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、写代码
3 _. U+ V4 u7 T* }: i3 h- ^5 K, m' ua.实现用户输入用户名和密码，当用户名为 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) :7 X) K. c+ y, b& A) e/ m2 f
name = input('name:').strip()6 N4 A! o9 P8 p/ ^  O( g
pwd = input('pwd：').strip()2 ^1 F2 f" q; d2 H$ g* X# E9 w) v, ?+ e

) I5 B4 V- n6 g2 F if name=='seven' and pwd=='123' :
  R. x- {4 {: y0 n* q2 ]       print('ok')
* X5 _7 _+ z+ R" V7 z else:% Y" b/ {7 a. _$ A- ^
      print('error')
6 d- E- p9 P9 _% P       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)  :/ H: A6 R. |. c0 e5 S
name = input('name: ')
7 d/ E- \/ x9 F9 V' P1 U3 O4 Y6 v2 ? pwd = input('pwd: ')
# J: R" q& ~) ~& D  w if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':# q) b0 u) K# Q4 }/ r0 F! t
      print('ok')  |( T; K1 k4 ~0 M0 {
else :
+ p/ ]* d, b2 b% ^% o. D9 h       print('error')" M# p; r6 Z$ @) Y- q% c
      count+=111、写代码% _) O: d: J* d. z1 r
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) :
, P' e9 \+ B3 V- Z1 s6 r) @ if i %2 != 0 :1 j$ ^0 r: C1 b. t+ E: L
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
8 U6 A/ n( b% G4 F) @ if i %2 == 0:
& D9 c8 w3 P" j- y) P       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 p3 i6 A  Y7 U. [4 k' @5 y5 `5 _
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)/ ^- E4 q( ~) x% K% a
for i in name:
2 i% S: _* t5 `$ f. B8 }% ]9 V print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain8 A: u8 j5 c" x8 H; i
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']# p2 M: ~8 f& R' v
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    / V! l) n; Z$ f" W9 }3 m3 ]1 Z
print(li)7 W6 s. `1 z) r& X( c
['alex', 'eric', 'rain', 'seven']
6 K  S- e) K( R/ rc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
4 n8 E0 T2 d  c6 _( i/ j7 u! _print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
  H% I3 O0 z- p! ^print(li)1 L* \; L, V# Z7 b8 b
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']& t/ A, u6 G5 p/ D$ V
li.pop(1): t6 N( T; \& Y6 s" I
print(li) ['alex', 'rain']9 ?7 k+ ^% `& i1 u. F/ [. H
指名道姓的删除li = ['alex', 'eric', 'rain']* O8 l; N0 p8 c5 Y2 K1 z9 T
li.remove('alex')
9 k3 m* p8 K6 S2 aprint(li)3 p7 V* R: d9 u" C; h7 e0 ]
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']7 H+ a* i$ _7 m
print(li.pop(1))
# K% H  {' y" E6 E; Gprint(li)0 F  D) y5 S2 R( y
8 p' `3 q4 s1 {8 o- t4 T
eric
3 @1 Y, T6 l+ `& Z/ ^6 P['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']4 ^: P5 d2 `# }1 a) s7 d# P
del li[1:]2 e7 q7 \6 F( v9 E6 j7 N
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
# N7 n8 G6 _+ u: Uli = ['alex', 'eric', 'rain']
8 U7 u7 Q) C: H; _" I( Ffor k,v in enumerate(li,1):5 v' f$ A1 B2 [6 K: N$ }3 u
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]3 {9 L' P3 o. ^  L$ j. p$ u4 _
a. 请输出 “Kelly”1 m$ E& j* {$ J0 u- c
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) A& B2 N2 f! d3 ~( A9 Kprint(li[2][1][1])
3 `* q; C/ M6 Y( K- b% Hb. 请使用索引找到 'all' 元素并将其修改为 “ALL”6 c) s# e- U1 q9 x& {" D
li[2][2]='ALL'
/ O' z- h7 s3 K  dprint(li)* L: x4 e& W- O3 ]; L
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
. u* c3 S& ?3 C+ @: ]a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')) _8 v3 }* t3 k* |
print(len(tu))
' C, X4 O* C$ u$ yb. 获取元组的第 2 个元素，并输出" o$ g1 z3 q5 `0 ^" ~
print(tu[1])
% r3 c% I. s$ c  H" Qe. 请使用 for、len、range 输出元组的索引
" h! T) \; A( C8 |1 B8 f# q, [! t1 Nfor i in range(len(tu)) :
2 s% S' v# S  B) x/ e print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
# c* D7 J9 p7 }7 M- _0 ?/ X2 Mfor k,v in enumerate(tu,10) :: [6 u% g; L* }
print(k,v)' }' h! }% q: N- @7 Q- Z2 e' ~
10 alex
) C5 e" O! `- h. {( d- o. {11 eric; y( ]% ~. V) X3 g
12 rain2 S5 Y( Y4 c3 r+ b4 f, T
6 b" ]0 {) l; u0 z
for k in enumerate(tu,10) :; c6 t- J# _$ E0 i0 k( A) T2 B
print(k)% ]1 c# ^# l6 J8 K; o
(10, 'alex')
0 z7 B1 ]( Q+ V% w. Y(11, 'eric')
9 f" Q7 a- B6 f- g(12, 'rain')
2 y3 k7 q4 m6 E  T& r6 m% O: p4 Z$ U: `9 D3 ?( @/ W9 H8 e- L: H

1 s4 d3 Z' X! D* J1 N25、有如下变量，请实现要求的功能% D+ @9 h# V: ?. a) H' T
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

- x' t. v- N- k* k% f1 j6 Kd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以7 K8 X. D- F$ p: t. ]4 n
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
! J7 d' ~! a# gres=tu[1][2]['k2'].append('seven')3 M9 z5 \% _$ A& i" l  F

" C' ^+ z3 Z2 P  Jprint(tu)
; B# e. k( q( t# X5 @1 q26、字典. i. N9 ^9 [, N" A: z0 B2 q4 g
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
% A0 Q1 t2 T. v/ S print(i)b. 请循环输出所有的 value
' _5 t/ z! c) bfor i in dic:; o! L% a6 v( B: l. U; u" V
print(dic), s! Y% w: o- p9 D4 Y* d
c. 请循环输出所有的 key 和 valuefor i in dic:9 r( t0 J6 B: i& b! p$ T3 Y9 C
print(i,dic)  S6 q4 |/ F: R) p/ Q2 {# ~4 R
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典+ W/ V! V9 k/ u$ P. R( Y9 h
dic['k4']='v4'
2 O- r8 v3 a$ |* M5 O/ M2 T  uprint(dic)
4 g2 _) Z, x# N( w# X' Y$ g/ pe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
4 d* E8 `, o; r; ?0 [3 P1 xdic['k1']='alex'1 k! R8 n$ w$ S5 a. ^
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
' Z- a9 M; s+ Q, T: H0 Vdic['k3'].append(44)
% n% i- I. i! K& f8 ~print(dic)% n) h# h& Y# K% v8 d5 n3 e4 B
+ n1 y2 X2 O! Z( n5 e' z
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
: c# F4 B6 c( I) X& U; y1 odic['k3'].insert(0,44)
( {8 V# K; c- {8 _0 J# {print(dic): h3 a: d/ n$ T1 c5 S
27、转换% ^4 i" z( m5 @3 g9 T9 s6 p
a. 将字符串 s = "alex" 转换成列表  s = "alex"
/ N9 r; p, }: p, b6 a# {# T9 {% N  W* Z" ]- q8 I1 O: J
print(list(s))b. 将字符串 s = "alex" 转换成元祖3 y# u$ ]$ e- h7 P# b: @  c* i
s = "alex"; ?# z) {, v! n' j
print(tuple(s))2 g9 e/ j/ Y! B% E# f1 i8 S

* ]6 U" q# L+ s: Wb. 将列表 li = ["alex", "seven"] 转换成元组' r$ b5 G0 w) e% V
li = ["alex", "seven"]
, c: ]* v7 |& H/ h! m, P; Kprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表2 }0 Z/ [: y3 F, \) w2 v
tu = ('Alex', "seven")
, L' _2 G$ N2 X3 d* N/ ~' Eli=list(tu)% A7 h% l1 U/ u6 L
print(li)
1 t5 Z3 T* H: E) ?. `. I' C5 x) [: |4 K4 f+ W9 I
# D& O7 J# m8 n. Q/ h& D: [/ E9 A
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
) K8 Z& |7 P* o1 s  \$ D* T0 E, c# u- W+ P% f( H4 F
dic={}
2 k" z1 N  W9 u3 m! {! B  Gfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
, }& M+ A! Q- L dic[k]=v
6 K7 b) F8 P# t% E9 V5 c" X print(dic)27、转码n = "老男孩". v6 h1 r/ M' }( P2 D9 v) s
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
8 h+ c4 {$ j, s4 ka=n.encode('utf-8')
4 C! i9 P: q& m# V" \print(a)
8 ^  Q' n: c( f& Ab=a.decode('utf-8')- V* w, l) n& Y
print(b)  P5 y! V; a$ n/ L+ {2 y
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'). R0 @. R, V* ~$ ~
print(a)0 y1 v) R! a3 O" Z  z
b=a.decode('gbk')
% O3 d% y. d$ y( Tprint(b)28、求 1-100 内的所有数的和3 U  t5 ~7 L8 E- @3 G! S
count=1
/ |9 V! x! ?- E+ \* x8 Nsum=0% E. U2 I+ {, O" m# w3 X% z
for i in range(100) :$ \" ?5 [8 V2 s5 ~* g
sum=sum+count
, |, b7 L1 h" R# ^7 b# d+ S) ^# w count+=1) f2 B3 [; R! ]. L% ?7 ?* g( {  [
print(sum). J$ n9 e' C# k/ r; Q

7 R5 \/ |, d! Y/ o5 m7 qcount=1
" T, ?( S' `8 e& _1 d9 T) Ksum=0
* X4 f' s2 W7 ^% W1 ~while count<=100 :
! g3 P7 M0 _! U sum+=count
2 q0 J% Q: {) | count+=1
& H9 Y1 w, l; e* N9 o8 C6 ~0 h9 u4 i4 mprint(sum)29、元素分类0 N3 d9 y* A4 J
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，, u7 J0 y9 J6 D
将小于 66 的值保存至第二个 key 的值中。" t( W* v% E6 `9 N$ k, q$ u& @9 b& Q
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}0 W4 J* n) \# B. t
li=[11,22,33,44,55,66,77,88,99,90]
1 i+ c) ~5 S0 C; F! Idic1={2 L$ x! @  V" T: v
'max':[],
3 {* M, h; l! r' @( | 'min':[]* R3 ^. O2 j( O9 p7 e
}; m( L" G1 K+ Z* }; b/ R
for i in li :
' E" p* J8 M7 z2 h if i <66 :' j! \1 Y. l8 t) q* n# J
      dic1['min'].append(i)
2 n, C7 V2 y0 M! c8 i else:5 k, ?" L, \- `) f  G9 l' ]; ]
      dic1['max'].append(i)" @! T" ~( s( }8 J1 h" j
print(dic1)$ }- W. D( ^1 g+ q0 [; [/ ]
  q; F' N9 q4 b' k& N
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
1 Y1 R% h# |% i/ l

Python基础知识汇总

主题推荐