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、写代码
" S7 @, [# Y# e( U. s  ka.实现用户输入用户名和密码，当用户名为 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) :
% `. `- v9 e. @3 }  w+ n* a# ?) q name = input('name:').strip()* A7 m2 L$ w# J2 ?+ X1 Y
pwd = input('pwd：').strip()
% J7 S+ d& m: w! X% Z6 L3 d
. e: q2 T/ [  V# | if name=='seven' and pwd=='123' :5 j7 @: M' v) w9 G6 F$ J$ M. T  M
      print('ok')- z) v$ U3 p% [% q
else:( E. @/ W0 {7 O0 L, v' L9 N
      print('error')% H* M* e& C( P
      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 }9 x4 V7 c& O1 a
name = input('name: ')# J9 c2 c$ V/ P
pwd = input('pwd: ')% o6 a% |, e0 a# p
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
" Y' V7 v3 C: V, i       print('ok')
. D# w6 o$ @# [ else :
# `: G, d9 l! K* h       print('error')
7 W& V! h. x7 j# h# D: i1 G8 }       count+=111、写代码" q- C! J6 H+ ^7 G7 {9 w( F
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) :
: v; v1 b9 o& q if i %2 != 0 :
  r7 {" Q2 b6 V8 d: 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) :* {! M/ l: l: ]; a
if i %2 == 0:
4 @3 E& ^; }& r       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"
  T6 ?4 m5 [3 l: N8 b+ xa. 移除 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 K4 v! W) j5 F5 `' H& I- S/ `4 d
for i in name:/ s5 h4 d  b+ s/ z& V
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain* f" K, r+ C6 x
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
; I$ S# h9 R, Q, zprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
0 Q# W7 K& L; b5 g% u6 x) E, Lprint(li)
. U5 e" a5 P# s3 _' T. K1 | ['alex', 'eric', 'rain', 'seven']
0 ~/ }6 z; |. Z* P8 T9 z, Vc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
$ ~! {8 y* v8 V7 v$ J! Nprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
2 A' u! @8 V& t& xprint(li)
1 C; e2 i  a& p; te. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']8 A" a7 l* D: F8 B0 [
li.pop(1)+ N$ K# j6 y4 ^5 X
print(li) ['alex', 'rain']
6 h; Y: m2 J9 N" q2 w. T指名道姓的删除li = ['alex', 'eric', 'rain']
1 c* ], y+ k8 sli.remove('alex')4 F1 p5 C3 m) H& R5 X0 R* m
print(li)( Q' ^, c& Z, T! s3 V
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']9 B" ~3 _8 b' B$ E) u
print(li.pop(1))
2 y* j; Z- s8 L3 H, gprint(li)! L' }5 |8 D3 Q, @+ G4 f, j9 E

- }$ E4 G# q  ^% x' {eric
: j$ r' _9 s; v9 K; F& O; u['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
! B" B! C7 z: g- i1 b+ v# p: T4 ~del li[1:]
5 Q  j6 P* \- P, `" r+ Q& jprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)7 `& P$ L3 s. f) w9 ]
li = ['alex', 'eric', 'rain']- t# B) R% k$ E
for k,v in enumerate(li,1):' b) m$ V9 {5 c) I, W! s
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]9 A- H+ V* _" f' k
a. 请输出 “Kelly”% }7 {6 j, }- `
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
3 D8 R+ A7 Q8 kprint(li[2][1][1])2 w0 S  L+ @' A# `3 b8 ?! M
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  x9 T- F  X1 zli[2][2]='ALL'7 S+ R& T8 e6 Z; M0 Z: Q, }. D( q" ]
print(li)
+ Y1 ^+ i7 v+ o24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')) H% j$ w' ~2 B. O0 k
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
2 U+ |' Q* Y  S" S6 Qprint(len(tu))
7 _$ I1 L# x6 ?b. 获取元组的第 2 个元素，并输出7 k: n( m+ s1 a% Z
print(tu[1])
. }2 k9 e7 D& q7 o* De. 请使用 for、len、range 输出元组的索引* x* }% e: ~* r+ h
for i in range(len(tu)) :% [& z. j+ ]2 Y/ y
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)+ H8 V5 G* w! n# f# y
for k,v in enumerate(tu,10) :6 s3 f3 t; E5 ~' y) P: r
print(k,v)
1 }# h8 G1 H9 M' b% B+ Q4 j% C10 alex
7 C( E" G: b# V# b9 Q11 eric
( c) s: {7 l# O: W- \% i  f' H: s12 rain
$ U2 D; b7 J# c) @% K- g1 L
: G- h9 u  [3 e8 [3 x1 Y$ V! E4 `for k in enumerate(tu,10) :1 l) m% V6 y9 b8 z  `1 [. p/ s
print(k)7 `& r* t% C" f1 I' f  ]
(10, 'alex'): h% V! S" J+ \1 G, k; Z* c% k. G
(11, 'eric')
/ e9 }) C6 f4 t5 p3 C+ M(12, 'rain')* d9 M2 `5 n. y: m

. M+ ~. j. }8 o5 L! w% t0 C5 X7 M% R9 ~9 }% _; N2 U
25、有如下变量，请实现要求的功能
1 Q. S- m2 g# itu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
8 a" W5 g: E" j$ q" ~2 C- X3 p. v% j; B
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以& l: [, q* I' k; r$ {6 h0 j
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
" u' s% R$ x' S) V6 ]: mres=tu[1][2]['k2'].append('seven')3 b* r+ f" V6 N

, B+ C4 y8 Z  w1 kprint(tu)8 r- Z5 z" f; q1 k
26、字典$ g" l6 p% s9 J  c% \% ]9 J  L* X
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:# W" a5 T1 W& ?8 \- W
print(i)b. 请循环输出所有的 value6 D0 W3 H- j5 [" k
for i in dic:9 R0 [6 }; p, U; b+ y( I/ p
print(dic)
! q' [; E! a( ]2 ]% g# wc. 请循环输出所有的 key 和 valuefor i in dic:
& i1 F4 R0 a# X1 ^8 o: ^print(i,dic)( |5 k: Q) M9 D% W" R& W
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
9 p/ a4 q6 L( Rdic['k4']='v4'
: o" D0 m$ C7 B; i7 i$ L5 [* `( W/ j" Tprint(dic)- |& n3 K8 J; [
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
# q  A, m' ~7 x2 x* A6 P+ a" N* kdic['k1']='alex'% N. w& |% W& l! K
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
) b( i& J( S8 n4 n+ u# cdic['k3'].append(44): |$ W/ Z. V. A, R& ^5 i) s# K
print(dic)9 k) R5 Y8 i; n' O; N# `
, z& N2 ]( B0 P6 E' d. J. N
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
4 C$ A6 R6 F. tdic['k3'].insert(0,44)
- W$ X3 L2 E0 j) P! Gprint(dic)* r5 a% z" _% ~/ r- W. r
27、转换
7 o9 M; a* E4 I5 Q6 L" {* l' ra. 将字符串 s = "alex" 转换成列表  s = "alex"
+ o* S8 ]* A! T# f) _. {, }! K+ p# Q+ ?4 ]6 d6 i- M' ?
print(list(s))b. 将字符串 s = "alex" 转换成元祖
2 c$ N6 y; O( X& d) D3 N+ U' Zs = "alex"
6 L/ x4 L3 Q7 j4 A4 Lprint(tuple(s))
  I! X' u  j, r
. R- }! k+ w9 ~% l: u+ Q; R* N3 kb. 将列表 li = ["alex", "seven"] 转换成元组
  J0 ]6 l( D: d9 lli = ["alex", "seven"]) \& E" O' R1 `5 @
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表4 h" S# V* s6 E7 L; Q7 }
tu = ('Alex', "seven")/ F0 H& i2 s( D0 s, m- t! ?
li=list(tu)
& S! T  ]8 g9 p* G: f( d- |print(li)$ q+ o2 p7 b$ N% T/ r* ~- g
3 \% L# H+ Q9 D  E5 q7 L9 q& r( V3 B
/ ?* G7 p, M; m8 C1 V+ F8 E
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
% V0 \% D$ w, `9 @+ Y
3 ^+ F' i% S5 C: ~8 udic={}- D  `! w- Q- `; M2 w3 B
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
3 U$ d$ ^# V( J dic[k]=v$ q; z" w+ [0 ?
print(dic)27、转码n = "老男孩"
& v& d( O4 H4 |6 ka. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
+ N* ?& o7 ^8 _9 ~a=n.encode('utf-8') 7 ~* [7 V5 o  L1 R( W/ a' P9 \5 o  l
print(a)
6 w6 @+ j' ~& Hb=a.decode('utf-8')4 C" [% h% }& p+ `; V
print(b): _3 S" _- y2 t- F% A: j5 l  \0 G
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')6 x+ {" m/ H0 S* S. o& v: q$ `
print(a)/ w/ V$ c2 b1 Q* q# T
b=a.decode('gbk')9 B& }  h- Q6 f" l8 L# _6 ?
print(b)28、求 1-100 内的所有数的和
4 u% z' R6 |! G% m+ Mcount=1
; t5 V1 n+ Y+ o* [" Tsum=0
" }. n- {5 K2 q! rfor i in range(100) :/ t9 V9 ^$ Y5 K
sum=sum+count0 a7 h, J2 ]4 z5 i  o9 M3 g! L* u4 [# h
count+=19 ^: U! V3 r/ {
print(sum)
; s8 r2 g+ O9 ^# r1 \; @; w# }6 M' i$ D" `; z9 Q7 ^6 W1 e
count=1
, Z7 n) ]7 f3 C5 W) ~* Osum=05 L: L  ]6 q: c* ?# E
while count<=100 :9 R$ {& ]) _- a4 ^9 d; {9 e
sum+=count" T% C" f: S, `! G
count+=1
) o! _, `) _$ f6 |% U- oprint(sum)29、元素分类
0 n6 h( w/ P( I. ]- F% t有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
, Z2 b) t! M, l% W3 T7 m将小于 66 的值保存至第二个 key 的值中。3 t( ?$ f- k2 S7 P8 H' W9 c$ c; b
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
3 k9 i! R+ v' V) K  bli=[11,22,33,44,55,66,77,88,99,90]2 {2 W6 i+ y( F# r( Q! @' {1 {2 `
dic1={
% k* B0 v: }$ X) p1 I 'max':[],7 v# Z' z8 y, C" \- Q4 {  j
'min':[]
! _- j0 h3 `( N7 m* Q' a}
/ m9 x' u1 o2 V* C2 A  C2 K8 d+ X" qfor i in li :: Y; y7 X5 b( x, {
if i <66 :
! T) l. J: T1 |! {8 N, h, d- \, K       dic1['min'].append(i)
0 o7 Z* @6 Z/ e- X' N else:
+ G% R3 J7 @% T+ f9 M/ i8 _) e       dic1['max'].append(i)
( z* z3 }5 E7 i) u, O% }print(dic1)
* U. p! {2 F1 Y* q5 s6 @+ R9 r8 P3 ~- x& W3 W( w' u
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}( O9 h$ Z/ Y+ I

Python基础知识汇总

主题推荐