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、写代码
2 ?6 |% w# M4 B6 ?: |4 ja.实现用户输入用户名和密码，当用户名为 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) :& Q; y7 s: d, P* a3 F
name = input('name:').strip()
/ H& X) ?' \3 @, B; N6 P1 D" R7 `$ x; Q pwd = input('pwd：').strip()+ Q' T" Y; f* q) B* V
! H9 T8 J( C0 P
if name=='seven' and pwd=='123' :
0 B; O1 Y9 V' M' L5 {8 ~* \1 E# z, D       print('ok')& Z1 S2 H5 d( q; c, U
else:
, W- m, q& k  G  }) d+ c, c) Z( c       print('error')
; P- S* m( T1 X- C7 t  `8 O       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)  :
: T0 a# ^. V* } name = input('name: ')8 I  ]) [- E: q# f- t" O2 {" g
pwd = input('pwd: ')
" j4 G* |6 |. u, p8 L7 K if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':. }7 B- Q+ ^* \+ k& C0 ]
      print('ok')! ^5 y4 L8 [1 u2 y+ P+ a3 T$ n5 p
else :3 d" ^3 T" S/ G+ O' T6 a' @
      print('error'): c) e. ^  N8 v$ h$ h: i2 }: E. R
      count+=111、写代码% L2 z) S! E9 F9 b0 k9 A4 C
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; J5 @' ~3 e; @ if i %2 != 0 :3 `' e8 r! o7 V, h, n% y
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
  W. o, x& |- b6 r if i %2 == 0:1 w4 X, ?+ ~( `4 G
      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"
, z* j& I3 W6 t5 a& R( O1 la. 移除 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)
9 m+ C9 c: V; n/ e. Yfor i in name:
$ h5 m3 W- o0 y# Q$ j2 D" u; p print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
0 Q# q% B0 [) Y  M! |9 A22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
' _. g4 {% d6 x. k. @print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
& _" ?% b$ m: L2 y- @print(li)
1 v9 o! ~" \$ d ['alex', 'eric', 'rain', 'seven']8 n3 h, }1 Y! ^, S- t% k5 ^2 c
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
# O6 G* p' d$ T* X8 z7 R; O# rprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'): s7 L1 m7 P. S) G  z" p; z: y0 @9 y
print(li)
. l0 `7 B" N- H5 ]" B; {- Qe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']$ }9 w1 J$ S3 H1 w. C' J4 j# `6 q
li.pop(1)
6 ]2 F9 D" F+ D- C( T  Bprint(li) ['alex', 'rain']2 q+ Z5 K# r' P
指名道姓的删除li = ['alex', 'eric', 'rain']
" ^& j) Q% t( `) }+ z, G* Y% fli.remove('alex')" V* H5 |. e9 ?6 Z: K' @
print(li)
0 v- m& V1 y% m& y, {$ O; Cf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
' k4 u# }: V7 ]+ C5 C6 Vprint(li.pop(1))3 w* T  Y8 `8 M: y4 n
print(li)8 U9 W  G% q- A
! h1 ], L6 _" \. w7 ?- R
eric# J- }' F4 L# f/ b
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']# T% C! W) I0 T& ]/ l
del li[1:]
" [9 {0 S* z- H+ q, u# Pprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始). n- d6 ^. I: l  U3 Y2 p& X9 ]
li = ['alex', 'eric', 'rain']
6 Y; N0 S3 x6 l3 J0 Yfor k,v in enumerate(li,1):  t' }2 k! C- d/ W# O3 T1 U
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 C1 j5 j; Z: z8 I: }2 qa. 请输出 “Kelly”4 j+ J3 f- }; u) B
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
. [: o( @4 N, Q- }. A- d$ A) Pprint(li[2][1][1])4 N+ u5 o% G. n* c# Y& I
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”1 X9 ^5 g% A0 P1 o& e9 X8 F0 B
li[2][2]='ALL'. T* V# }9 o5 G9 e# v
print(li)
$ `; V3 n. q- ^% u9 ~. G3 [24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')$ `7 U) Z) L3 E$ h- t
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
* t9 f7 X" x1 c9 g1 ~print(len(tu))0 v: M  C) M4 M8 Q' ~4 t
b. 获取元组的第 2 个元素，并输出/ \/ [+ J  T6 M" L
print(tu[1])
- P7 d, o. ?$ l( A) @  H  J! Qe. 请使用 for、len、range 输出元组的索引
: M- P7 S3 G9 v: ]8 E% }2 Afor i in range(len(tu)) :4 C  P# d# `5 N% ?
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
2 m* Y& B7 T. W/ ^9 @5 ufor k,v in enumerate(tu,10) :$ E# X0 b  L. l, }' L
print(k,v)
% _& R$ g" d9 n: ~$ z& y0 }10 alex! ?* O7 u, [- E5 R
11 eric( a) ]  z1 r, x$ n1 W
12 rain
3 y; Z8 l, a8 @- z
+ ^0 e. s5 d% B4 m) i6 @for k in enumerate(tu,10) :
( s4 o5 j- ^- p4 Z print(k)- \- l' d0 h6 N3 n, q3 G& C, p
(10, 'alex')
3 `+ R& R3 |" d- b! l+ v; B) t(11, 'eric')6 L) W& p' w* K3 I) ?- o+ x5 S/ Y2 G
(12, 'rain')
9 R9 T, _2 ]( i, P* b
$ |4 A/ a0 G+ \7 p! l$ e) \. W: r% m& R9 t/ x4 n
25、有如下变量，请实现要求的功能/ y9 N6 T0 Y3 @( {. f
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
" S/ G% B, N7 x: K9 B
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
( k# b1 c% o; c" Ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])$ K4 b. W( r, y1 t
res=tu[1][2]['k2'].append('seven')3 ^6 W: E& I. `: A6 x

' c, @( x, d4 F# ~print(tu)! \% n( t, y! e5 ~4 E& H5 N
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:4 Q% Z1 L1 s; c' ^
print(i)b. 请循环输出所有的 value& j0 [' P& h5 A' o7 ]4 B6 ?; r
for i in dic:
$ @+ M4 _2 O+ [" U5 s; `8 k& |0 f print(dic)
! m% T! T6 f4 n( cc. 请循环输出所有的 key 和 valuefor i in dic:
, W2 [8 ]' Z# F' A+ _print(i,dic)/ K. h: }# J+ i5 _: C
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
  J% _2 V9 ~% R0 N: Qdic['k4']='v4'
; A" ]9 K$ K0 V2 Uprint(dic)6 P1 ?7 e2 Q; L9 H6 C
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典2 E- T7 [* ?4 p9 _2 q: t
dic['k1']='alex'
' O- M0 ~4 K2 g2 F# Uprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
! R5 X! g/ b$ N3 @dic['k3'].append(44)& C7 B4 |- ?  C& e
print(dic)
' O8 [8 V. s* X3 a* K  ^7 m
8 Y3 n2 y0 F3 M7 l5 Dg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典0 D% Y) p( Z, g3 f7 d8 I2 M* s
dic['k3'].insert(0,44)1 Z# q- o4 Q4 W& T7 x
print(dic)7 j  o0 }4 x! P7 E' p
27、转换3 V2 z, \) @: e
a. 将字符串 s = "alex" 转换成列表  s = "alex"
3 H) Y. ]9 ?) Y; y8 t$ n3 n
( \( s. G& T( Rprint(list(s))b. 将字符串 s = "alex" 转换成元祖9 n8 o" \+ r/ e3 `3 ^* S
s = "alex": q" G  r2 l4 ~& R2 y' I& C
print(tuple(s))9 T2 ~/ t6 V& v8 @2 {0 `% {8 o

* n! M/ u7 c  h, E3 z# \b. 将列表 li = ["alex", "seven"] 转换成元组1 k: P6 L9 h8 ~$ |1 v
li = ["alex", "seven"]9 j# L0 n9 E6 W0 x0 \
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表: \% m# [, n* V) @- `3 y
tu = ('Alex', "seven")
& A% t7 Q5 w2 q$ S. {% P" _li=list(tu)
( u! `3 L  d, N. p2 B; o. rprint(li)
4 j3 i. L3 {" j* g+ n) H' Q7 m/ ?  r" o6 N

% b# H1 F  R$ A+ k  I& D6 c' o% Jd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增/ V( ~/ Q; S. r. V8 R9 _

7 E* ^7 E; A- f: @/ y  t" Jdic={}+ X& l$ ~$ w7 t% W. W0 F+ G
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. ~( J( ?8 z9 m$ P" x* z dic[k]=v
9 W% Z8 h  u0 q" C7 X4 ]. N print(dic)27、转码n = "老男孩"
" A$ ~. m( {5 c# va. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"% y" {% L; B& E" e( W
a=n.encode('utf-8') 8 F( u" m/ `; l7 i! ^" z
print(a)
; j7 ]/ Q( C# S, G- U6 U6 ?b=a.decode('utf-8')0 r! V, N' D7 I  e) n. V; ]/ y. k: N
print(b)
/ k8 q& k) v' j+ Y1 Mb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
4 w3 s- N/ _$ T6 X& P/ N: Gprint(a)
2 a% Q$ p5 c- r- v9 I7 [  o% tb=a.decode('gbk')
5 _  j* x9 n1 v. q8 t9 k% C- ^print(b)28、求 1-100 内的所有数的和
3 A. ^5 y8 a0 \+ f4 b+ a, lcount=17 f# P5 y) c/ M( A: ^5 \3 i- y) z
sum=0' `+ T: q+ q9 J' r# f, h
for i in range(100) :, Y6 j+ E& y; [0 N
sum=sum+count* g" C+ Z' Y9 K
count+=1
- Y* ?5 i4 \0 [% `print(sum)
7 e5 a8 l  A6 I$ Q' x
& q$ D- ~7 U6 {# B+ r7 W1 }count=1
& f, v- F. [4 Fsum=0
# m' N; b2 I, R) }' W+ Q8 bwhile count<=100 :
$ f9 Q" p8 B6 U* j sum+=count5 [1 Z- O( Q& I, u
count+=1
' y5 F$ Q- t/ k" z6 i# Xprint(sum)29、元素分类
- z4 r- _+ T, i: E( w* L8 q有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
$ t" o, j1 H- q6 x  `将小于 66 的值保存至第二个 key 的值中。
% t6 }. X9 f' P: q# h% o) q即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}4 t- c" @4 ]/ {& I5 S; d: Y. X9 L
li=[11,22,33,44,55,66,77,88,99,90]
/ }) W; c2 ]- ?+ g( Bdic1={. h* a' l% `5 }. b/ _
'max':[],: H- `2 ^/ G) n; d+ ]" @7 f9 S
'min':[]3 C# J& u' Q- C( X6 B/ c; z1 t% A5 G) I
}3 ?6 C: h. z: x3 W# d) \
for i in li :7 O8 j) m* S6 u/ {8 `% k* _
if i <66 :
/ t( Q! J( B3 H  x6 Z+ m8 s6 o       dic1['min'].append(i)
+ N/ _# [# h* l  v, j) U else:' t) a" a' Z& k; w3 T" i. b
      dic1['max'].append(i)* F; n7 t) Z# S2 j% X8 I
print(dic1)
: f! `# r7 N! f8 D9 [
8 Z$ Q2 p, [7 I! X6 l9 S* {---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}) o. c1 k9 B/ u) |

Python基础知识汇总

主题推荐