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、写代码6 l6 ~6 L% |: s& o. ]# e$ ?
a.实现用户输入用户名和密码，当用户名为 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) :
, f0 R, Y  W! R4 R1 T! n7 H+ e# E name = input('name:').strip()
$ U& u5 Q$ t' |: l  B pwd = input('pwd：').strip()# ~+ s1 s: z) U

$ v: T9 H5 m: @4 u( u0 ` if name=='seven' and pwd=='123' :: `& Y# M/ k$ _1 w( c7 c
      print('ok')
" m( `3 J9 k) ~+ n else:
  J+ U. ~( h& Y" N8 ?/ a4 x       print('error')2 L. @' G+ I+ |* J, P$ Z! m
      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)  :+ i2 K& c: h5 e- W% S; S
name = input('name: ')$ W3 f7 @% H0 [: M& y
pwd = input('pwd: ')
* I, u' ]0 z$ Y if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':+ F& C( M$ Z* ]) t- Y+ f( f; `
      print('ok')
0 r9 R! h" W5 U; N* ^0 M) R% L. p else :% F* \+ }6 d0 W2 h, M( s2 C
      print('error')
, Y; D1 p# b' i( d8 w7 `7 g' B       count+=111、写代码. ?$ ^+ T7 _7 t! {
a. 使用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) :+ l+ {% s6 U9 |* L* t* i" ^9 T
if i %2 != 0 :( ]/ m% n$ e: ]
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
/ L+ [- o0 d. _: N6 v6 C1 K if i %2 == 0:
2 G0 G# a2 @! v' `# S0 v8 Q       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"8 ^& _( V9 S- l+ h0 [, O
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)
2 f, p4 h. N. m! t) S2 _for i in name:! B1 l& G! n; Q) r! r
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
, [* ]7 i5 K; j  @/ K) d22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
, H( G3 `6 H% F7 d" u7 mprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
0 z: v/ V' G& w# ?2 I; j& Aprint(li)" E7 P' }1 B; Y! |1 |) P
['alex', 'eric', 'rain', 'seven']  n6 P9 G8 P) `+ i
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'), |; E0 N. c% i1 ]: d: p1 t* w
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')* }3 F" d( I: R& [! t
print(li)
! z- C1 b- I4 B8 x! G3 Te. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']" N2 v3 S9 l% m1 Q) ]" s# e
li.pop(1)
) h- z# i5 c0 M# n2 C0 Nprint(li) ['alex', 'rain']
9 R- w! r3 v, G) R, X指名道姓的删除li = ['alex', 'eric', 'rain']$ c$ h. n5 ]  {0 N" M  \* ?
li.remove('alex')
4 I, n5 h3 ]: s; k8 S" {4 a7 F8 Sprint(li)( C+ _. O* y* A) c! `* V
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']5 u, r3 B1 p& C' [& p
print(li.pop(1))
* Q; p* |/ t: `$ k, [4 w- w' Iprint(li)
9 b: X# |, F) K# i1 `0 L- ~" L1 n( |0 [
eric2 v! N) E" P$ o  y. J
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']/ X+ x8 g' E/ i# u) G* K/ ~
del li[1:]
" _6 I3 x4 k! ?print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
' W7 I$ v) |8 ^0 S" w8 [5 C% j' Hli = ['alex', 'eric', 'rain']* ~$ C, h0 J/ G4 }4 E
for k,v in enumerate(li,1):
1 i7 o; R4 U+ k* }: y, l: M print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]; ]: G  X  x2 [) z7 @! a7 b
a. 请输出 “Kelly”! u# U- ~6 q& x; q/ i- ]
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ a6 A) e! x# u6 C2 ]+ `, Lprint(li[2][1][1])& f' H4 I6 Y& [9 d# I
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
+ N1 d! a" S2 f7 e+ H! J1 Xli[2][2]='ALL'
7 ?4 j' C8 m2 Nprint(li)) d& M4 i0 q6 G6 q! {" x
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')8 l9 W& f  b' p- @, w1 h9 J
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
/ k  K& _" o; b7 V1 e. E  Lprint(len(tu))
( i' i+ Q% f2 }+ e7 vb. 获取元组的第 2 个元素，并输出
. M$ }1 b& Y) E4 G* Gprint(tu[1])
1 j( u4 Q$ |% ?3 o$ G5 ne. 请使用 for、len、range 输出元组的索引
. O  [' k% l: y8 g7 v6 v! C! Sfor i in range(len(tu)) :
7 M7 b! V( D$ {4 c% B6 z print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
9 Y, o: X- W' E' A6 Gfor k,v in enumerate(tu,10) :' M: }- f+ ]% n4 C
print(k,v)
9 Z% Y* `- G3 X/ F% O$ ^4 q& X10 alex6 s1 v) [; Q& l3 U4 a
11 eric
2 Y" p: y2 E. ]7 Q% F4 ~1 r, j12 rain
% }% K) ]# w* w( k2 r1 ]7 s
" b# m( `8 H* D( H, w$ sfor k in enumerate(tu,10) :$ @" _: f5 z2 ^3 {5 o
print(k)9 c  M% n% ^3 G4 d. O$ @
(10, 'alex')2 A+ [6 E& j7 ^2 C; Z
(11, 'eric')
/ b5 a  A( f1 Z! w(12, 'rain'), X7 X! T, w% q4 X3 W  F& V0 s$ n
. l2 ]( ?' g$ X, x% v4 V8 f

/ v; P& b3 f) m. ^& v* E; p25、有如下变量，请实现要求的功能
3 p% ~9 N1 F$ Etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
+ n: K9 u1 D2 G
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
( _6 c$ [/ B+ s/ |3 V& f6 _tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])8 A% J. q4 j* F5 u/ t1 r, J
res=tu[1][2]['k2'].append('seven')
, m+ c# B# d; g9 i9 a% X6 G- r3 F# ?" A* _; r
print(tu)
* {9 ]: d( m3 a4 s& e/ o/ d26、字典
4 Y- z( c) n" Q& O" t5 Idic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:5 v/ g/ v) K7 k6 G/ B6 V1 {! W. W0 ]
print(i)b. 请循环输出所有的 value
. K: x4 u: {) t& ffor i in dic:
" r4 m" _  B! p print(dic)
6 m( c- I! d; Y/ R+ f. ~: A* B! @c. 请循环输出所有的 key 和 valuefor i in dic:
& G1 g5 }$ @& A: p# y7 uprint(i,dic)5 W* s& t- p5 ^8 q
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
% |' @5 ?1 Y: p/ ~/ {1 \dic['k4']='v4'
4 X8 H- p$ Y4 f6 m' vprint(dic)
1 o" W3 @+ S4 x7 d- }! |e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
. n! j% s  `% vdic['k1']='alex'1 z% k! N* b  i8 K: M" j& b/ D
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
5 H8 |  O3 }7 O1 w; |% rdic['k3'].append(44)
6 _* [+ |$ t5 K$ S/ }print(dic)3 k, Y) I/ A+ j3 f3 _

7 ~* X) \8 q# o& Bg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典4 @) E) ?/ E, g+ v; V* _* H
dic['k3'].insert(0,44)
' T( G! e' X  _2 D$ x( ~print(dic)
5 @% q0 l6 \. x. c: w4 L' y27、转换( G9 P( o; O1 V7 H
a. 将字符串 s = "alex" 转换成列表  s = "alex"
/ _* ~, T3 w  i3 u1 O( d% s& R9 ]& I8 z
print(list(s))b. 将字符串 s = "alex" 转换成元祖$ y  i: N  ~7 y, c
s = "alex"
: Q0 N) s" m1 A, w' x  L; u  mprint(tuple(s))
) h  H; ~2 C- A; j( c$ [9 s# l6 u, Y) N5 P5 D: t) B
b. 将列表 li = ["alex", "seven"] 转换成元组1 P. z. H% l0 G+ Q6 r% k9 b, p
li = ["alex", "seven"]- F" ]0 h" T8 @" V
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表+ P" b! U) Z! i8 A
tu = ('Alex', "seven")
3 Z/ q( y8 E6 K$ G  o, Gli=list(tu)* h' }* ?# L; O5 O, I1 J6 B4 Y2 s
print(li)
2 d) [, @6 t! m
# W$ r( Y! b. w4 G$ ]% l0 L1 Z" |" W+ y8 Y7 I& i, J7 g
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
( z5 y" L: K5 I' c
) y: r% F- E* ~2 c5 l( gdic={}- a1 q/ D: n5 ]0 E! c0 ~( t0 s
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面* E" X" ]& i% K7 k9 y5 Q, R$ ?' R5 |
dic[k]=v6 Z1 V2 t8 A4 K+ C# i# ]9 N
print(dic)27、转码n = "老男孩"7 x# m% v: m7 K9 z) a4 m
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
( `* F5 j; m' W4 {5 r( F0 sa=n.encode('utf-8')
* Z/ v9 M! w. K: Sprint(a)' L$ j: v4 V8 A& `4 Y. ^% S4 k
b=a.decode('utf-8'); [* P6 g" o6 V5 g' N0 {! ~3 o- y( d6 [
print(b)
; ^- J& E' ]2 k8 B% q; cb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
' V; Z/ y1 z, s& @print(a)3 N1 G5 G' A) F2 P. O
b=a.decode('gbk')
  d. g- S: T/ K9 Y" y2 yprint(b)28、求 1-100 内的所有数的和/ {. o0 @7 ~1 @; _4 _  j
count=1( T2 f" E! O+ {+ O6 [7 t: C# v) C
sum=0  d7 W/ I4 p4 s" E$ P; {
for i in range(100) :- Z% N4 w+ X( H" l" ^: {) ~
sum=sum+count
7 R5 j3 y8 l( l$ {' c$ q count+=15 M' P) S) u7 z- @& |" B- E+ F7 ]* n
print(sum)6 R+ Q& D/ G- W

, v1 r: R" X0 J$ A4 |# l' g) jcount=1
4 V7 [& N& L4 X0 y! J8 o9 Lsum=0
' ^/ y6 W# z0 ^: Lwhile count<=100 :8 w* E- _3 n3 Z( i7 i% X! W
sum+=count
& r8 b" z) m1 K. D4 U2 F5 m+ k* O9 O count+=1
! y' ]; P" M: u/ _. Q7 ~6 S; \print(sum)29、元素分类
9 t/ z$ q+ m! u* C9 ]; Y7 ^( o有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
+ o4 O$ f+ f9 }# s将小于 66 的值保存至第二个 key 的值中。% G5 ^8 P; q' v: v( R# j4 C6 x
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}2 L/ E7 _1 D! k. E
li=[11,22,33,44,55,66,77,88,99,90]
6 U% U1 H0 M0 f8 z8 m; G7 Ndic1={# A: k# _1 `9 }
'max':[],3 h+ d% I+ U5 M, o
'min':[]
, z( w' t9 G! [, x}* ]6 ]+ M7 x# t3 Q* n; h5 }5 \! h
for i in li :
  K% j! i; l7 k% i; q if i <66 :
! _7 u$ q8 p3 C: J7 W, T. f       dic1['min'].append(i)
& _. b- C( G0 e2 f! h) S$ z! s else:- ?0 e4 t# C$ r" u
      dic1['max'].append(i)2 Y4 j# l3 M% L7 M1 r9 f$ C, ^5 i/ v
print(dic1)  A8 p/ T; M. S1 f+ i- L8 u5 N  N

9 M3 V) |" B9 F2 ~---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
  |  Z( H* _- ~7 g7 L, Y- w. H. F

Python基础知识汇总

主题推荐