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、写代码5 ]: `) T/ l5 _
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) :# I6 c3 M' ^8 F  f% G
name = input('name:').strip()
" F2 U5 t8 e* V/ [ pwd = input('pwd：').strip()' Z/ ?2 g. W. u- w6 F- Y

# F( }3 F$ a0 _6 B; h- O& N# y% ` if name=='seven' and pwd=='123' :
( _9 U; x- q1 D* q! Z       print('ok')
' Y3 ~  V! d- E5 c( Q( h$ u else:
& f% p! R: O# |) u& v5 M       print('error')- F, P! ~# W6 P4 v" |  L8 J+ |
      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)  :1 t; X0 p0 V- h& ]7 b, I
name = input('name: '); r+ {/ {; I- X
pwd = input('pwd: ')
1 \. Q( ]" \5 x4 q! U" M* K if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':/ m9 T& a" u. A5 r3 s( j9 _2 ~
      print('ok'); ?! F$ f: n0 P( X
else :" N" [5 m4 f3 m  L3 v6 `- o; u& L
      print('error'), A: c- T: [2 \3 |9 N/ Z' y8 r
      count+=111、写代码
, ~4 ~  D7 @# v1 W) D6 Qa. 使用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) :
( _. X- b- K- p$ f3 d if i %2 != 0 :6 h# B1 J8 J$ E7 R7 D) M1 i# ?
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
* n7 R5 ?9 }% G) n8 t if i %2 == 0:
2 a/ N( i+ q# f5 I4 }, Q. ^       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"
, m- L! K0 N* b- I6 `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$ U: }* c* N/ ^( S, h: Lfor i in name:
  a; c' N1 e- x4 @1 T# g2 _  A print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
3 g3 ]$ ~. S4 ~22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
- {: h9 `6 W8 X; tprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
3 S7 f' z: a( m9 C; Mprint(li)( @3 V! @# R3 O- `6 Q/ m, E
['alex', 'eric', 'rain', 'seven']
7 ~- P7 F, V2 _3 ~% r# z/ g2 A' c+ Ac. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')( H" l/ H* S/ }! H! L0 ~8 M
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, f" N$ Q4 X; \( wprint(li)
" E) b4 x/ l+ V) S, xe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']9 A/ B; G! W6 K2 ~7 m+ M! C
li.pop(1)0 D" O6 Z) L. T
print(li) ['alex', 'rain']
8 \8 N; G* B, B指名道姓的删除li = ['alex', 'eric', 'rain']7 C) s9 }) D! \: W
li.remove('alex')1 }& k0 k0 r. ?
print(li); {1 M$ ]( ]* _, h' K. I% F$ f7 I6 N
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']% R, S: ~- O. X( S
print(li.pop(1))
& r9 q% t& X! I2 `2 Cprint(li)
( [8 S! H- t$ I% w9 R
* e- p; g0 z3 G- C7 a' i9 J- {! u: Teric
: D) ?3 {. l/ k5 P['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']' A. Z( ~" Q) E% E( Q; m7 `
del li[1:]4 q/ y% z) ?; ?" ?( e
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
* V8 M' d, f3 S* Mli = ['alex', 'eric', 'rain']
2 ^5 e" v0 M5 G% J1 D7 J: Xfor k,v in enumerate(li,1):
) h$ k& w, E7 r- v print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) R, J% x+ u$ d7 \; fa. 请输出 “Kelly”9 P" D- j" L# c: L* s2 }  ~" f( r3 R
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]. i0 g& m; F; @7 u5 V& ?+ N
print(li[2][1][1])
. C' S, U3 g- Q2 I% k+ pb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
7 Q: S1 _5 c; v" K* {li[2][2]='ALL'
7 e" c% f# W: D7 X# x, D- ?7 yprint(li)
7 L2 ^( O- i6 N6 W' |! p0 R$ O24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
: e* l* O& N. i0 C: aa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
6 U% Z2 \) f. E2 hprint(len(tu))6 A4 g( p! d, |4 b! }( v. F* }
b. 获取元组的第 2 个元素，并输出' W8 g3 W8 m4 e: x' ~7 l4 `
print(tu[1])( ?# F6 i: a2 i, G+ J- e* |
e. 请使用 for、len、range 输出元组的索引  V3 r8 z8 y% j$ ?2 L4 n
for i in range(len(tu)) :8 P9 R5 w; _) @! f5 b- P% Z1 ]5 O
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)' I1 ?* v" G4 I6 I
for k,v in enumerate(tu,10) :- O& k, l4 \" o3 c6 H
print(k,v)2 ]- D( T& A1 U, M
10 alex& \- c" @# c. i, B  @
11 eric
3 `2 T2 }  |1 T$ y1 x7 M12 rain; @$ q  C( u+ U! P  w/ ?+ l

; }1 a* z) V6 ]% Q, u7 V9 bfor k in enumerate(tu,10) :6 A* j  s9 ]$ T( e/ B3 |" I! M
print(k)+ b* C5 m6 K& h. b4 T# N/ V+ p0 S/ \
(10, 'alex'). {# \2 ?8 |& ^, }
(11, 'eric')
. X3 X5 j& T2 ]% x" _2 B+ o  ~(12, 'rain')# H" u: j# L) [9 O9 b' j1 S
, q$ S$ h/ ?* S* |( R
5 g1 W- \- u) u) z; x3 ^. n
25、有如下变量，请实现要求的功能# Y8 u: _! d: W( X% l1 U1 X
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
: X' g* L* Y6 W. G) G) R
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
9 x; o/ |# T1 E9 Ltu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])6 ^& J) A) F. n9 U- {8 z1 b! K
res=tu[1][2]['k2'].append('seven')2 o+ Z- |& w1 u) h8 E  R/ W
( f% U, r$ {9 p9 ~* Y
print(tu)0 ^% F3 \, c- j* n& u7 j
26、字典
( h0 Q# Y: Y% b" w6 }/ Odic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:# \7 Y0 k  b! o
print(i)b. 请循环输出所有的 value7 S" O% t# @6 v( z+ Z6 F
for i in dic:
/ Q5 v$ H( r  r8 d+ b print(dic)
4 L8 K& O0 y* `8 F0 z( h  Q( M4 Bc. 请循环输出所有的 key 和 valuefor i in dic:
8 r5 G6 x, n2 B  y; I5 y' `4 }print(i,dic)
: ?" _5 _0 F- |% R+ b% X6 pd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
" H7 w2 b- k, `dic['k4']='v4'; r4 w1 C% B5 o9 S
print(dic)1 L3 ~0 ~: }/ e2 G8 p! N
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
  L  y# S7 l; `" D9 T' i* Odic['k1']='alex'7 ]2 O5 J. [5 e* R/ e+ X
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
2 a/ j) ]! v# r! a$ Qdic['k3'].append(44)
2 u" F- d0 v( i+ k1 c/ H! ]0 M* Cprint(dic)
  e5 ~* x3 V( s5 M
5 l  V* ~" S8 q0 a/ {, ?g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
' d9 b- x) M9 w% ]2 v6 Fdic['k3'].insert(0,44)( D; A- b# K8 M6 T& ], t! |7 ?: Y; w* r
print(dic)
- r/ ~# P! k( k% J- z* P* M8 j27、转换
8 O$ K7 h% L2 e* y8 ja. 将字符串 s = "alex" 转换成列表  s = "alex") b9 a2 E" N; Q( T$ \( x
( c% b( j0 k& v3 `! C
print(list(s))b. 将字符串 s = "alex" 转换成元祖
: r: d$ T) Q5 a1 P/ \3 N% ds = "alex"
) Y# @% X) p6 g: U$ o6 zprint(tuple(s))  u' H2 R& ~2 I7 B4 o* A. J! C4 y. O

/ c% f% j, q! e; u1 b' b* B+ Ub. 将列表 li = ["alex", "seven"] 转换成元组
* {, z$ n' S' z2 Z6 L& s) Tli = ["alex", "seven"]. t+ t5 B% A  l; y' B
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
" A+ u' L/ w) U0 ]( N5 Z( y1 rtu = ('Alex', "seven")! x4 C, Y2 C9 `1 ~  r8 `7 w
li=list(tu)
! R9 L8 a/ s0 Y: P: q% bprint(li)6 Y. _# S% n) {% v4 K5 m

+ I; V4 V; `) E  n, o# ]  `$ M' R* G* g. I
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
; ?7 k% x9 f4 b
/ t. c4 S1 e) vdic={}
1 H5 ~+ `; H! g3 L# t+ [for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
4 F2 Y6 Y+ B) c6 j, U dic[k]=v/ k% p1 m) J; L& H3 x  }  O: {0 L
print(dic)27、转码n = "老男孩"
- Y- ?0 k* X, ], O5 W  D" \5 Qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"+ r- e9 x0 i- F8 u  i: [5 i$ G
a=n.encode('utf-8') 0 u6 Q$ r/ S4 z4 m6 H5 ~/ B/ e
print(a)
' g" I" }" u8 J% M/ bb=a.decode('utf-8')
3 |) L3 n! ?" K/ N8 f5 Bprint(b)
$ b) ~: Q6 j8 Rb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
' R% x9 I2 V+ \6 K) M: R) `print(a)
- p* X* v9 ?0 {) Qb=a.decode('gbk')0 U, l5 E2 l0 V: T3 [; N7 F- G9 v
print(b)28、求 1-100 内的所有数的和# U9 }; O+ N" d7 ^+ y- }! d
count=16 R. A5 k# m3 P* u) N7 V% ]5 C- p" V
sum=0$ s4 b, w$ e, T, D. S8 i
for i in range(100) :
, L* L3 I6 v5 C6 w+ |( S sum=sum+count; u+ y& _$ T# e6 e3 f4 j
count+=1
& w( i9 p# Q. D3 k. \( Jprint(sum)
0 |9 V5 C0 D8 u  C" n; v
. G5 t8 i: l% Ucount=1
- Q2 H& B* G" p0 J+ }, `sum=0- B* x" l& ^' f3 n! Y% j
while count<=100 :: s! {/ x: }) y
sum+=count- N  X( k- {* r. o
count+=1
& U& N) E+ U0 `2 R7 {& X! [print(sum)29、元素分类( Y  E, p/ R  N" X
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
1 |; w( A, H. L) W- i0 K2 e# G将小于 66 的值保存至第二个 key 的值中。4 W- D6 p- W! O8 b
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}: L& Q. F. q  Y% ^7 b) K
li=[11,22,33,44,55,66,77,88,99,90]: p, W& s0 ?( f6 {# W# T- w8 g0 X
dic1={$ G. {& \" w; h8 X3 B
'max':[],
* b( ~  m  g! a8 S8 a0 \: } 'min':[]
  U$ t) {+ c# k5 G- h}
8 n1 y$ M2 m: m( j/ z3 H2 p6 ifor i in li :' t+ E* z9 N8 o9 n: o
if i <66 :
/ i" n, s1 B. A  T       dic1['min'].append(i)" |, ?, s$ g" A' P( b
else:
0 F) J1 n2 @% N, ~       dic1['max'].append(i)
2 Q! @6 Y* _! [0 v7 e0 q; T! yprint(dic1)$ w  v4 R" V, k- f

$ ~" T; x# g& N---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
( h& A8 Q3 K2 x" H& [

Python基础知识汇总

主题推荐