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、写代码4 k  L6 E4 J7 G, a$ D- x2 k  \# U5 e5 u
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) :
# \2 S; B  b: L; y% o* W name = input('name:').strip()
, u" q- h- _' z pwd = input('pwd：').strip()
1 P& ]5 Z/ A! m! ^  V/ S7 E4 ]' x& ^
: e/ J9 i) X1 B% H/ B6 t  k if name=='seven' and pwd=='123' :
& I. P; Z1 ~: G) k       print('ok')
% ]" z! y! x) l0 S  Q- y else:& D1 ]$ }5 ]5 F- q5 b
      print('error')
1 F+ s2 }, w  `& V+ {( M( ^9 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)  :
7 X. ]( g0 Y" x. Y; D6 p name = input('name: ')# j9 s( q0 K; p# ~* Z' L& h
pwd = input('pwd: ')
" e/ T2 c8 a4 q# z if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
$ Q7 H! I1 a0 ?0 G0 q0 E+ x8 y       print('ok')# q1 X$ I" W2 {, Y$ C% q$ j
else :( z8 |, d$ p2 F& j  N- U
      print('error')
8 i7 ~8 K. I2 F/ m       count+=111、写代码
# J3 }% ~" D' }( u& h, Aa. 使用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) :
$ g5 t* X. x0 o* @ if i %2 != 0 :
, U6 t: I% T* {9 K  }* v1 z       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
2 y6 Q" D3 Q: y7 z5 V" `0 l$ Y if i %2 == 0:
. E8 _% [0 p" s       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" v* g: r; ka. 移除 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)
1 V- H- w* b) ?3 R( U1 d. tfor i in name:
5 V  a" g1 C5 I0 [! a6 L print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
- U7 V2 \; b7 W% a# |22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']% C, ?/ b! V* y+ @( O
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
9 H! F# L; m" _- hprint(li)# S& f- J2 O3 F2 x4 h
['alex', 'eric', 'rain', 'seven']
: H& F& y" f: t/ {2 @. W0 Qc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')( f" L7 Z0 T5 _+ `0 p. ^- n8 y( L  |
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')% @4 p: K- R( }
print(li)" R. G' W) U+ H/ I2 K  Q
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']- G+ l7 k5 d8 ]" W. T
li.pop(1)
  }5 J  M/ {8 o& r5 M. s5 X( mprint(li) ['alex', 'rain']! K% N3 \9 W" M: G$ q3 ~
指名道姓的删除li = ['alex', 'eric', 'rain']4 x, Q" \; M( Y- U
li.remove('alex')2 P; J- \2 ^; l8 I, x3 t1 w/ Z
print(li)
; u' \0 j( ]8 t) ^' \f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
7 `5 v8 T+ R) Q- E- ]print(li.pop(1))8 @* v4 z" \) W" K, O
print(li)
8 n# q( I2 G! q* W% l9 Y
$ i9 s7 }/ Y  H; ^3 P+ Aeric
" G; [2 O$ k+ v' w4 _6 V4 m! C['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
3 G& ^3 T" w2 w$ s5 r0 Odel li[1:]
  P; A* W) N, zprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
1 z: P% c2 K9 Sli = ['alex', 'eric', 'rain']
" S' d5 A4 i' ]5 _3 R9 w0 p* ~for k,v in enumerate(li,1):
7 G# N- i! i* d+ a print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# }7 D9 z1 Z* V9 s3 p& ua. 请输出 “Kelly”
6 r1 a- l+ l, h- O/ K3 z8 Ali = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]4 ^" T3 d  @! v5 ?5 A0 G! S% Q
print(li[2][1][1])
1 ]% g5 H! W' m) ?2 q; F) Yb. 请使用索引找到 'all' 元素并将其修改为 “ALL”# I( s* k5 k: P( \' m9 ~
li[2][2]='ALL'. x* k9 M5 j: K$ w# h* m
print(li)# U$ A7 E; m# M& z0 l+ s
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
, f1 }2 E  e* K8 @  l% N6 n, [a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
0 A0 T9 y# Z7 r6 I7 iprint(len(tu))
9 b; A3 J. n6 `; O0 h! Ib. 获取元组的第 2 个元素，并输出
5 p( `4 p2 f5 Z; [" A: U. Cprint(tu[1])
6 K7 Z, h8 g( O1 _  @5 ce. 请使用 for、len、range 输出元组的索引
: d. ^& O& p( |; t& ]3 p% r; hfor i in range(len(tu)) :
* k( Y. ^% v& S4 s2 q print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)* ]* W# g0 G' V
for k,v in enumerate(tu,10) :0 b# F; z9 }+ B" H: W- S( B
print(k,v)7 s& v4 F6 F7 H  _* J: \5 N2 M
10 alex, B& c) L. ?' j* N& v3 u: }/ M
11 eric( @( ^) C3 l8 L- p5 R: E
12 rain
: ?; N$ V4 d9 X& s9 k# [* h7 z9 o9 \* `- E% A
for k in enumerate(tu,10) :
. c: P/ T# _( L print(k); A' U3 t/ q% w6 l) c* s  S3 z
(10, 'alex')1 [8 Q8 g% X1 l/ \8 h( C+ \3 P* m
(11, 'eric')( \. D& f! g9 I$ D2 s! I) Z
(12, 'rain')/ Y5 w2 p4 i5 t3 ^3 b/ j3 s! ]0 Y- I

, u" i' D: |" m) F' o
) ~% K0 f9 C( V25、有如下变量，请实现要求的功能% w3 |( G/ ^% n! V( |
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

' }* i/ d- e4 P, f+ }' nd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
% |5 \: C" O, {) C  J3 Ptu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])1 ]0 G" U, Y* o  m' m) K  O& h
res=tu[1][2]['k2'].append('seven')
: M. P. k  c5 [% }6 N7 D# v  E" G4 x5 G; [* z  g' B
print(tu)% l1 h5 t6 _# v: K
26、字典- ^$ m) B8 F' R# ^+ Y' H
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:' e/ i# _1 R' F# f8 i" J
print(i)b. 请循环输出所有的 value
, Y3 d+ V: B: y- r' I% bfor i in dic:
6 J2 u6 V! `4 ] print(dic)
; H+ O1 `- H- vc. 请循环输出所有的 key 和 valuefor i in dic:+ O1 g6 L9 E2 R
print(i,dic)
2 g. [) D# U8 l2 P+ U1 H, N% ]d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
, C: T) U1 G1 O" a' gdic['k4']='v4'7 K4 ?, z; j  O
print(dic)
8 c9 i0 s- r. ^' ~, Ge. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 z% l; c% P0 @, ]dic['k1']='alex'6 t( x% I1 [6 T1 k! G
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典6 U9 I, g% ~$ R) {/ ^
dic['k3'].append(44)
1 \% a' p7 C: W. y7 F& L# _0 fprint(dic)
4 ^6 u4 N+ r* S
. [) J, f; |. ?g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
' t- T4 t: T$ gdic['k3'].insert(0,44). N& n' D: s, H* I" g$ L+ \5 M" Q
print(dic)
( d2 m; _0 |7 d9 h8 q27、转换) p, b6 }8 @8 h& Z: t& o  ]2 P" R& v
a. 将字符串 s = "alex" 转换成列表  s = "alex"/ P! K. C2 w8 F1 H% [

2 U0 q2 ~2 G; eprint(list(s))b. 将字符串 s = "alex" 转换成元祖1 }8 x* D! b' \5 t% [2 ]% @( ~
s = "alex"
/ V9 @3 ~- A( \print(tuple(s))
1 I/ c! c2 ?6 x% P
4 l; K: p9 a6 O7 ?7 {, jb. 将列表 li = ["alex", "seven"] 转换成元组
) n8 Z+ \( s0 T, g" ], tli = ["alex", "seven"]
/ ~8 X7 s: i: w4 U  ]print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表# r7 j3 s) _0 s, K+ e
tu = ('Alex', "seven")
6 P0 A* d" E% ~; I3 ili=list(tu)5 z' p) U/ L4 }3 ^
print(li)' R* @% H2 z; A0 r$ c

% g% r) y2 G3 j' s. c4 m% ~. H/ f* N4 }# \4 Y; U3 M7 q
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增0 B, n& d3 ?7 |( B4 c
; e& [8 @- A+ ^
dic={}
7 w; u% ?) p/ hfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面- ]0 W3 d) ~/ S: i: m2 L  \
dic[k]=v8 h$ ~' m- Q7 ]/ g7 a
print(dic)27、转码n = "老男孩"; F% y( b9 h4 s5 G/ c: F
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"" o+ H3 y* \: O- \
a=n.encode('utf-8')
4 o" I5 u) D. h1 E" {print(a)' p; U. K9 |7 P+ H. l9 i9 [
b=a.decode('utf-8')
5 b* ]. s  _, Q! x" U/ F8 C) \print(b)
' D- }# f& [% V0 ]5 q9 tb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'): C, Y' L! S5 \% k. _3 W
print(a)& A  j/ l8 ~$ j4 O3 o
b=a.decode('gbk')
0 H$ n8 I/ o' D2 g$ {# s8 x' aprint(b)28、求 1-100 内的所有数的和$ F1 f) f1 Q8 M5 E* d; I9 K" M; W
count=16 c/ T5 b3 d" K
sum=0
/ j9 @* ]" k; H6 Xfor i in range(100) :* Y5 X: Y+ X9 f2 o% T
sum=sum+count; I+ o1 m# \1 p" j4 G1 d! w7 F
count+=1
+ x) A# K( b8 gprint(sum)
. U3 m% e% g3 R+ i2 h6 l( f; h. Q: k  ?! N  M
count=1: W8 s& Z2 r- \
sum=0
9 R) Z4 G: ^9 G3 h5 s& p* i" z% Awhile count<=100 :. }/ u( d; B6 c+ i5 f( [
sum+=count
* G$ Q8 g9 v: P) x1 k. ^ count+=1
4 ?8 r: l' X2 h. Fprint(sum)29、元素分类
5 z1 A2 C1 ^: M* r  {3 M有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
) b. c- N1 v0 v  S& N% ?将小于 66 的值保存至第二个 key 的值中。4 o! Z/ Q1 f/ o! n- P
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}/ y% g7 f: P' ]4 s
li=[11,22,33,44,55,66,77,88,99,90]
2 y; U' ?) X7 m" N/ `" g& i! [dic1={# s5 @0 u" s: l7 Q  v; ]
'max':[],
1 B. |( m! f* ?4 o, W 'min':[]
" C6 h( F, y) V}, z( z- u, J+ W2 G
for i in li :
  C  |. J7 w+ B3 V. m. l if i <66 :
  q( d! Z' v8 Z3 l$ Q+ x       dic1['min'].append(i). V# {7 s% u3 p2 d6 c1 ^- G0 Q
else:/ S  f# j$ w; S
      dic1['max'].append(i)
1 p" h7 X* N3 }9 Pprint(dic1)/ [1 v+ W% m5 w2 \6 T
' _" e3 Z* q1 o4 z- c& _8 L+ w5 k
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}" `( u$ R! n, A/ F4 [

Python基础知识汇总

主题推荐