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、写代码: f1 G9 ?- c- A! I. f; Y
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) :
$ h1 s9 J; q/ `- J5 L8 f0 P name = input('name:').strip()) q2 l! f# |8 `8 `* V% L& O
pwd = input('pwd：').strip()- J$ g  \% A6 g* b; e* N) B; T9 a

9 m4 g7 P: f6 S& x  l6 O7 x# x3 \ if name=='seven' and pwd=='123' :. w/ u" J1 ^. ~% G
      print('ok')
5 V$ w( C+ \) I8 g else:- ^  d2 G4 v* q3 l: _$ |, A# l# R
      print('error'). F' ~% G: P0 \/ S2 ?4 T
      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)  :6 V, R' ^8 F9 o( u, o
name = input('name: ')
& Y: b7 z$ j6 W0 Z7 J# g pwd = input('pwd: ')9 h3 R0 `" |# G  f2 i  V% C
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':3 b. e. \6 a/ D# c% |
      print('ok')% Z9 b! c1 V' ~; [& S' E
else :8 n. S) m3 @* |( P7 \9 d
      print('error')
, F% w: d; U% x+ r6 ]( S       count+=111、写代码
  X7 ?8 j# R2 G9 @' ea. 使用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) :
2 s) F7 q& X7 p2 b+ {, f8 y4 D if i %2 != 0 :' V) f4 {) r7 o  J
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
/ t: R5 C4 f3 T5 w0 I, ^5 b! z if i %2 == 0:
; v' q, r) ?% s8 y: E( t  w' l       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"0 a1 g& g% X9 j8 a: W
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)
2 _7 Y/ }9 t: B' D8 `for i in name:* V/ ^. p3 y7 {# J
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain0 B0 b/ a8 t5 [& F8 v
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
0 L: ?$ D/ r. O6 T8 j' Z7 Jprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
( S& H  t/ s% y- v, l: `print(li), v9 R0 q. C5 [- [
['alex', 'eric', 'rain', 'seven']
  v/ _& `9 F8 e* \c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
$ `# B6 \0 R( Dprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
1 R8 R7 ^* K8 k# l) Z0 gprint(li)
! x6 d0 [8 _, g( S8 a) le. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']: w7 y- B$ K9 V) H
li.pop(1)
, `  l4 R' o4 J# u$ V8 Fprint(li) ['alex', 'rain']# Z/ k! S/ f) l7 c
指名道姓的删除li = ['alex', 'eric', 'rain']
& y' _7 i; w/ |; v! `: t3 e8 j) Cli.remove('alex')0 A( O- B+ b! D" f7 i9 |5 _& |
print(li)1 T* W0 }/ A1 p& Y, }0 `0 l
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']5 s# J3 S5 y% F* h: s# a- u
print(li.pop(1))+ l. s  k3 Y: n  m
print(li)" E% v- U4 F8 s5 F, J
* l' w8 s% Q6 s/ x' h
eric+ a3 O0 |' J" b- I2 J; L, \  B
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']+ _% M. _+ r) f) r. I3 b
del li[1:]
7 g6 C" t7 Y3 B- l6 d/ {- m8 _print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)+ E6 E: Y# _* l7 H0 \$ ?8 l
li = ['alex', 'eric', 'rain']/ P0 g2 r  W# [( f. M5 H, V' a# X
for k,v in enumerate(li,1):
2 R) X/ }. n9 I6 j print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 T4 S6 `. U0 R' M* `2 na. 请输出 “Kelly”! \! c6 s/ Q; k# f
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 i* {4 ^- Y% V6 I6 {5 J
print(li[2][1][1])
( _/ m1 V6 N4 H+ G/ z2 e8 Ob. 请使用索引找到 'all' 元素并将其修改为 “ALL”
$ k; Y8 [: R; b- Y3 Zli[2][2]='ALL'/ T+ o; z* v- ^
print(li)! {3 {8 B" D, L# r9 D" P
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
" G) }+ Y: y6 O0 F3 j3 oa. 计算元组长度并输出tu = ('alex', 'eric', 'rain'). x7 V: F  r; t/ x$ M
print(len(tu))
  H& ?; U9 C( {& z# [b. 获取元组的第 2 个元素，并输出
4 V# h& Q& ^& E/ C; @print(tu[1])
" \3 r2 J6 g0 u2 f& \e. 请使用 for、len、range 输出元组的索引! C6 u# m, E6 ]/ f
for i in range(len(tu)) :* s2 X( Z  F5 s5 w) j3 _
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
+ v) \. H% [# u6 G0 Afor k,v in enumerate(tu,10) :
) y4 d& f! G9 Y4 @; v print(k,v)' l% F" t7 _+ G! t+ Q9 g
10 alex# Z5 B$ O: f( {- _' `0 }# i7 O
11 eric
0 ^0 d6 s' ~* e8 A$ P3 c3 j12 rain+ r  w# s* Q' `" u5 \# }  E
" b) Z; N1 ]0 T% [
for k in enumerate(tu,10) :
. ^# \. o5 ^, m( f9 z print(k)& E3 r  `, X7 j  n8 k. e3 j
(10, 'alex')
; ]/ N. b( {& N; H# `(11, 'eric'): J6 K8 S; O+ L* {! o
(12, 'rain')
& s7 k" I, [3 C! V- z1 P7 r
% g% G/ ?9 x! n/ q! A; \1 G. v+ g- V0 O6 C; p6 P9 o
25、有如下变量，请实现要求的功能
, p3 S4 R( j; h7 J; p; wtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

6 i, x; L) z. Hd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以3 O4 w) Y# K3 J+ c) E. y) H, R+ Q
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])6 Q8 {6 V' N+ z! @4 P0 y
res=tu[1][2]['k2'].append('seven')
$ [+ I+ C7 u2 t5 ~/ w! G" Y
7 b3 R9 {  y9 ~# w: R4 Vprint(tu)- h% t% q$ r$ W8 b
26、字典
" F6 z) t3 U# U! p( W9 sdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
) j$ I0 E7 z8 s' e( |; Q" y" P  O print(i)b. 请循环输出所有的 value/ a* ~4 M# l" L# v! D2 U
for i in dic:
8 r9 f" H$ ]( ]! F, D% `) D print(dic)
) s( u4 n  ^7 ^! A' K6 q: |$ V0 Yc. 请循环输出所有的 key 和 valuefor i in dic:
, V  ?% {% Q% E" J5 C; hprint(i,dic)
$ n" w( t; r" _) ~+ _4 M. [d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
3 Q6 r. Q. a1 T$ A" Z' }# C9 `dic['k4']='v4'6 M* M  j2 ?, H; a( ~: L# A
print(dic)% S: V: ]% W" |* W; Q1 d( W2 p$ V
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典, p9 z# B! F' P2 G# r7 t
dic['k1']='alex'
6 S+ H' p: O% L4 c) lprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典; p* R) u% L1 l6 B* Q6 @4 a
dic['k3'].append(44)  Q+ p- G0 W3 w0 Z9 v
print(dic)
) ^6 I3 C' R4 c2 t
' d( e6 d( }0 c6 U7 j9 t6 F' Xg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
- d/ e+ c0 r( bdic['k3'].insert(0,44)' f& y& ?+ p8 {
print(dic)
! `, T4 j9 C: |& l, ]27、转换
% F* d' B' ~+ d7 Fa. 将字符串 s = "alex" 转换成列表  s = "alex"
; Y- ~0 L5 ~1 g# A! U5 f! |
( Z3 r! N" _5 t- x7 C/ W  y' rprint(list(s))b. 将字符串 s = "alex" 转换成元祖
: k4 e$ o# I1 ?) Cs = "alex"
$ ~3 N5 k# q: _; |, H& V$ kprint(tuple(s))
# j% M2 f  ?  z0 C* D
b. 将列表 li = ["alex", "seven"] 转换成元组
% [, _+ D9 L' I; q1 l5 nli = ["alex", "seven"]% p, D2 S: N: {  T* {4 @
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
; W: |3 l( L) d; s; jtu = ('Alex', "seven")6 e( {8 N2 A0 E' M! q9 ~4 ^
li=list(tu)
% B& w3 V3 \8 Z$ u" C: L- X' nprint(li)- ?& f2 X, v! V

3 H8 N7 v5 ]! g* r5 O+ J) N2 r: F
' U& _: Y- z& `  d, kd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
  J: d/ e& \0 W: f4 ]
# R! E1 T$ @6 Y8 O& @dic={}
7 o' r3 y6 u- m% w. u6 K% B3 w: j! ifor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
) n: \4 |: m: h9 v% P dic[k]=v
7 p. c9 q; f% N( W% b) M print(dic)27、转码n = "老男孩"
) k# U: m5 }2 q! D8 ?- ea. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
4 U6 r$ S, q' Ea=n.encode('utf-8') + ~  y5 i* E: I9 l& I1 z
print(a)
+ \& a3 n' W, X9 c/ `b=a.decode('utf-8')
9 b; M0 Q+ M# e; n9 ^: @3 Yprint(b)
4 W+ k: S" ~  u: ~; A1 @0 k+ ~b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'), z2 q; b4 y3 `! d! }% ]1 j
print(a)
* T( Z% N" ~6 H, X% tb=a.decode('gbk'); ?- \5 l, x$ o1 b: l
print(b)28、求 1-100 内的所有数的和
$ L! o) {1 Y  F$ gcount=1
6 c' X# z, p7 [$ wsum=08 A3 A6 }/ l" h
for i in range(100) :
0 l$ x0 P/ G, Y2 `. s6 f sum=sum+count% u5 c4 R3 n7 _  v
count+=1
# ]& m* X! \$ k% Z* m# Gprint(sum)
, Q9 d! b8 C% A1 X6 {
1 {- s) D& q1 ]: u% Ucount=1& M0 M' z* S% w0 Y  d2 V/ _
sum=0/ s2 T0 g* `3 w! ^: ]% S
while count<=100 :
. Q$ l7 J7 U% \" L sum+=count
* y& m" K! J, _& } count+=18 {- c# l& k. l$ T7 x2 B# S
print(sum)29、元素分类* ?) W- p! f. c
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
; B- R2 l& _2 d) r将小于 66 的值保存至第二个 key 的值中。
4 P9 x7 c7 A; }# U即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
2 v% v. Z* s4 uli=[11,22,33,44,55,66,77,88,99,90]& F: o# R8 i6 h: _3 d8 [  j9 m
dic1={
: V5 t6 j+ W1 z" d- ^1 J/ | 'max':[],% E; I0 e: s/ ]; e5 j& a) a; f0 G/ V
'min':[]9 L0 y( V) g. h9 F) E
}
: s: b6 d% W* g' E) Q4 x+ @for i in li :0 K5 M9 F$ @* R' g9 A& N- b( P
if i <66 :
$ y: g2 d$ q( b) a7 u' K       dic1['min'].append(i)
! {8 ?) }7 u2 H$ K  S else:
4 t$ g  X" S% G2 r       dic1['max'].append(i)
4 P. R1 `8 g& t; r& F0 {print(dic1)
; Z$ l5 k4 F% Q0 ?( l' ~
* O1 C0 J( G$ _4 F6 g5 o, m& m---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
1 \/ z: ]) M, o7 F

Python基础知识汇总

主题推荐