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、写代码
, A- Q2 q# v; ]8 x: n3 ^" p' D% fa.实现用户输入用户名和密码，当用户名为 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) :+ c1 V9 N% G: _% M/ W$ W
name = input('name:').strip()
( B6 M4 Z6 {! |0 f' ]) K pwd = input('pwd：').strip()
6 L4 \1 A% ~5 Y' o8 e# h$ E& N" l5 o8 L8 S3 ~9 Q$ L% g5 ^
if name=='seven' and pwd=='123' :
! s* a* G9 @. n2 A; S( D1 N       print('ok')
7 r1 S. T2 ~+ X% O) J! N else:
  k4 q+ E! A: T* V: j       print('error')
+ v6 e) q: _$ K( }+ g1 ]5 N       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)  :
) q3 O% V/ Y. r5 t- V4 n name = input('name: ')
  F$ U; y: w0 m6 {* q pwd = input('pwd: ')' c4 g  j( N" l
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':: ]* s( h: B& Y0 Y/ ?! r* U0 l
      print('ok')
* N) ^" G# L$ j9 K  a else :
! e2 t: q' E/ E6 v# b; u       print('error')6 W6 b' R( h% v2 G8 U# Q4 z5 S
      count+=111、写代码% f/ d) h' _  i" K* K
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) :
5 M1 j6 U0 ^0 U if i %2 != 0 :& x1 U& N8 L  c- v6 {4 m- g' m
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :0 d$ j( q, h! V) {
if i %2 == 0:
9 O$ V1 _6 H% d* }       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"& L1 _/ P! q: B3 ^9 u* I
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)
9 X. w6 w! t6 i. Ofor i in name:
& ?8 e4 }8 X; ^, K print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
. E" u7 q. f) P7 l) t) e/ E& Q. l22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']( ^) y3 P+ t* f8 _% l% n; N
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
3 d5 Z/ j+ ~, N2 D' pprint(li)
3 l0 O; G' A* Y( L* _ ['alex', 'eric', 'rain', 'seven'], j1 J1 K# s& q, @8 o$ E
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
( T4 c' G4 T, D" R8 i; {print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
' t! m! b; l. p1 _9 oprint(li)
) w1 ^, o9 j3 {2 K+ O* oe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']" `3 m$ }3 w8 b1 k5 h
li.pop(1)0 `3 E; T* V: |
print(li) ['alex', 'rain']
8 s0 w3 _% `; K, o/ Z6 z指名道姓的删除li = ['alex', 'eric', 'rain']$ [% C2 z+ g7 ?2 ~5 n' ?
li.remove('alex')0 G0 |* ?/ |' A" }6 |2 r
print(li)! p) z5 f; k! L" o, i- x
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']2 h- S+ c# U' w
print(li.pop(1))
1 n. `. ]* J# sprint(li)3 H$ ~, f' d9 U; c2 [
, A6 Y& W* k% z2 H& K* q
eric3 g) [7 x* Z+ F( \
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']7 {0 w4 g3 x6 n$ E
del li[1:]$ b" f( ]" }9 e. y  a# U
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
/ R" Q. `' v+ f8 W/ i2 \: t6 Jli = ['alex', 'eric', 'rain']- b; y; z7 }  |/ p/ t% E6 N
for k,v in enumerate(li,1):7 @0 k1 l# I- w! _; n& b0 \, {
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" p& K; d" r5 c; ]a. 请输出 “Kelly”
9 N( z% ~8 E% x2 Pli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 k3 `2 }2 `6 |/ _! r, Vprint(li[2][1][1])& [8 h: P% p1 T4 n. i6 q8 ~+ L
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”* C0 u4 S5 U# }$ v2 |" W/ [
li[2][2]='ALL'
+ x% V' L! a2 p3 N. ^9 `6 [" Pprint(li)% K! ~* R2 }) u2 t) v$ V
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')+ `5 j0 M1 Y5 U6 H4 V% L  g- ?
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')6 x8 A6 c3 Q1 j! h6 u% M4 l
print(len(tu))' j8 Z( W4 l* l  P
b. 获取元组的第 2 个元素，并输出
3 w6 U/ [) |2 Y( ^3 V+ F# [8 W( }7 o! bprint(tu[1])/ c4 m+ j) m7 t# ~, C. |, R4 k
e. 请使用 for、len、range 输出元组的索引
! H, f4 P, }. ?5 N- nfor i in range(len(tu)) :
  ?( u! R' q# @/ ~9 x  s print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
% m; L& [! T: x9 l8 B1 ~$ Gfor k,v in enumerate(tu,10) :
6 D$ J$ e4 v0 D( G" E print(k,v)
& n. P; k1 A% \2 i. Q! n+ l10 alex
6 L  d1 ~* |* `* N4 r11 eric
& d0 t! |0 s# X& M12 rain9 g6 s; s+ B* l5 Q! N

; f" x  c- |% c) u/ U$ s' Ifor k in enumerate(tu,10) :
8 u& T' f9 B) |+ q5 z print(k)
0 e$ p0 X' G  _( G2 s, U) V7 h(10, 'alex')! o& D% p- D5 {+ J. ~5 o/ B
(11, 'eric')' t) ^3 }1 j! e6 \  k+ @3 z  D
(12, 'rain')9 p8 b$ T, j" r
& w# R: F' j+ N# K$ u! c0 K

+ @4 E$ B% Q" H; _25、有如下变量，请实现要求的功能
6 ~% {4 Y( W6 a# [* M# I& }tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

+ Y0 ]5 K! d! ~8 `" n* r. `d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
& ]( m( x+ |( o: K9 A+ g. h8 Q: g0 atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])) ~, A2 A+ d8 R2 y3 u
res=tu[1][2]['k2'].append('seven')
: S  i  P# h3 \+ M3 M
- Q7 f" G( K1 f  kprint(tu)% R  k3 S+ U, S- I. L, |) M
26、字典
% l4 h1 B1 s3 y8 r3 w+ }0 ndic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
2 }+ c9 l+ ~" }0 O& d print(i)b. 请循环输出所有的 value* @* m2 l6 \8 J& B- o
for i in dic:( O3 k$ a* u& e3 I) W6 k
print(dic)
( t* q6 ~: _1 J" ]# M/ jc. 请循环输出所有的 key 和 valuefor i in dic:
. `' }+ z( Y- ]. @print(i,dic)
" Z; H4 |8 ]2 U1 R! a: R& R  ^d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
( K# l" ]3 o. f0 u* b$ C  ^dic['k4']='v4'
8 e' I. M- h, T7 {print(dic); L& e' W3 w- b8 d) E
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典; _* O2 g+ o2 E
dic['k1']='alex'
* }8 A# s7 f# O# Oprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
( u- `" L$ Z! j) D" x7 Mdic['k3'].append(44)
% C. z0 T" ^+ mprint(dic)
9 ^" N' L- w# E8 }0 @* E# f* D' k. \- c8 B- D
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典5 p- J2 g1 C( m; I! [6 c( s
dic['k3'].insert(0,44)
/ O: v* y, G$ ~! A2 lprint(dic)* [: M5 z! u- k
27、转换
8 g$ w% b. r" a3 T! {& la. 将字符串 s = "alex" 转换成列表  s = "alex"
# M/ ]" g( X' p! k& R! b% P& S( K
print(list(s))b. 将字符串 s = "alex" 转换成元祖
, _1 F9 U# H0 {/ l& u' As = "alex"8 ~2 g3 Z* L( A# g  H
print(tuple(s))
& j6 Z9 z( g, ^. x/ E
- f- ~  i: y+ S7 H9 Db. 将列表 li = ["alex", "seven"] 转换成元组: h" n6 l2 u2 s5 h' W6 Z5 D, b4 _
li = ["alex", "seven"]
+ y' r7 L4 m* Q) tprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
( |3 Z$ ?3 D/ X1 j! n% _' Ntu = ('Alex', "seven")
) v3 c0 D, [; ~0 w$ ili=list(tu)
) @4 ^5 b+ W. X: z( {5 ?4 H) Eprint(li)
6 t8 x' U' H! `1 X* g( B
( o: {+ Y4 b1 o( u( G' L: g% t
, o: ^+ m: q" @- v3 e. J- K/ d7 ed. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
8 E- G, e. X0 |: Q/ w6 }/ S8 N; O& e8 A3 Z0 e5 V1 Y
dic={}
8 J+ h# F6 C# ]' zfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. j9 P# e, A  z! z* e  m dic[k]=v/ w# c  r+ X$ a5 r
print(dic)27、转码n = "老男孩". J3 Q- v" R( y- _0 g
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
8 w% G' ~& H7 o) ~$ F* ja=n.encode('utf-8') " t3 a" g3 Q% w
print(a)6 t! r/ |$ ~  Z+ o2 a3 `; w- ~$ ?5 C
b=a.decode('utf-8')
4 Q: r8 U& z$ M5 dprint(b)
4 ^- m/ U4 T9 G) o: t) _b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
7 ?! Z+ a* I* ^5 |# F9 B5 ]print(a)
# n3 u! M- O. ~9 O" Cb=a.decode('gbk')
" B5 C9 O  ^4 U7 mprint(b)28、求 1-100 内的所有数的和5 C5 A! K, t  S5 W) ~+ m
count=1
: C% }( e* C: X4 Y) ~sum=0: t( r6 r" I6 {; w1 t: t) L
for i in range(100) :
" o! z. r% o& C# n sum=sum+count
; z. O. y0 l7 F  Q( i/ W) X3 z, P count+=1) O( m, c+ T' e8 d$ f7 o
print(sum)
5 x& Q- d" m2 I) L
. P7 M( S: ]7 ~& b  s" ]# W9 zcount=1! |" M9 ?1 r, n: ~' t
sum=0
( b) K' L+ h- u6 s4 _while count<=100 :
! p0 D  ^6 t2 S/ K0 Z sum+=count
3 Z' P8 J' ^4 t0 k- ^7 t2 d9 D0 v$ p count+=1, b2 ]$ k7 f* d$ o& {# F# _' \, _
print(sum)29、元素分类
' b: I4 Q' r/ R7 H  ?0 A$ s6 w有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
0 F2 }" L! V9 j$ O+ s8 H9 ^8 z: y将小于 66 的值保存至第二个 key 的值中。: P9 O4 o: C7 n
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}8 c: v  x6 M% G- J2 e
li=[11,22,33,44,55,66,77,88,99,90]5 J5 b2 M! Q3 z0 Y
dic1={
9 F) p' Y* o8 f( t' j" o2 B 'max':[],
1 E# ^9 X* l" L! l9 i4 Z1 J 'min':[]
9 g5 a: D* ~9 M4 B}
) y/ T2 E9 e$ Yfor i in li :
' F: o$ I' U: I if i <66 :1 l1 X+ ~# q1 P) N! R6 h- E& \3 K( O2 v* ~
      dic1['min'].append(i)
' b' d0 j- I. r5 m+ R5 N' @ else:
( m( e& g( B2 K( E1 ]# }3 M- O       dic1['max'].append(i). k! h1 J5 A- v8 r& N/ d. j$ ?% f/ `. g
print(dic1); u! ^3 S- C$ @% o

0 G" l, W/ u. j3 m: z: K& [: M, M---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
, c/ ^7 X" y/ L9 C$ T- q

Python基础知识汇总

主题推荐