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 A0 p) L% j* a. ?  C
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) :" w( }) E0 X) y( y# S6 D
name = input('name:').strip()
$ Q0 @0 \5 K4 Q' @. w/ B pwd = input('pwd：').strip()- @6 M' U7 p8 p3 s# j% {  P. h4 l$ q
* J  |2 c" N" f; o
if name=='seven' and pwd=='123' :/ d1 @8 n5 t+ m
      print('ok')
5 w5 {1 L: g  P2 V0 v6 _2 W else:5 V- G" e5 a! Q
      print('error')
! ]7 ?7 u: r' U. _& Z. t1 C3 k3 Y       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)  :
2 r! h$ Y" \9 T  s name = input('name: ')
8 O' v; ^; e* b" _4 F! g pwd = input('pwd: ')& k9 z+ j# M1 ^% b5 `
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':8 u$ ], o/ z3 S0 u9 o  k
      print('ok')
7 B  z5 g/ ?2 M: m0 d else :4 Z8 @5 d( Y: s1 Q* g9 h. _
      print('error')
1 ]3 ~6 _* Y# p! D$ d- B       count+=111、写代码
5 E% @  |6 A& a; r! @7 e4 b) Ta. 使用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) :( j* m; S& \- k9 \' e# O/ @$ J
if i %2 != 0 :
2 L* ]2 ?& |2 Q, ?7 k       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :4 `0 V: ?, H0 O: X- V/ i$ H/ e
if i %2 == 0:3 C* `+ O2 r5 U9 i0 C. n/ K
      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". S: s' q6 n- e2 ~/ A
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 |( C  t. _0 L7 d4 w
for i in name:
9 A0 ~8 V. \7 `" Z6 u7 \- Q print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
5 H9 e: m0 X9 Z$ k1 B2 \+ j22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
8 x$ L& ^% ]4 X, G8 Nprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
# T9 K1 l( g6 V" u& x0 `4 qprint(li)8 V/ C1 R9 J  K
['alex', 'eric', 'rain', 'seven']
1 W6 t0 P' q( K+ c# k5 ?c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'); f9 n2 ~5 I8 Z6 Y& _- |
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, s* P+ t$ s; {! ~. [print(li)
+ v: K1 f3 O" P6 \4 V  _: Qe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']7 |+ g4 x, a; C6 w% d0 I, E
li.pop(1)
5 @1 F6 Y5 s& {& C, t7 ]# Aprint(li) ['alex', 'rain']0 |: X9 L+ m; p* w1 }( s+ @4 J5 x
指名道姓的删除li = ['alex', 'eric', 'rain']
. l; s6 s9 I" N, e% n8 n, O8 Tli.remove('alex'); J& d5 {* R1 m) G" ~/ F
print(li)
7 F& M( l. S3 _5 j7 H" N0 Z3 {f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
$ L4 X3 q$ ]6 Y6 m+ Aprint(li.pop(1))
* U6 \) W& ]. l  g0 q" ?, {print(li)
' R3 K6 M3 a! _+ {4 n1 H* p% G2 D
/ k% H1 J, l( y: r4 }0 ceric$ h6 u3 W# h& m
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']# k, Q; G8 }2 W+ ~' _
del li[1:]
& c7 h4 T: a( lprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
( w7 M0 t, P9 r, Nli = ['alex', 'eric', 'rain']7 G; l5 B- o' R# r( f- h
for k,v in enumerate(li,1):2 T9 G5 D3 P- \# B9 G% s
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" {: E7 M3 H7 V& E" F1 Ia. 请输出 “Kelly”6 H) x7 _/ h) Y5 E4 x! s9 [
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]3 d- p9 t2 g& ]0 k* F
print(li[2][1][1])
: ]$ n) y  H! z- L' J% r7 T9 ib. 请使用索引找到 'all' 元素并将其修改为 “ALL”7 K; F, h& A* K1 x* k7 z/ _
li[2][2]='ALL'1 h1 J, Y( y3 H5 Q' w$ H/ @) \
print(li)& G% G* q$ h, C( T/ \
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'). Y# }1 o3 [% j) w8 W
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')9 m9 s6 ]3 N$ d7 d; J+ Y
print(len(tu))
' J2 t# n4 w. n7 Vb. 获取元组的第 2 个元素，并输出
) ~2 E' ~: Q# Z5 s2 f  tprint(tu[1]), ^( s# {5 s6 S* s
e. 请使用 for、len、range 输出元组的索引6 ^" G" Y, Y% _2 s" ]3 b# l
for i in range(len(tu)) :
3 A1 f7 L4 b' }! _% K( U& @$ P' G print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
% Y' g# T0 J% c1 ?for k,v in enumerate(tu,10) :
4 t+ y9 S& L8 j' [- F7 g, T7 @9 r5 r print(k,v)3 i( _7 _, |& d. C6 y
10 alex3 a% r7 n7 w2 K5 r5 h
11 eric
( S1 `( T4 O' g: r12 rain& J# W" u0 }4 {8 u& T

2 j( {# w. @' _7 s. r1 y5 g% b* U' Ifor k in enumerate(tu,10) :
2 p+ v7 l7 I# q+ X+ q print(k)- y; r# T1 ~, e4 f5 q
(10, 'alex')
3 ~: [+ t/ U* r) j, _% K(11, 'eric')
) {9 Z6 R/ q6 @# j/ m5 S( k(12, 'rain')
8 f" k% I7 C8 u+ c1 k4 t, Q+ ~' U4 n/ o# g- N* x$ ^
4 v+ W, O) H, [6 f5 y
25、有如下变量，请实现要求的功能7 ^, w3 {# [" c$ }$ m4 {. f' j
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
0 p: F+ ~9 a; b- K
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以& W5 k4 _2 ^. I: A" f: x* E
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])$ f3 H- I) F2 {& N7 |3 _
res=tu[1][2]['k2'].append('seven')
% v5 m. E/ I/ s$ T' R8 \" O3 j$ k* X6 [, u- k$ q" I
print(tu)' Q% _) J) q2 ~# R1 ]" E8 f, B. A
26、字典7 R+ }6 s& R0 a4 X% b2 Y
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
; o$ Y! t9 ]) }' m) i print(i)b. 请循环输出所有的 value
! S6 E% _6 x! X. Ofor i in dic:  N9 }8 I/ J8 W- G2 r9 U; j
print(dic)8 s4 V# x8 k, e$ N/ B& e* W& x1 H9 I
c. 请循环输出所有的 key 和 valuefor i in dic:
7 M. s- h4 s, K8 J" Lprint(i,dic)" x, s6 \; }) R3 P
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
/ a# Z! i; v7 }8 E1 Jdic['k4']='v4'
4 r. l1 v  p! K) |print(dic)
5 F' N7 T8 a& s" ^7 h; ]e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
+ ]* E6 Z& q: K; g5 J. e+ F2 t: w9 Ddic['k1']='alex'
/ M: i; q( m; B/ C0 e/ W9 Bprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典+ ~4 O( w# Y1 }: T7 o
dic['k3'].append(44)& m1 b* I4 d. d/ e  `! c7 w
print(dic)$ r3 @4 X/ }4 A6 M9 V7 i7 [

6 g6 i5 W. L  `4 X+ q( s' }g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
/ G4 k7 {- K" v3 s* ndic['k3'].insert(0,44)7 y' I; s3 e6 N+ h6 l5 f. v
print(dic)
+ i$ v) O- @) h0 s4 l27、转换
) c. q+ g8 A9 m6 h' e! i; pa. 将字符串 s = "alex" 转换成列表  s = "alex"
- w4 H- d8 V( i1 \, O& h% y) M% S1 O6 B& |; h0 k
print(list(s))b. 将字符串 s = "alex" 转换成元祖" U% J, i" y  g, ^
s = "alex"
' Z3 T0 w2 I' ~print(tuple(s))
9 K5 F8 x+ B: Z1 ~: ~5 t& p) H5 S/ M. t- q1 {1 ~" m* {
b. 将列表 li = ["alex", "seven"] 转换成元组* v3 o) y- I: E
li = ["alex", "seven"]
2 G: ^# E% D" c4 x/ nprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表" Z. k% P) |, y; j
tu = ('Alex', "seven")
9 S# C/ B, v' ^3 Z. |li=list(tu)
0 b6 Y0 ], ]+ P% |; ]5 }" ^# Sprint(li)
- J  p7 e! H( I4 P; H; q/ x8 V2 X$ ^: V( K5 O6 I- b) G

1 f3 l) D( V$ s" Z9 K, B+ Xd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增  o  x% a. o( @" \4 }( L$ {( w
& M; Y* k. x8 f0 j( c
dic={}
+ @: e. q! E2 S& P+ o/ `) rfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面+ f; W  z/ z0 W& a7 |' j( G
dic[k]=v
$ j4 i. Q3 J; e0 x' C( t& U print(dic)27、转码n = "老男孩"* v+ l. L6 q( f: w0 ^
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"+ X3 }6 _+ U5 s) E+ _6 L2 N" v
a=n.encode('utf-8')
7 P& u  B5 J+ C- U' `& D9 cprint(a): v4 y) o2 }: W9 l0 h2 Q  P
b=a.decode('utf-8')  b% I3 e( b7 y6 U( C2 j# y' \3 R: g
print(b)4 A$ v/ _$ Z( B4 a! {
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
& I1 r+ ]8 z; c+ P- |9 Eprint(a)
/ D. x2 ]) d7 _$ |; j' \b=a.decode('gbk')$ M% P* R1 C% t. H0 g. C1 i; T
print(b)28、求 1-100 内的所有数的和! u' V" ~+ o! r' R6 ^7 {' Q. F
count=1+ i5 [4 F1 S) `. z" j+ g# N4 ?
sum=0: u: e4 T- c$ S( N% @1 G0 q
for i in range(100) :7 l, q" P* K8 Q% I5 _0 a9 w+ V
sum=sum+count' G0 ?  O' ~. I7 S
count+=17 I+ P6 C& [7 O; N2 V1 w* ?
print(sum)
! w- s% h% c8 y0 f# s9 h5 A) ]1 `# E5 w' O6 R! p6 u& {
count=1
7 v  x  ]( L  o) E" g( usum=0
. v# U2 r+ ?7 i7 }7 y( ~/ lwhile count<=100 :% X. E6 L, m! w) [3 k
sum+=count
# p8 ~: V( ?; V. g count+=1' p( q! Z+ r* q$ ^' G
print(sum)29、元素分类
1 E5 G5 z8 B8 J# ?3 h  s有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，/ p: Y0 J$ f# ~: J. ?2 k9 {
将小于 66 的值保存至第二个 key 的值中。4 S+ \7 a( t% ~' T
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}4 \+ i; o5 V- G" g( M" k
li=[11,22,33,44,55,66,77,88,99,90]
9 l1 G* z* O" E$ Fdic1={
* |1 W  z' x+ T8 o# A- E5 f6 f: ` 'max':[],3 {7 a+ F8 D) Q- t+ o* R
'min':[]* e) \8 z+ h, a$ E, g1 V  e
}
  J, K3 \) {6 _% o! C9 I: [0 Zfor i in li :* D# x) d  O! }) i6 B
if i <66 :5 j% `) X3 e- K$ t
      dic1['min'].append(i)
, Y8 x- p4 i+ O1 w% w( w6 R else:
3 B0 _/ A- j* k8 `9 _: j       dic1['max'].append(i)
, @5 {' e, e$ [$ |+ C! O! q  |! i2 hprint(dic1)4 \/ d4 b" u- j/ D

! p- O# N, T6 L/ T---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
5 r+ o% |& z6 a5 I! w; g8 V

Python基础知识汇总

主题推荐

浏览过的版块