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、写代码; x0 n$ d, V% S' y2 C. {0 [% {0 b
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 X- o9 x9 P5 D4 ~! I name = input('name:').strip()
- S) n0 A2 t7 l1 C, d7 P# K  j5 I4 U pwd = input('pwd：').strip()
+ c* k  k" \/ s6 ]" M+ l1 ~: l$ [$ F
9 A2 i+ ^6 U$ ]7 q7 I$ G! ] if name=='seven' and pwd=='123' :6 F9 u7 j$ ^0 c4 u
      print('ok')
/ ?; u: W/ f/ o  T# I3 B else:* W9 V3 u" e- X. @& P
      print('error')- }+ O/ E5 r. _. i: G
      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)  :
  t' ^+ U2 G5 ^+ Q. w% i! [ name = input('name: ')
' k( e) b1 C$ c8 c% M& C pwd = input('pwd: ')
; _+ z5 A/ x. |8 I3 O5 s5 d6 ? if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':2 h) B1 d% x" k( H
      print('ok'); Q# ]. m& i0 F2 o& x$ c! a2 J" R. {
else :: B, f- P/ R1 k; {. n( X) P' K
      print('error')6 D* o& _4 y2 |- J$ b/ E& H
      count+=111、写代码# h9 J/ G$ n# v( @+ }
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) :  \# @5 \& R. @: O
if i %2 != 0 :* w) s1 b; s8 F& {: _  a2 J- N
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
- c; j, r3 ]  O8 u5 k if i %2 == 0:( {1 S& C# o( `2 v
      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"
& i: t; g/ S- [$ V( w. m) Oa. 移除 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)& T9 ~6 p2 p4 D7 H6 I9 h" L9 Z
for i in name:0 _8 U+ h3 g0 T: M& z9 X: N
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
& a$ O9 p5 n; ?4 D! u+ G22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']6 G+ t, Q9 }5 }; f
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    1 Q( I4 j- E' ?+ N' T
print(li)
2 e) ?! v9 \/ o ['alex', 'eric', 'rain', 'seven']
- d% Q# V; L8 d: e8 Ic. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')! w+ v1 Z. T2 H( {$ f
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
# H7 J) e  r; m, p2 jprint(li)- w* f4 e: W. d- Y& T7 ]# N
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
. t1 \: z0 g9 L+ c( ?  Qli.pop(1)
1 E9 A4 E$ b4 M. s! ]- C: X! Z6 Oprint(li) ['alex', 'rain']- s& a$ ]4 R/ }' l( P: n. k
指名道姓的删除li = ['alex', 'eric', 'rain']2 i( u( l( P! g+ E+ l2 T
li.remove('alex')
- m) k! m% p  |- z  j) }. {0 sprint(li)
' x  q1 ~" e; Y' h" I, ]% jf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
+ B( \, Z) t2 ~! q$ \. [print(li.pop(1))
3 N* ~9 _1 q) Zprint(li)
6 V9 N. o; A, C6 N/ s0 a, D, C6 d7 T* o% K6 }; N
eric
3 C7 D9 \" t5 X9 H- ]' T3 U+ `1 j['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
6 c0 F1 K6 o( R9 j% H* s8 Jdel li[1:]
* n. G( A* v# l6 X5 A3 f# [print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
0 q; j# I: |6 y; q, Kli = ['alex', 'eric', 'rain']7 z) }! d1 j- P; [$ h/ L
for k,v in enumerate(li,1):
: S% ~! e& x, ?  ?4 J; p print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]4 z5 [5 E2 d$ [" @
a. 请输出 “Kelly”' K% L$ ^* ~4 M+ W, C, \  h
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  g  m+ C6 w; mprint(li[2][1][1])" F) t9 R0 Z" l7 t0 V+ D$ _
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”5 h; C1 a/ R7 A7 q+ t0 l
li[2][2]='ALL'
/ D4 N- ]0 h" J1 Q' rprint(li)# `; F( e# i) ~& t
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
# i+ s; \0 w) qa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
, @, O1 J/ y9 L0 L0 W2 R" p/ r1 ^% qprint(len(tu))' g6 J3 V/ d1 B4 L" e( m
b. 获取元组的第 2 个元素，并输出
- s4 X( R  |- m3 P1 H$ Z% ^print(tu[1])
5 ]  h9 p) Y4 T) k# ue. 请使用 for、len、range 输出元组的索引
0 S; J# U+ q' v& Q, C" xfor i in range(len(tu)) :
. W2 z! {8 N& ^6 x print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
. m  ]7 J. F. Ufor k,v in enumerate(tu,10) :
( R: O0 t0 f2 F% t1 p) p9 q! { print(k,v)  M7 Q6 x" ?' \  Z& J. ?; c3 D
10 alex' C: z. K) p0 k/ v
11 eric. [3 I2 z7 ]0 U, L* c' I, S
12 rain5 u( w$ v4 k2 d; F' m
) V, l2 L& L# i# R( j0 D! O
for k in enumerate(tu,10) :8 [8 \& |$ s" n6 M4 I
print(k)
& Q+ n0 Z, n& M: f' [! g(10, 'alex')
, s# t7 V- \& W) G& q; u" k(11, 'eric')" r, L2 y" Q! G6 y7 H
(12, 'rain')
$ `/ H% R; i$ j6 D% E
, u& m. j' _( T1 ?7 r
' _) K6 u  I8 H- c25、有如下变量，请实现要求的功能
5 g8 F* e2 b) C+ |tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
% A) h3 R$ i8 o( t- s" B* u
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
; R  `  W- g" k2 Ptu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]). L, f% T9 k5 i; C0 u* |
res=tu[1][2]['k2'].append('seven')5 i# U0 ~5 _5 a4 \6 Z2 ?1 T

' y% M6 D# T) S; t; G$ d- ?/ d( Mprint(tu)) h6 e. e" h$ G% s/ T
26、字典0 j* p/ M/ I- R& ~+ ]2 J
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:1 N! w- \) R; S9 V
print(i)b. 请循环输出所有的 value- p9 L! p5 C' a9 l- q/ R1 O
for i in dic:2 I5 T) {( u" u3 F% Q2 r! E8 F
print(dic)
, t! d8 h5 E3 C1 q4 \% m( ?. Ic. 请循环输出所有的 key 和 valuefor i in dic:
2 Y, x( C% g# Q1 H/ m! i0 N, Aprint(i,dic)
# x, O% b1 ]: d: U; G$ f: nd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
3 J0 m; Q/ m* {$ m5 edic['k4']='v4'
+ u2 h9 K7 E0 ~  e( D2 j' o# Eprint(dic)
- G6 c- \* y( Q; ~( Q" d8 F/ |e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典7 e  t* b3 d- G3 F
dic['k1']='alex'3 c( @. @5 t/ E1 l
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典4 D2 z/ n/ p. `2 K$ h; H
dic['k3'].append(44)
' R) ?0 H$ S6 T2 }; ?! I1 Nprint(dic)
) E) l4 L/ x8 F& j$ o
) `& {- A7 h9 x5 G; E- eg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
& S9 E9 j3 E% N1 B2 K+ ?dic['k3'].insert(0,44)
& W% t' ~2 b4 J: Q/ v3 {print(dic): H, n: G! }- b# j) a- Z
27、转换
6 I. _& [+ x- x. m& ja. 将字符串 s = "alex" 转换成列表  s = "alex"
/ P* b7 X, {  T# A8 A- ~9 k$ `. i4 _8 J
print(list(s))b. 将字符串 s = "alex" 转换成元祖- [7 U$ T" j) I* D7 a
s = "alex"
9 c. n' J8 q/ Kprint(tuple(s))$ F0 T  o( l5 e- g
! b( a  U) C  _4 R! v- [' U
b. 将列表 li = ["alex", "seven"] 转换成元组; T+ u6 [2 w' c* J$ }
li = ["alex", "seven"]
& J( O/ c2 ?9 {% B- A# Tprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表. M2 J6 L$ d, h# U3 d
tu = ('Alex', "seven")) e& B; ?! S) Y8 h
li=list(tu)& b4 G1 n% x: d, ?  J
print(li). L1 c2 p9 D. F- o9 q& v1 ^% N4 T

- j* x' j8 _: y7 r" K( Z0 U! ?! ~7 |8 n
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增7 ]5 B8 K) V# V8 q
0 \! d% ]; T5 H! N8 U: d5 U9 B
dic={}. r+ q4 j. q; W9 f' L
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
3 D: E/ c1 Z. T3 H" A dic[k]=v! u( M, @: l# v0 D
print(dic)27、转码n = "老男孩"
, |2 ?( W9 R& G7 _' qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"1 W$ k# ?0 z. o6 w  ?
a=n.encode('utf-8')
$ ]$ K1 C9 E- F4 [1 sprint(a)6 \3 A4 J9 H3 s6 |7 v
b=a.decode('utf-8')
) l$ V( [1 J2 ]print(b)" e: P, n1 h2 }; L5 `- C/ G8 t  r
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')2 K% t# v# h( u" L: |( Z
print(a)0 x( R$ o) W  I: q
b=a.decode('gbk')
5 N9 G- s% Q8 v" hprint(b)28、求 1-100 内的所有数的和4 o& A6 X7 |( O6 |6 w5 G
count=1
% y5 N* K* B- fsum=0
, q. e( J) H$ g# hfor i in range(100) :
/ E7 v" J: F4 c7 G( i: A sum=sum+count
# ]" d9 e" ]! x  B$ A) q9 Q! T count+=1
! o% k7 I' g$ q; ?, Aprint(sum)
) Q8 l/ g+ \- x4 f" A% N6 {0 {% Q# i. [4 @* c, A- M
count=1, m5 |" k- Q( s
sum=0( y$ X  g8 s" s
while count<=100 :
; W7 E" Y) ]7 d, j sum+=count7 s. D" J, O9 i) \6 B0 G- ]
count+=1" G' j' K; B- x. a8 _# Y
print(sum)29、元素分类
3 ^: x* t& W" `8 x; {: {, T有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，8 Q' Y" ?8 D) }
将小于 66 的值保存至第二个 key 的值中。/ ?4 ]6 s( D( s& e5 v  b
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}  j( s1 ~2 j9 K
li=[11,22,33,44,55,66,77,88,99,90]$ R# i) }( }) }: g
dic1={" y/ ^- o; ], A1 X
'max':[],) H9 ], j5 D. g& t  h# G9 m6 M: g
'min':[]
" y% L" m* v+ f! l& @}& ?1 U" g; u" G( d
for i in li :
  L6 Z. M1 P5 Z. l0 x2 I if i <66 :/ J. K% ~( j! }8 X& i! e1 B
      dic1['min'].append(i)
7 L# A7 n  u" C else:# G6 W$ l5 T  m9 r5 G  A
      dic1['max'].append(i), r4 i( u9 S, G4 E. r
print(dic1)
3 ^: [6 B( X. H2 u! v/ p$ T- {2 B* p+ K3 i& @
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}. N$ u7 `1 K" D$ W

Python基础知识汇总

主题推荐