Python基础知识汇总

显示全部楼层 · 2019-6-11 00:22:31

1.执行脚本的两种方式

Python a.py 直接调用Python解释器执行文件

chomd +x a.py ./a.py #修改a.py文件的属性，为可执行，在用 ./ 执行a.py 文件

2、简述位、字节的关系

1bytes=8bit ,2**8=256,可以代表256中变化，

3、简述 ascii、unicode、utf-8、gbk 的关系

ascii 是最早美国用的标准信息交换码，把所有的字母的大小写，各种符号用二进制来表示，共有256中，加入些拉丁文等字符，1bytes代表一个字符，

Unicode是为了统一世界各国语言的不用，统一用2个bytes代表一个字符，可以表达2**16=65556个，称为万国语言，特点：速度快，但浪费空间，

可以用在内存处理中，兼容了utf-8，gbk，ASCII，

utf-8 为了改变Unicode的这种缺点，规定1个英文字符用1个字节表示，1个中文字符用3个字节表示，特点；节省空间，速度慢，用在硬盘数据传输，网络数据传输，相比硬盘和网络速度，体现不出来的，

gbk 是中文的字符编码，用2个字节代表一个字符，

4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8 是3 bytes=24bit

gbk 是2bytes=16bit

5、Pyhton 单行注释和多行注释分别用什么?

单行注释 #

多行注释 """ """三个双引号或是三个单引号把要解释的内容放中间， ‘’‘ ’’’

6、声明变量注意事项有那些?

万能避错规则，以小写字母开头命名，可以加上下划线，或者数字，

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

.pyc 是编译py文件后的二进制文件，用于加速运行

10、写代码
* k* f, e9 Q3 sa.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
print('ok')
else:
print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
name = input('name:').strip()
pwd = input('pwd：').strip()

if name=='seven' and pwd=='123' :
      print('ok')
else:
      print('error')
      count += 1
for循环：
for count in range(3) :3 ~% ^# e3 p* Y% y$ \$ C
name = input('name:').strip()
: G  P, B$ m# J5 c pwd = input('pwd：').strip()
- I* B. g/ }# M2 j# d! ]) s9 t- l, h& z* F
if name=='seven' and pwd=='123' :
" Q! u3 i  e; k       print('ok')
7 f! Y& I) u0 l- m& s' |5 m else:2 n0 }& B8 N, s! `
      print('error')
! x& E( S, i3 [       count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
name = input('name: ')
pwd = input('pwd: ')
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
      print('ok')
else :
      print('error')
      count+=1
for循环
for count in range(3)  :! n& E  \1 A# F  B) t) b2 Z- W
name = input('name: ')* U* k$ X& H+ I, D! p
pwd = input('pwd: ')
9 ?2 t( a3 r; o8 d) Y- K if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
; D6 E5 P' F  x) T4 }( C/ @       print('ok')
  x; M, I/ k% {3 ]: C else :
) F+ M( V/ s; Z  F" ]- x       print('error')
0 g. l" v, z* H       count+=111、写代码
* }$ R2 ?0 Y% t8 x: q7 F9 K: V+ B& W0 ja. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
if count % 2 ==0 :
      num=count+num
      count+=1
else:
      num=num-count
      count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
if count % 2 == 0 :
      num=num - count
else :
      num=num+count
print(num)

c. 使用 while 循环实现输出 1，2，3，4，5， 7，8，9， 11，12

count=1
while count < 13 :
if count !=6 :
      if count !=10 :
         print(count)

count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
! q2 G8 D: W: d0 D) T# `( w% S if i %2 != 0 :
) r7 L* s! G  ^6 Q       print(i)

count=0
while count<100 :
if count %2 != 0 :
      print(count)
count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :+ K$ i2 d- A# L# \# Z  j
if i %2 == 0:/ R( b; W4 e' B5 y: t/ m9 D
      print(i)

count=0
while count<100 :
if count%2 == 0 :
      print(count)
count+=1

12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制 0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

n1,n2是连个不同的变量名，但值都一样，都指向了同一个内存地址，

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
print(int.bit_length(n1)) 结果 3

18、布尔值分别有什么?

False .Ture ,或1 和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"4 K1 S/ m+ g7 S2 ]! \; ~
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p')) apex
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e')) ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
print(name)
0 y% i5 A4 D7 s7 g" bfor i in name:
. l* }2 c# N" e; ~8 E2 y print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain' ?, z8 a2 N* a& ^, q  K  `
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
" |  ?' O$ ]! o" z  v! [, yprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    " _3 `8 x8 I8 j& `5 g
print(li). g. J1 `# T8 k; |+ s2 s
['alex', 'eric', 'rain', 'seven']
3 }0 Z1 M! g# Q. W7 A1 A9 cc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
, O7 {7 W5 J  H& Sprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
! Y1 a" h" s' ~% @9 bprint(li)& [! O- W0 o1 ]$ c" _( l
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
4 ^0 _! i, m0 X0 f* z) Gli.pop(1)9 c% }) S9 V/ z" A  d
print(li) ['alex', 'rain']( P% U* A. @. x7 G% z( {
指名道姓的删除li = ['alex', 'eric', 'rain']5 [( |+ T$ _; t% }+ r* _& g8 ~
li.remove('alex')
8 n- `$ i  A$ b4 ?( Eprint(li)- f0 U. p# @' u3 }4 Y0 U
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']( p* L! A( Q. I. M0 G0 w/ x, b
print(li.pop(1))& O* c3 p( h6 D! y$ r% ~1 X
print(li)# l, O. \6 L  Z8 w  U! y
' R- E) ]( r% K( G3 l+ E3 ?
eric* v- l& z2 ^2 W, M
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
9 l8 C' M/ b- s& j: K1 ]del li[1:]) H! G+ y" V5 q( F% |' w- q
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)9 v! J9 G: C! Y) F" F
li = ['alex', 'eric', 'rain']
& |& L2 ^/ N, m2 ^# t1 X, xfor k,v in enumerate(li,1):2 K: q$ H+ l) N9 Y5 ?& s
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]$ B" n. F3 _. Z. D3 }/ _* o
a. 请输出 “Kelly”1 ?6 s( V( j( v. h' z( R1 k
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]! |4 X; I+ A5 k! h5 k4 U! e( M
print(li[2][1][1])
4 S* o2 c& `2 j; _9 p6 B) c" Ib. 请使用索引找到 'all' 元素并将其修改为 “ALL”
: v) c! X( _* _" ~li[2][2]='ALL'; e1 H9 i, l0 d5 J3 s( w
print(li)1 I* s% |5 z5 S3 L4 n- a
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')! n! |" o: _5 X6 h' [
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')3 N! T) ?# i% y& t/ g
print(len(tu))( G: `7 m; k# k1 C; q  E
b. 获取元组的第 2 个元素，并输出
' O& t7 ~. W* aprint(tu[1])+ z/ w1 O, Z8 [. f# `2 a& P  K
e. 请使用 for、len、range 输出元组的索引3 v) l$ T7 Y4 E9 I% `
for i in range(len(tu)) :
8 y+ }1 j6 i: f6 A. ~( @0 l print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)4 C7 ^! ?, P$ B6 l7 s. a. o! a
for k,v in enumerate(tu,10) :3 {8 E& R- {' w6 B5 R! P/ n2 Z2 t
print(k,v)
1 B8 M. r/ g$ l0 W% t10 alex
8 `7 T. u' m! }7 ~: U; k; z11 eric! i2 P) t8 C" G' ]
12 rain
( K$ d& C/ Z' ^2 ?" n) q# J& s* B3 Y( w
for k in enumerate(tu,10) :
0 h% I# V0 P* M% Z$ p) _$ U+ C. z print(k), P, V, g9 V- q: w) T
(10, 'alex')
# l+ j( A/ x9 }  Q* r. ^- H(11, 'eric')
) w* F3 K( @: `0 p1 O(12, 'rain')" ]3 X  c5 N3 J  D

) {" i; ?) z3 A7 c1 a: Q. f, ]: m# w' i
25、有如下变量，请实现要求的功能) S# z# ^' N$ ]+ k" u7 z+ O
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
$ \7 n) i' d  c
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以1 c% g  z; ~, W' E2 ~4 O! I
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
/ b: s8 i; C% q( v2 H+ j  L3 W) W: @res=tu[1][2]['k2'].append('seven'), O/ G: ~# |: n% w7 c$ p- W! q

! ^% \( h# _* G( g6 S" Z, o/ Rprint(tu)
6 e  s! M: j+ z  |# \26、字典4 Y; e6 t: H, }1 W$ ^
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:! a; [% c5 _* E4 K) [1 x. m. z# `0 W
print(i)b. 请循环输出所有的 value
  f( ^# }+ c5 J7 g0 T4 L' Gfor i in dic:
2 H8 _# A( y" y print(dic); |+ K& L% ?+ p
c. 请循环输出所有的 key 和 valuefor i in dic:
: i* N: \0 m+ f4 a8 U4 J' Y' }* Kprint(i,dic)
( }- X6 Y3 ^, Z% v1 e* H$ c" k! Ud. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
; K  r2 H' `0 idic['k4']='v4'# T5 \; ~% F/ s6 q# ?" O0 W8 h- T
print(dic)
! k# W6 c- H4 o* e/ I! F# r8 me. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
) X" h' T8 K/ l1 h; c5 q7 vdic['k1']='alex'' p8 H9 p* J+ r! _
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
( M; e/ j7 P: P; z8 g/ U3 `7 Mdic['k3'].append(44)
3 s6 s6 c# B7 h+ F8 iprint(dic)7 h. [; N0 z1 ]9 Y" F

' v; W/ O6 l: |# T! Q6 \$ E7 [g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典8 A1 m  }( Z- C* O  ^/ @
dic['k3'].insert(0,44), O' |8 u1 Y  C7 L
print(dic)
" [5 l5 c. l$ q' M27、转换! t% ^& k' Q$ s2 Y6 _
a. 将字符串 s = "alex" 转换成列表  s = "alex"
' [3 f$ e- j- r' z+ e4 [/ F( B( p1 e0 S% U7 ~( q) n
print(list(s))b. 将字符串 s = "alex" 转换成元祖
' Q+ W6 B3 K- w1 |9 v2 h" H5 _3 Ks = "alex"* W5 A, I8 D* M
print(tuple(s))
" p1 X+ c5 E+ P: l2 C
8 T1 d+ v( L5 r8 @b. 将列表 li = ["alex", "seven"] 转换成元组. ]6 R& N& L2 V' M$ c
li = ["alex", "seven"]
# B) j. d4 ?6 A' o: N$ y# ?print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表* ?* t8 o+ Z4 {/ X) [& T- j5 Q: F
tu = ('Alex', "seven")' Y$ W; |& p2 ?8 j1 @* W  E# k$ }, R0 K
li=list(tu)
+ l  m( Y1 F- U& i/ tprint(li)2 A  a8 w1 y; A
. O- V; q2 Z0 d( J6 \- _6 c3 D. ?
5 O; R, \9 `8 \1 F! m4 f
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
* }' R: o5 W* f% o  `$ `
- `( z. `' w/ @* W9 {dic={}& Z4 i! M) z( Y) a" f8 \4 ?: m
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面: A* ^* G: u7 E2 o; A
dic[k]=v* G% t6 A  ^- E6 T: @
print(dic)27、转码n = "老男孩"
7 Q. F$ ~' K  r/ z- ]a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"# t+ i) T+ w! V, _  c: T8 x
a=n.encode('utf-8') * L9 S% B3 ~" C6 N2 G' ?
print(a)$ [% `' K5 f% e+ o
b=a.decode('utf-8')
. j; d+ t! j& P7 qprint(b)
, t4 p( _! m0 p: {b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
: f( `7 d! d- }4 m# qprint(a)
2 f: ^( j% T9 i# Z( Vb=a.decode('gbk')
: b" E; a7 c+ I) D( C' k  o8 j. Jprint(b)28、求 1-100 内的所有数的和
% z" Z8 K' }3 S" wcount=10 z& Y0 E% {! h
sum=0
7 u# l3 h0 ~+ p1 p+ O1 }for i in range(100) :: J1 }- o" E6 M. _; c
sum=sum+count( E# X' G$ a1 g
count+=1! q' f$ [- u5 r' r
print(sum)1 N: w. _4 h6 }. ?

3 e5 z! n0 {# @' S, h/ x6 Pcount=1( C+ `6 y) x5 E3 L& k4 C
sum=0
6 i% X0 D: x, E9 |) R+ ~0 v- }while count<=100 :
% N- ^' Z) X5 h) V$ p0 G4 v& O. f sum+=count
2 R0 u2 a3 x" |5 i8 O! B/ b+ E count+=1
8 F! @$ ~9 n( c8 Y, V+ D, yprint(sum)29、元素分类, R5 {& Q) v5 G6 h" N) q6 H# [# _
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
+ Q' E* b- J. S6 ~; H6 i将小于 66 的值保存至第二个 key 的值中。
7 `9 ?# U6 @; h7 K6 |即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}& [' C8 x- J" ^9 ~% O0 W; q
li=[11,22,33,44,55,66,77,88,99,90]
  ?9 J1 L$ N- a& u; }dic1={5 f) v9 X# j! Y7 h1 k, ~& X
'max':[],
  \2 `( D% T+ v# i8 C0 K: r3 E% t 'min':[]$ K' t# i5 Q4 \+ a8 k9 O
}
5 a- ^( E8 i& C  r) Kfor i in li :
% j8 g  H, z0 C7 L, G8 s. H6 p: F/ G if i <66 :
; Y( L/ g; {3 w1 {       dic1['min'].append(i)
: d) o" ^' ^) w# v9 Y else:
0 y7 }" E! ^* @' [7 M9 |% D7 C# T; t       dic1['max'].append(i)
! T" p+ f% j; k. B' _6 b. X) uprint(dic1)
! y$ {, z* D+ z) j( [" `9 Q. g
8 E  B  R, O4 N9 H0 x- T6 Q---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}. N$ R& X2 _  R, g" T# b

Python基础知识汇总

主题推荐