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 @1 n8 C. E! J% \6 \4 p0 @0 D: v
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) :
$ m: W4 Y9 k# t- R& k1 H name = input('name:').strip()
) O/ }0 s& I- c pwd = input('pwd：').strip()3 T7 \9 [" O0 s; t
3 Q$ V) b% ^# v) W/ {4 D& u' k
if name=='seven' and pwd=='123' :
- H! `5 p  N: c5 l( S       print('ok')
& A3 G, {6 I0 m4 M. J else:* P2 }" J7 j! R5 r& a! Z: O5 ]
      print('error')
2 x. I9 M) u' q6 u1 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)  :
. Z& f7 ?, M6 V- P8 M! \; H2 ?. A name = input('name: ')1 ^+ O0 n9 w1 L
pwd = input('pwd: ')2 _% D$ p$ }/ J: ]
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
; J1 P! U' l( k5 G       print('ok')
) r4 o+ \' ~: N- L. n else :+ X, c2 j/ Q0 i, K
      print('error')' q/ [7 P# m+ ]0 m6 w
      count+=111、写代码. Y% _7 B& R! ?% U
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) :; m7 y6 E1 H' u7 u% H* T$ D
if i %2 != 0 :5 _, c5 q9 x! E# a$ D
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :- p/ w2 U8 S2 r; R! }! E$ N: G: E
if i %2 == 0:
' H$ W) _2 e2 m! k' m       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") c$ r8 h5 d. U& T
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)/ p* I- B( T1 X/ m. H. D: w! {" y
for i in name:
+ u9 I! ~1 i+ e0 d print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
4 |7 \( @. c1 O2 H$ k7 e& D2 r22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']  d5 X2 `, h- u
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
6 ^3 R& J, q  T) j. b1 yprint(li)
5 }2 C+ e% I: {* Q7 ^8 A4 Z ['alex', 'eric', 'rain', 'seven']/ X% i- k: ?/ t0 V" y& X
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
& j) X" U1 G$ J: n* Gprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')2 |+ k0 Q1 I; n
print(li)& |; F8 \& V$ L8 _* H3 R8 T
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']5 M) |. J- v$ I7 q$ v8 H& }
li.pop(1), b. {* z/ D% c0 S' C
print(li) ['alex', 'rain']6 X' b( ?) g! P. Z0 z
指名道姓的删除li = ['alex', 'eric', 'rain']3 I& u! d0 R+ I" `8 H; w+ F
li.remove('alex')
3 s- p( P, n" W; c) O+ Oprint(li)
$ c/ V* L& {. s/ H4 C& q9 Nf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
. {8 g2 @: v* v" l. N, Gprint(li.pop(1))
& z  W, P+ k4 u, oprint(li)4 h8 c) K: ?& V- j5 b" a1 }
9 P' u  i7 G, `; U7 z& r* O9 d3 X
eric
" F5 Z: I- k. K['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
- H  u+ }- ~; K: ?del li[1:]2 g# E( }; d. l3 M+ O% }
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
) X" X- Q2 D6 B; Mli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):. m* }% r4 h; L$ R2 c9 g3 O0 t
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
6 Q( O; H: o0 oa. 请输出 “Kelly”
" c# Z) _8 R5 c, N5 K% t6 `4 vli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]/ S- A  U' w! f: D0 k
print(li[2][1][1]), Y7 j$ c3 E$ _+ v
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”: X- H) j0 W6 B5 a% \3 e8 u
li[2][2]='ALL'
) K, c  \; c( i- f, ]2 eprint(li)5 M5 Q. `% ^- w6 E( D
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')* X1 h5 F. b4 W5 Z( g
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain'). D/ r8 q+ ]& Q; C; f- h) {1 G3 ~
print(len(tu))
3 H) B" g: X; g( u! U- r% E0 R0 Ib. 获取元组的第 2 个元素，并输出' C! ]" U0 t4 W1 ~+ A
print(tu[1]); d0 j* C$ i+ M9 y% Z) W+ F' s
e. 请使用 for、len、range 输出元组的索引
- q( l% N" O8 m$ [" l, o& s+ zfor i in range(len(tu)) :- m% {( M6 x7 r% w& L8 Z
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
8 r" D! K3 A2 A& L( l' vfor k,v in enumerate(tu,10) :
7 N1 [# |& ~" b+ f0 |# G0 u print(k,v): B: a0 k* B3 n6 n9 B1 Q
10 alex2 ]; g5 u" `% \. V( \1 n- v* c0 o% w' ?
11 eric$ H6 v0 `1 C; N4 A  b. ?' ]
12 rain  [) w- ^2 V2 F+ l
$ @8 Q* e/ f' G+ M5 f$ w
for k in enumerate(tu,10) :
) |, {( G+ k3 q3 E print(k)
6 d3 l1 h1 g# G! |(10, 'alex')$ T: A' r7 L, s
(11, 'eric')
4 Q0 S5 z: w9 Y- l. {+ `(12, 'rain')% }6 t3 e* x0 E! Y2 m

; D7 E5 R. ^1 s- }6 W2 l( |! f+ V8 z3 I6 y
25、有如下变量，请实现要求的功能$ g6 e+ Z$ Z. s1 G. F: L* b& M/ m
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

+ X2 a. n/ L# ]* x3 g9 Wd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以$ t5 l$ {1 m/ p, V' P
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])4 n1 B5 m% u6 Z- |0 t
res=tu[1][2]['k2'].append('seven')
# ]0 l) Z4 U$ t* @5 m- s& I+ S! m7 Z) P! m$ F: ]- }7 ?
print(tu)# @5 ~  J0 ~' c- Y4 r! @( b0 z
26、字典
9 A; `; ?+ r' t4 Qdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
3 r4 w1 f, m& ]9 J+ T6 \7 h7 O print(i)b. 请循环输出所有的 value" C4 R$ K# e9 ^  ]: O5 S
for i in dic:
8 h) x9 O8 a) i+ m9 S print(dic)
4 J+ I* g9 [7 U  gc. 请循环输出所有的 key 和 valuefor i in dic:
" Y1 l9 g' N3 X- q( Y6 y) C- Zprint(i,dic)' i5 n1 o% t5 e
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典3 `9 a$ Y/ V8 A* ^7 V
dic['k4']='v4'
& S4 ]+ R; \/ [" {print(dic)
/ e/ a5 b+ p4 S. x. fe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典- x& o0 q# L$ {, y  x  M) A
dic['k1']='alex'
6 a, G! D! C4 }6 y" d. p5 u1 T: Zprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
7 L" f3 i" @# K* }dic['k3'].append(44)
  S; ^3 I; j) E5 h+ g1 {2 Kprint(dic)# m$ e; C: Y7 R) l$ u3 Z3 J! I& V
7 W; \8 G' d1 F# i
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
2 p4 E. s  `% g3 x: Bdic['k3'].insert(0,44)& F& q% R. l7 u& P" k" F
print(dic)# l1 V$ ~9 ]+ y8 v4 t3 _' N
27、转换/ l: z+ V- ?1 b: i' w
a. 将字符串 s = "alex" 转换成列表  s = "alex"4 P% Z/ D- r7 j

# S( ^, h3 U: c" J# I( Vprint(list(s))b. 将字符串 s = "alex" 转换成元祖
; `  `' W. i/ ~8 u  R% z* j8 Ns = "alex"
# J  G& I3 P. z. b* d& w: J+ O& Uprint(tuple(s))
& m, W; a8 `2 A% m' ?5 \* {5 n: q$ g- `7 `/ L
b. 将列表 li = ["alex", "seven"] 转换成元组
6 M+ f( U! B0 mli = ["alex", "seven"]
; b- p; M4 w+ a1 C2 N; ^# z0 Hprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表( {6 j: i4 N: v* f
tu = ('Alex', "seven")9 t/ P8 b! W! p9 T# k9 r, S! R
li=list(tu)
+ i. D5 Q- R* O: H5 Wprint(li)' S0 ~( W- _- g
+ i+ U  Z" I# C2 X

! d& [* z; M* P+ R5 ]8 x4 _- wd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
' y& J: U% ^! B1 F. ~* N/ w/ T7 B# K' p* K
dic={}! R: d- ~2 N( X3 q
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
2 S' q5 \1 P7 C' y& }  _: @ dic[k]=v6 ]! E& \- N! o. M
print(dic)27、转码n = "老男孩"1 y7 o$ G' K, P
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"* B. J& s( i) N  h6 C/ g6 u
a=n.encode('utf-8')
0 B  C  U3 U+ P( o5 _print(a)
, z% [4 |( W9 l; Ub=a.decode('utf-8')
! S/ \4 O) f, P( W( gprint(b)5 X* S5 I" f* @% e; q5 d  i9 u
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')" G0 D0 l# q: W+ o
print(a)& d: j) K; Y5 F( L+ }; s4 ~( l
b=a.decode('gbk')5 O2 h' G( K; O0 O
print(b)28、求 1-100 内的所有数的和$ b$ f: q, D9 k& z. z8 e' f
count=1
1 }  a6 H0 c. D- z( {  g* Csum=0, P) h( X3 H% ]# L% f
for i in range(100) :
5 s& n; v- R( G! n8 Z sum=sum+count
! H/ n) b4 i! i' Z7 v count+=1
7 t* L& z1 n9 X% mprint(sum)0 P1 ~. K5 i' G6 [! H

( m; ^. O6 p* ^count=1
* z# c1 E( N. q1 ^& X$ ^) Bsum=0% r' s1 y! _" g! a
while count<=100 :
4 P6 V2 W) u, r9 ~1 O sum+=count7 J. Y( f$ T+ f2 F- r, l9 l3 @
count+=12 g( r( F* o" p
print(sum)29、元素分类
# z5 Q$ F# g. i. s. ^- q有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，( d& Q) t: P2 I0 k* M
将小于 66 的值保存至第二个 key 的值中。" u7 Q- w5 ^# j7 d" [& |/ y
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}! q- [; d) e, _' A, x
li=[11,22,33,44,55,66,77,88,99,90]
) Y* ~3 ?$ K  E% l/ A" }/ fdic1={# X* I: _) z+ ]
'max':[],! s8 d$ t- x, G/ g, t# c- N
'min':[]
1 P: Z% Y" h# c/ d}6 _" t) Y7 q8 v' V$ _
for i in li :
5 y8 z. E8 M0 X) C9 c7 B4 Y4 E if i <66 :' b" D8 n) h" f! @+ u% }! I
      dic1['min'].append(i)
5 ?4 n' V4 e. i6 m; `" R" ?8 ^ else:  n& ~( l; L0 _3 U! Q9 U, B
      dic1['max'].append(i)+ T4 I- R0 w. `, j
print(dic1)
: [2 d" D6 m2 J9 h9 s) h( Z1 P7 S0 v0 K3 @1 Z8 s
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
/ K1 W6 \+ J  p, j# q6 [9 e$ @4 i6 {

Python基础知识汇总

主题推荐