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、写代码
& p& Y6 w7 k+ f) f% S7 r- {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) :
+ ~. T$ ?! ]9 ?' e name = input('name:').strip()
4 p" b! E# f0 A# k* m- ^9 F pwd = input('pwd：').strip()
1 U( w. t% U6 J3 o1 s% p1 ^
. u) h3 y- n9 o( N* w) X. x if name=='seven' and pwd=='123' :+ c* t9 l; a$ O  l
      print('ok')
) \( \6 J. d; E' ~: r2 o else:3 p0 t* d: x2 |5 B+ Z
      print('error')$ J% ~' R) e# f( Y
      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)  :4 o" N% g7 v+ r, U, n4 f; t
name = input('name: ')
9 T* k% Q( a2 b, | pwd = input('pwd: ')
3 {+ }1 \# e* `- ] if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':4 ]" C8 a) Y+ N8 K
      print('ok'), v5 g" a  }6 L- z# V' M$ p2 b
else :4 C; k/ n8 A( m& z
      print('error')/ y- |1 ]* G3 q( W( _: l0 s* u
      count+=111、写代码5 S6 `% k7 J7 c) A% V3 w% ?
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) :
3 @; Z) E8 y) q+ L- \# z if i %2 != 0 :
) V) b/ ^$ |+ |$ H. y: U% T       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :/ D( r  P; L' Q- V+ _
if i %2 == 0:7 U  G+ C3 F1 {0 [+ X& m2 O
      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"
& _6 G# J. Y; s- h) ~, \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)
- ?  Z' O9 S1 x7 m' R" }6 V; W1 Bfor i in name:
; f6 L7 ^# P; W8 O. d print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain, W. G' D* y# f! [! D3 W) J
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']" [9 F" E" `# k, c
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
9 ~6 a- f: X; pprint(li): H8 N7 P8 m8 u1 j& ^
['alex', 'eric', 'rain', 'seven']
' s. e* H5 A0 c& f- j- p7 u; [$ dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
" q. @/ o) G* f5 H( Xprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
3 @* _$ p4 E; M9 O& E. dprint(li)
0 ]" M1 F6 N2 W- a! o6 Ne. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']3 D2 ~+ j% M9 `9 r* U
li.pop(1)' p# F! T2 z$ k4 ]. ?, e, x
print(li) ['alex', 'rain']( b) k/ b5 m2 f# j' ?+ ^
指名道姓的删除li = ['alex', 'eric', 'rain']3 u- x: R  @! K
li.remove('alex'), o* r4 w4 j5 ?; o+ q
print(li)# v1 H' c' f# P) Q
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
+ K& b/ f" ~- r2 V( m" o0 Mprint(li.pop(1))
( i" m7 ?# A2 vprint(li)
6 C! S) @1 w- t8 ^+ z" a" H8 M6 C8 o" p% i9 O3 M9 u9 _% X
eric
2 Z& \) R8 V2 p5 v' f6 h7 g; a8 h( C['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
& S  X: f4 D1 K! e+ J7 Idel li[1:]
) S& S% o, b3 Z' q# }# U  Z1 Qprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
( j+ g. ]: W; v1 R* Z' Yli = ['alex', 'eric', 'rain']
# X$ r  {# x5 [0 lfor k,v in enumerate(li,1):
4 T; K) z, J$ A: G' H print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
. w/ u4 M5 u5 S) A# _a. 请输出 “Kelly”- b, m) l. O( X; f
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]  g$ \" H) {! e% M: O
print(li[2][1][1]); S3 a: O% n' ^8 Z8 r3 {1 k1 X
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”6 W+ s( z& O7 M" O2 v/ E- L, W
li[2][2]='ALL'
: X0 d0 }; A% t' Aprint(li)
( u/ m) n+ K. O. a24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
- @& [1 W$ w- r2 J( aa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
* [' n, Q# Q9 m: f: ]& w# Eprint(len(tu))7 z: p: K# x# ~; K  c* S0 [
b. 获取元组的第 2 个元素，并输出) k% x! B, {* m- Q
print(tu[1])1 n, |, y/ V( T9 e
e. 请使用 for、len、range 输出元组的索引
7 x+ A4 _, g9 s0 l9 G$ W, ]- N6 t) Zfor i in range(len(tu)) :
7 B% J" \. c0 v9 f1 x# j print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)0 l$ N. ?. o  u  r2 y% {- P
for k,v in enumerate(tu,10) :
# `% {7 `5 i. B- n' F print(k,v)
' f/ w8 H# _8 ]9 o10 alex
& Z- K* e" o) T/ ]( b* |6 I! k) I2 _11 eric4 ^& H2 G# G, ~0 U
12 rain& z: \! a' _+ P) r& _

4 o" A; E% Z7 J) Nfor k in enumerate(tu,10) :
( o! C8 b$ Z6 \$ X print(k)
6 u8 k2 K8 @# ]* _2 j- Y(10, 'alex')1 M. B/ o# k2 C  H9 e
(11, 'eric')
  `0 _# |- \. [# e6 r1 ^- A" z(12, 'rain')2 Y" N  }! y7 v, V3 s" b

' j; B8 k7 t1 _0 @7 }- u; q* V9 a" g. J
25、有如下变量，请实现要求的功能
% |2 G. W4 T$ N9 Q1 R' W/ Otu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
2 a. h+ e8 t, |% K5 ?2 R
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以, |/ O- S2 Q! j4 j6 t, c6 M
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
4 ?4 F& D) K: N, _; z- Ares=tu[1][2]['k2'].append('seven')6 m- W' f; z! E' E6 [5 }

- }2 A2 {9 ~% E2 A9 uprint(tu)
3 n' J) ~1 f. ~' s26、字典2 }; X3 N' V  L5 A0 ~. R$ T/ D( X
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
6 q' \0 h0 `5 b print(i)b. 请循环输出所有的 value) J- a- G% P2 I% M0 x, o
for i in dic:
( e8 {  O7 I6 ~3 K2 U" a! z print(dic)2 ~9 k1 [8 C' j, r9 P1 S, b3 C) c. u
c. 请循环输出所有的 key 和 valuefor i in dic:
. U# p& n. x. E, [print(i,dic)
) f3 s) ]# I  m* Z# M% b+ E  @d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典* @% Y3 u/ k% q8 O* q* I6 p
dic['k4']='v4'
& M0 Z) c* v& D' k$ i( ^1 {print(dic)4 w- ]# y! ^% \/ Q/ ]
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典  Z7 t- v0 t9 m5 t7 Z
dic['k1']='alex'9 {6 V2 V, z& m6 G& U8 F
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典  L3 B8 R# Y  o4 D% W$ C, N4 F7 B; B
dic['k3'].append(44); k: V3 Q( \; e  U6 H
print(dic)& L# C8 r" y% l) y) ~
( F6 O' F- q4 L: k. Z. Y
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典6 I- B$ T7 e+ K' m7 M; G0 b' ]  ?
dic['k3'].insert(0,44)
$ \" T' j4 V8 P4 X5 ?2 nprint(dic)
; L" ~4 ^+ ]: N5 v$ p27、转换( O$ q, J6 ~5 l9 Z5 a  G
a. 将字符串 s = "alex" 转换成列表  s = "alex"
+ M% C$ q- ]7 D' m5 n; i! j' u
print(list(s))b. 将字符串 s = "alex" 转换成元祖
, s( J" T, T" o7 X! D4 |4 \* Vs = "alex"+ ~  ?( u# }. z0 m
print(tuple(s))
  I* O$ O* B1 L" U- o- J- r" ^( P9 a8 x' P' l
b. 将列表 li = ["alex", "seven"] 转换成元组" g( N0 a: H: u5 C. @" E8 P
li = ["alex", "seven"]
5 F7 j  x, N- N! nprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
* n7 R1 ^4 B; k- I5 ttu = ('Alex', "seven")
+ m7 i, {( P# A7 O7 y, W8 [li=list(tu)
' o# n+ [3 ~1 ^# oprint(li)
1 G, j- {$ t/ @6 J: R7 I( {3 }- T! k/ I' x, u7 G
, ?3 Z  E& F3 l  A# E. w$ y9 n
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增" X1 [  q; x. h- ^

) d) Y0 v$ W2 H" ]9 Q, a; cdic={}
% D- P1 a+ g# {" ]% Sfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面8 z2 y+ e, K* F
dic[k]=v
1 I2 q; m+ n" P; ` print(dic)27、转码n = "老男孩"
& {! e3 R" \8 E3 na. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"2 R: A$ v) \& E4 ?  p
a=n.encode('utf-8') ' s. h' z8 k1 T- S- {2 G
print(a), q$ ?2 i: i& p" W- m
b=a.decode('utf-8')* ~4 k2 {) A# O8 N3 O: u
print(b)3 i+ H7 P* S; B9 o4 q
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'); C: @- L# _% K$ N% R
print(a)
) K. Z: b% _4 Mb=a.decode('gbk')
" Q' v6 C) X2 Aprint(b)28、求 1-100 内的所有数的和
7 \  N# d2 q9 G/ u, Ycount=1
5 I: D; F  w4 ?) \8 P3 L: psum=0
0 h2 r# `4 O* V* Gfor i in range(100) :
+ |8 s. y- L# s& ?# f sum=sum+count6 l1 \; m: w0 e2 H' B
count+=1
7 h& W+ U+ ~. |/ I9 mprint(sum)
6 y. X' {. F0 a4 T. N9 U. @2 K! J8 \1 T: i
count=1
$ r6 X" N9 _1 s8 lsum=0
) m& {; w8 s+ y$ _! r) n# ~% }while count<=100 :- A) \5 A" Z# o6 \  ^
sum+=count: c# v0 ?; `; l: _
count+=1
, ~) ]& S+ Z( i0 k2 h' M  g. s2 \" Cprint(sum)29、元素分类
; X+ S# J2 ^1 |. _- A有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，( ~# s9 v- n& I& m0 [. q2 l" r% A
将小于 66 的值保存至第二个 key 的值中。
2 u0 z5 H6 I6 V' P即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]# f# U9 j% ^; q: ?# b
dic1={
7 ~- i! p7 z! W 'max':[],4 w8 ^. Q7 Y# c$ e/ F
'min':[]/ J* ?5 |" Y* k) L
}, w! O- K% Y8 q. L8 X! g# Y
for i in li :; v' v0 A5 T) o/ u
if i <66 :
* l/ Q: R0 k/ s       dic1['min'].append(i)
8 U( R" P$ u( U+ p else:' D* u3 L+ E; `6 i" }
      dic1['max'].append(i)+ g- M" D' l/ t- l) Z3 \
print(dic1)1 t9 \4 {' J% }) ~7 h: t
7 o5 X0 W% w( ^; Q% U4 C
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
  T8 V, V" P( U& L

Python基础知识汇总

主题推荐