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、写代码) F3 t. S7 j& P( ]2 j0 g
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) :
3 ~# L% f- G* j2 _  F name = input('name:').strip()% a7 O$ w8 @4 ]( h- t. U. [
pwd = input('pwd：').strip()
' z/ |, m! v. M0 M
$ z7 Y3 B4 Q! D6 f( B# c7 w if name=='seven' and pwd=='123' :2 P% ]! t; o+ s8 R1 L+ F" E  b
      print('ok')
" ?2 r: x) f; ]6 f" K; U5 `! t else:( p$ z+ L2 L. ]' R1 q4 @% H) I7 E$ K
      print('error'). h, V) ^$ b) {- h$ r+ H8 K
      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)  :
2 n7 ^9 j& m/ x) s) S  F$ n name = input('name: ')
" T# z3 t7 I% k7 z6 X3 L pwd = input('pwd: ')7 w. T! R$ b: i' _2 r
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
+ b; F+ D0 F+ G4 A       print('ok')& r+ [+ M7 g) j# M& H$ }  C
else :" H. n" }3 K& [$ P* g, E
      print('error')
9 k; ~! Y/ Z( t7 [! p       count+=111、写代码
! Z- ^# L, [2 K$ P' }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 k! q+ e" b8 h0 t4 w if i %2 != 0 :: S* H$ l) N. w+ P3 D
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
2 S0 z/ T2 Z7 }) t3 `* l" l8 _8 l if i %2 == 0:
: g2 e1 V( y. 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"
: l2 d5 p+ Y4 E. i, Z# [. wa. 移除 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)  ?' d' i; j( w2 Z1 ?
for i in name:
% E9 v* G3 Y! c" ]. \: r print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
/ L+ t/ H; f4 _6 i( f& ?22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
8 |9 o; F; i# H4 nprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
, \( M$ ?1 G' ^& X  n) v; F- Gprint(li)5 l1 l1 [& d- v& \% b; o
['alex', 'eric', 'rain', 'seven']
* Z1 x" C; `" Z1 P- Q1 D, {c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
4 Y# c$ K  u" y3 s/ F$ _print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')# u0 d1 N& J8 L) [( s  z* D" Z& j
print(li)
2 x7 H; D) h/ g7 O; V" _8 v  Ae. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']; d& ]! a) d5 Y9 T
li.pop(1)
! y6 i0 Z% b$ K- u" Lprint(li) ['alex', 'rain']; x5 |- [7 K) [/ b8 }9 ~0 |% |
指名道姓的删除li = ['alex', 'eric', 'rain']- e9 J/ a+ i! l; m8 n2 a
li.remove('alex')! k3 Z0 y1 |4 }
print(li)3 a# e( x' P& S- J5 O
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
, S/ L6 z0 f, z. X+ U$ dprint(li.pop(1))+ j7 x5 W& b7 \9 j% i' @
print(li)+ Y7 }. z0 I6 [8 e1 [5 @$ E
" g9 n' N% K3 k# |
eric
7 n! b$ U+ F% I, N  g+ C* F['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
$ ~. S; E. _) V: |/ x+ k4 q4 Rdel li[1:]- e0 F9 c) {& T# V) g
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
+ ^5 M+ k  \# _, ili = ['alex', 'eric', 'rain']* Y/ s2 n8 [7 J% s, X9 k
for k,v in enumerate(li,1):
" e- |2 M6 J. {! C4 m% A6 l print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- |2 L, {4 N, Za. 请输出 “Kelly”
+ D" _1 r1 N  Q) S0 pli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) A6 b/ U" b# ]$ s) b) W1 mprint(li[2][1][1])
5 N# ]7 Z% a! n3 c5 k# J% H% ^' Ab. 请使用索引找到 'all' 元素并将其修改为 “ALL”
; K2 g2 {5 m& v9 @li[2][2]='ALL'7 |! c* y- i9 }  R1 o
print(li)1 c$ T7 q. S: R4 \& V' J" x
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
! E- K* h. c! [0 I5 g5 [3 f6 f% ?a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
$ }" K& n2 c: l/ J. Hprint(len(tu))
0 B3 J% x: T7 a: ?  l/ A: ^b. 获取元组的第 2 个元素，并输出
! m; V" g3 O6 {  q+ p* @print(tu[1])
' \- o0 _4 R6 k1 p- We. 请使用 for、len、range 输出元组的索引. {1 F# v3 s& d5 j3 M, X0 s
for i in range(len(tu)) :
) H0 N2 i! P* N5 S% l print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)5 y* [# [5 H8 H
for k,v in enumerate(tu,10) :
' @/ I; {- p% o) ^( E. Q( s print(k,v)
% {6 Z" Y$ U! S9 z; M10 alex
. N/ n3 k# n, X  ?& T: ^  _11 eric& \1 m6 Q( l4 F9 S
12 rain8 @) z6 o, e5 r1 o
+ X5 ~0 X1 b' v7 j
for k in enumerate(tu,10) :; Q: F0 G9 ^: \+ q% n1 Z
print(k)
# V0 }9 v6 M( f" m; H" q, h(10, 'alex')! t! {2 s8 \9 H' V! o, }2 ~
(11, 'eric')2 j7 P( n- `, E3 @
(12, 'rain')
$ y6 b2 ~5 I2 v( ?& d
( O; [8 C# i( z+ G6 C5 O. l" Z6 ?/ I" g: r5 i2 y
25、有如下变量，请实现要求的功能- B1 n/ E+ g8 R) `. o$ ]
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
& ?6 R! x# n' D1 r% T& b, {- [
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
" f& o+ m8 [- e! {  Atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])# O3 ~4 S( ^0 t% w
res=tu[1][2]['k2'].append('seven')5 N' D4 J8 n/ Q

4 L6 c9 o  E( l( T) V6 i9 {print(tu)
& H& I( R/ ~/ Q+ X6 `' R26、字典+ N5 o! R; z! w* p! U
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
4 g7 D) [$ h/ A+ G, ? print(i)b. 请循环输出所有的 value
$ j0 H- \3 r5 r7 Pfor i in dic:
) t# C6 p1 ^* Z print(dic)
% e5 z& a% [# ?+ }) J2 H! Hc. 请循环输出所有的 key 和 valuefor i in dic:) A% g. E0 i" q  k4 A' L
print(i,dic)* ~% s. Y' x7 D3 a# b, O, p
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
  E5 w. @/ p. z+ n; h8 G: ddic['k4']='v4'; L- V6 [) W2 M3 A( N) e
print(dic)) l3 e  R' `8 O( R
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典+ k1 `! C# l7 i  P
dic['k1']='alex'
8 }4 C2 m: ?* y& K: E  X$ nprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
. ?# k( N. y9 _! u  S- ~dic['k3'].append(44); W6 W% z0 r  t& y
print(dic)
3 f" A' ^; @! c: }, f) d  w& l0 W' t. w2 V3 |# H6 ~
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典1 T# D$ ]/ M+ Z+ b
dic['k3'].insert(0,44), [6 f7 s* J% O( b
print(dic)
, H$ J; R5 C1 B/ d% q" p8 D* x3 h27、转换$ r2 w; u2 p( M( m- Y$ {
a. 将字符串 s = "alex" 转换成列表  s = "alex"0 B. w1 d/ i' K9 n: d

' \' C  d% _' [) I0 N, M# _print(list(s))b. 将字符串 s = "alex" 转换成元祖
) j9 l% N6 D0 T; }0 `$ i/ E0 w$ gs = "alex"8 d2 L' w+ R3 f7 W/ x
print(tuple(s))% U4 o* U$ ~. O! W% d+ Q

6 q4 ]1 ?5 o! P2 pb. 将列表 li = ["alex", "seven"] 转换成元组! I% Y! \, t) d3 T4 o) U, J
li = ["alex", "seven"]8 |0 x7 K- T5 A. w  J; B$ Z; A" J5 l9 s
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
/ w8 R3 W6 v2 E: b1 ttu = ('Alex', "seven")) Q1 K5 r7 L3 m+ I5 }3 h$ K
li=list(tu)
, c% {* |. U# t7 m  ^7 n$ Jprint(li)
1 q: V1 ]" O$ q
: o* d8 J2 n3 F1 R
/ u8 A' J  A" {7 [3 `d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增6 R0 p) @. O! E- ?# b4 t' O' B

  W  w! L$ Q$ Y" Zdic={}
8 @$ E1 r0 b. s/ m$ q  |for k,v in enumerate(li,10) :----li要放在前面，序号放在后面8 K( e# ?: s& w3 T( F8 I/ ^- F& r
dic[k]=v
( g7 z) d' @2 `1 @# h9 z+ | print(dic)27、转码n = "老男孩"6 w5 V% }8 O9 R
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"7 e! t# V  U5 c3 g1 B& B
a=n.encode('utf-8') $ Z1 r6 e- J6 K2 ?5 L' a
print(a)) |& M% A6 a- E- E4 j. r
b=a.decode('utf-8'), A  u3 k" u; Y1 t9 Z: p& v
print(b)8 k5 M5 B' i7 s: y8 ]
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
' L$ h/ @. i5 P- Y$ r1 r6 H+ oprint(a)3 s1 \! x1 J+ m3 n7 W6 R1 D+ j
b=a.decode('gbk')
$ r% a6 {1 A( R$ k) I/ X4 C8 Eprint(b)28、求 1-100 内的所有数的和: H; {+ l3 J) g" Z3 Z( F& f
count=1
2 P  m; b7 v* X4 T7 B: z1 P# o0 vsum=0
6 R4 h- f) z' O' t) ]. p% Afor i in range(100) :) u5 `: y$ [' Q8 ?; L
sum=sum+count) T2 F+ {) @( ]# v7 h* ^
count+=15 N/ }8 V1 B6 P3 ^' V) ?& h0 W
print(sum)
3 f$ _* K% q+ V2 s
" D2 g! T$ \7 t! S) k( icount=1
3 e9 T% L* ~! r& e3 ssum=0: g* J! c$ [. P1 N( X* w1 f! P
while count<=100 :
- S5 r& _/ P0 ]5 H4 e sum+=count8 s; K- R2 \8 p+ n& s3 s$ Z
count+=1) G3 I- e, r& z5 Y% x$ c& F5 Q
print(sum)29、元素分类
" ?7 j+ v# t1 G; e& }有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
7 I( m7 C$ s' S- m* u% d将小于 66 的值保存至第二个 key 的值中。( g3 Y5 X! S- d1 i/ q
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
# _: n' z+ I% i$ N, r" h# b0 j" I9 oli=[11,22,33,44,55,66,77,88,99,90]9 P. D2 C% E8 `7 Y- o" E: h% x5 M9 `
dic1={( [0 ]) ?. d! d- v) o" d# R& a
'max':[],
7 G8 c& O: t- R' D* F! {; R+ | 'min':[]
( H3 y# q; e* q) D) C' R}' N4 E9 U1 O) y- D9 C$ l/ ~
for i in li :
4 q' P6 [! Y+ R, E0 M if i <66 :
9 u/ W1 D2 J9 ^+ i       dic1['min'].append(i)
8 d0 @! _, o2 X  C else:
% e1 E* o1 q' ^9 |/ P# v       dic1['max'].append(i)
2 I6 v& Y7 ?* S$ q5 z: a9 T6 Lprint(dic1)
9 Q2 @; w6 ?  T+ G' z) _' O& Q6 y
, l  N8 K% E, N  ?---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
3 x% S' B% n  v" q

Python基础知识汇总

主题推荐