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, w( A- w! ]1 B0 ja.实现用户输入用户名和密码，当用户名为 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) :
# ~) r1 L  `9 j. ]  o4 x. I5 } name = input('name:').strip()
* \0 v* M! F3 A+ M, Z! B3 i! p pwd = input('pwd：').strip()
) m& @1 Q" u2 X8 W5 h, b. _: N' a0 }
if name=='seven' and pwd=='123' :8 u) {% B8 u) l; e
      print('ok')
# F7 Q+ }8 u/ X else:: U' A: B4 F* R6 p
      print('error'), P0 q7 @+ C; w; T* a1 t2 u2 f
      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)  :
5 D! o& h- i! Y. J name = input('name: ')2 I$ @, o; c+ \2 g, ]3 @7 |
pwd = input('pwd: ')0 v; ~' x, {+ P) D
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':  v) `) f: Z" m. y3 r, i2 ]
      print('ok')
% t0 b- q4 a' T- m6 { else :
: G7 W! |1 T% d- e       print('error')" n  @8 Q+ J$ r, w: f/ c# \( l
      count+=111、写代码
; d, \' r% e5 H3 l0 Y, Y4 Ba. 使用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) :' S/ Z7 c3 M% g# `0 z  C
if i %2 != 0 :
( I8 A# E. `; _# O3 S  u" M/ 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) :
/ ~/ r- Z/ I* Z1 U4 W  A* ? if i %2 == 0:+ P+ Z' A5 T8 N3 s* a) H6 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"* e# f8 A* S1 @+ U+ U6 b3 @
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)$ |7 v  f* Y; g2 u# w; f% c
for i in name:- T4 p# P) K2 d2 \7 E
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain" L5 W2 o1 M3 G: x
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
* x: W2 h. ~$ d  Sprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    . ]/ K7 @' {2 B, x
print(li)( `" I8 ~( o/ K, Z, Y! ~9 }
['alex', 'eric', 'rain', 'seven']9 R4 \8 |0 h5 r" ]) m) n" E$ h0 t
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
; }2 W6 }. a! z" v% Q, M$ aprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
% {% n$ O4 x# f6 b& G6 @4 aprint(li)
  p: x1 m; V; p  t% g& Ce. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']# [5 _4 u+ x6 M/ F
li.pop(1)
+ |4 x; V; f  Q+ rprint(li) ['alex', 'rain']0 M5 n9 U/ X9 m# Z
指名道姓的删除li = ['alex', 'eric', 'rain']/ t) e3 a9 r$ X4 Z
li.remove('alex')3 m) L" G( v0 d
print(li)
' K; v* ]4 ]8 H/ A% ~f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']+ D& R. h9 V* C% J7 [$ N
print(li.pop(1))) u5 o! Y3 V! a; m; |+ ^
print(li)
4 g/ j7 O/ K9 X' u4 }$ P
- M0 f) L) u+ l2 g% ^2 qeric6 J) ~7 o* v$ t
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
, Z! c% y7 a5 hdel li[1:]/ s% R# R( _, Y1 L4 `, _
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)8 e' Z2 }; ^6 U! o7 @& m
li = ['alex', 'eric', 'rain']+ A, ?6 F# W+ z0 ?' W. D. q( M  G( r% n' B
for k,v in enumerate(li,1):
) Q) Q! I4 \6 A' n6 K2 y. J print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
2 `9 r5 |+ \- n' }2 ?; E6 @* fa. 请输出 “Kelly”
! F5 a) A3 S1 I( X+ Lli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 T1 r+ F, F6 |6 P9 g- D3 uprint(li[2][1][1])# p0 t9 |* b" L1 d7 C6 C% M
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”! w2 m( }) E' c# h
li[2][2]='ALL'9 T! h9 x( }; y# Y/ z; L$ l) `
print(li)
  j3 i  V: V5 K24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
$ T/ N/ K& E4 {1 H- fa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')& O8 t6 J: f1 I2 B% \' ?: N) w
print(len(tu))
8 e9 d4 L8 u3 B$ L. _* k: I3 _4 ab. 获取元组的第 2 个元素，并输出0 C" d0 L. `+ R9 }5 B" t3 W
print(tu[1])
1 m5 w2 g% s% C4 m7 q2 ?( w- n8 de. 请使用 for、len、range 输出元组的索引
/ J. L4 \0 E8 C& X, `for i in range(len(tu)) :
2 r& g- ~  |6 u* r' H( t print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
3 T: c0 ^+ j# j4 j! ifor k,v in enumerate(tu,10) :, S) V) j. S! [0 g0 t6 M# A
print(k,v)7 _; b* q: n. d4 z5 @% O9 u
10 alex
11 eric# R! P! h2 {/ Y7 d4 o
12 rain
: o0 }+ B6 ^( r/ l; e7 n: F( r" V, O5 x( g' u/ `; Q
for k in enumerate(tu,10) :) i4 V( l# n- f" R3 J, l6 w! O
print(k)* z* r0 Z" p+ k, S3 _  Y4 ]( z, E4 Y
(10, 'alex')" [/ `" I: [8 K) |$ w
(11, 'eric')
1 d5 l/ J0 |. o/ s(12, 'rain')
9 |- W$ ]/ ]0 p$ o
$ i  U2 d5 P# L2 L5 w  T3 R
/ F0 s3 }. D" B4 Z' Z25、有如下变量，请实现要求的功能$ a8 ?- t3 [" M- p
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

. y- U( k! a; N& Z1 Id. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
& k. b- H1 z6 Q6 E9 Ptu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])1 A2 r' ~' @9 o. z7 u' X4 S
res=tu[1][2]['k2'].append('seven'): C/ q2 S+ m! k% ?/ Z6 w) u

8 g- Q+ N) V' eprint(tu)3 E! [  h( ^5 O- t( a7 }
26、字典
3 y* e# Q9 B/ t1 Q7 t% ?3 vdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
* q1 r, C, L* v print(i)b. 请循环输出所有的 value6 Z, m2 d9 y" d( s
for i in dic:$ |8 y5 a4 Y! z; U4 _9 U  P# z3 C
print(dic)
5 u) ~( ^) S& N7 [' w7 X1 Ac. 请循环输出所有的 key 和 valuefor i in dic:
. y9 |' M9 T4 E3 `0 j. Vprint(i,dic)
6 r/ \! G: X, u. s' ]d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典+ ]9 F5 E( n( p- _
dic['k4']='v4': u% k- l2 ?, f7 `. C
print(dic)
( U7 y7 r+ `5 i& Ce. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典' g! L. I0 b& Z. R5 J  }3 A5 g1 G0 A
dic['k1']='alex'6 X0 X5 I! m/ X1 ]
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典) j  c0 r0 t) C$ N
dic['k3'].append(44)
( }2 K% z8 Q% \; Bprint(dic)+ C$ e- |2 e- x% c

+ [* L' I- G$ mg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典' U8 Q, }- V) I7 [8 C: N
dic['k3'].insert(0,44)% k  |% j9 Y2 V, }/ ]
print(dic)
8 p& T- x* N2 _+ o5 ~, k+ _: b5 N27、转换
4 u. O1 E) z( ya. 将字符串 s = "alex" 转换成列表  s = "alex"3 l" @& ]1 S, R) Q6 y

. {" t4 r5 ^! ]0 \print(list(s))b. 将字符串 s = "alex" 转换成元祖
5 {' ^8 b: E( h! l0 R# S/ qs = "alex"
8 F2 ~" l# V  t+ V2 Sprint(tuple(s))& O9 g6 w( n% Q* B
' H# k* `! m; `% z0 c
b. 将列表 li = ["alex", "seven"] 转换成元组
  z' J' ]% e" p! \) Tli = ["alex", "seven"]
4 q6 F: M& ^7 F+ L4 {: yprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表. q$ l5 A! R: T# g- U4 |# c" s
tu = ('Alex', "seven")- c1 A, o! b' s( {! P) I/ ]3 c
li=list(tu)
8 g) v. s( d5 B0 }# `print(li)% Q- G& z& r5 V5 d  Q, l
. h  C. o; s) L4 h0 K

5 g9 v$ V4 A9 O+ g) dd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增+ ]) I5 ~8 u- Z$ V

1 I. i' q6 I# @' n( rdic={}
3 f; d- ~) k* f3 b( `3 nfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面+ s% m+ L% w2 \( w& G8 N- H
dic[k]=v# i+ T5 H4 M8 k+ l$ C
print(dic)27、转码n = "老男孩"
6 D# q5 P; Y7 d8 Z) la. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
2 t( k" H- Y3 |8 q3 Fa=n.encode('utf-8') " h' S! [3 {, j. `2 |3 l
print(a)
/ `2 ~0 l( S  }5 a. E1 A8 d, o1 @b=a.decode('utf-8')
* e9 R: w# U" L& x4 ^+ A0 i7 z2 Xprint(b)
8 H0 P9 {8 F9 Y! ]- B. q7 Ib. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
, _  Z9 o1 K$ I5 z! s0 Z* Tprint(a)6 o6 A6 {* Q; H. G
b=a.decode('gbk')
+ D+ q$ i- @( `" pprint(b)28、求 1-100 内的所有数的和* B* @! D( D: Z! S8 J
count=1' P) p, M! ^4 J. X
sum=05 ^( v7 b, \* q& y6 Q' _
for i in range(100) :! P2 t& r; Z9 m2 ]+ K0 k
sum=sum+count
+ U* a9 \3 G4 j" u' A! p8 \; p count+=1
; K4 m- g( y$ L; M8 Q: m. t4 x' Oprint(sum)7 E$ z$ U7 d" g: w6 s: G

1 [5 x2 z  r4 K: W( B7 I6 Q: F+ icount=1* B9 ?0 M2 D& ~2 l) O6 H  [5 }; F
sum=0& t' u/ F; J, Y! F* m2 g  }) ]
while count<=100 :
) W* _) H! p- l3 |6 g4 ~ sum+=count
9 q1 B, q% g: _ count+=1
" @0 G! h+ L% E: `* q; C$ y& Yprint(sum)29、元素分类: k2 O! ?4 H+ {) N6 N" `% F* E
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，9 X7 f- K9 }& D. |1 Z; P' C
将小于 66 的值保存至第二个 key 的值中。
$ u' l' Y( s$ b: e1 S即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}$ ^! }  _* _3 [) m7 l
li=[11,22,33,44,55,66,77,88,99,90]7 _* C- h. `5 b6 L
dic1={; H" Z7 n0 Q5 ^* h# q, J
'max':[],  `# b, w: d5 \( @8 ]$ a3 j( @; U; L6 K
'min':[]+ _+ m; b; H/ Z4 W" r# K
}
# a  m) S" X- E' c3 y4 }# _8 p& xfor i in li :* ]) S# v% Y, f2 L% l
if i <66 :3 a* o5 G) [0 \- g5 t6 C3 V. J* V: R
      dic1['min'].append(i)7 g3 k1 i' a6 d
else:
4 M. h5 U. L8 G6 V+ }6 X1 Z       dic1['max'].append(i)
* u5 B% K, g: g3 Gprint(dic1)
% j2 q9 E. W' W2 Z; V9 l5 V  F" ~1 T+ I
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}; e% o9 I' z, U) e. I

Python基础知识汇总

主题推荐