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、写代码( s: G2 l( r3 T; H: q3 ^
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) :" C' |& k9 \& N7 L7 j
name = input('name:').strip()4 C5 Z2 d3 g% l. ]1 ^9 P& u! i" h
pwd = input('pwd：').strip()3 t: E1 C  g. s& _/ L! u9 P9 h: n
, M3 p3 X) W2 }6 q7 s# L+ [
if name=='seven' and pwd=='123' :
# v; j. l: p! h       print('ok')
/ g& V0 H# C# b1 @; E. N else:
  G. ^2 D# G0 K0 _  F       print('error')) M, _3 X+ k% }$ s
      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 W% W. T& y4 ?8 X; X name = input('name: ')* s# H3 ?" w4 G/ G: v
pwd = input('pwd: ')' l8 J: B& {1 D% G% N
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':7 J8 V5 O; p- ?
      print('ok')2 ~' P& r, j$ q& F* P
else :
, C) }* T1 E/ P, h$ R       print('error')
- V/ q* {# b1 ]/ Y! x, i7 R       count+=111、写代码8 g1 B- G/ }& T1 A- {5 {
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) :
0 h1 G7 _: [9 B if i %2 != 0 :% G( Z6 x( g/ j: 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) :
3 K) Q: L& ~. K; |$ b1 b if i %2 == 0:7 J6 s( u" h; w2 D- `4 a
      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"' I" v- p! ~: ?7 s- n
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). H* L' D# }6 O
for i in name:2 X# }4 V3 i( _1 H/ b: O$ N
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
: m: \3 q' b% A' f) }% m22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']- s8 `, n  l0 Y* R2 W+ L
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    3 W' C& p0 q% Y" j
print(li)& p. \0 }% m: {, w) m
['alex', 'eric', 'rain', 'seven']
$ {9 L' |/ ~- T$ d/ wc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')( m! X1 z4 D% j+ F
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')6 P% ?3 d6 [9 H# T9 ^4 l
print(li)
! }+ W0 ]' o3 M, B; t# a- me. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
# ?+ J1 j' y! D& n$ d- t; ?li.pop(1)
4 X8 {: W  {- Yprint(li) ['alex', 'rain']* p5 Y3 D( s! }5 D% ~' P8 X# Q
指名道姓的删除li = ['alex', 'eric', 'rain']
8 n  N4 q& H( H1 }" Z' O  d! R  Lli.remove('alex')' A( M4 T& P! X3 ], H; k
print(li)
* W9 p! `; j4 e( s1 E4 `1 xf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
* B. N* z2 l2 Y  S7 m5 R4 E2 Tprint(li.pop(1))  r/ H5 z: k4 n! r. ]
print(li)% M8 S0 G7 R+ Y: K

1 M# W$ d5 f) U6 X4 Z$ ]eric
: r1 W! R& x: R1 L0 D! M" ^' I['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
9 G. H6 \, X2 V: U! Mdel li[1:]
& |6 p' L- \5 Qprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
2 c$ Q. |6 H' n3 Kli = ['alex', 'eric', 'rain']/ u1 F% i# \4 k0 G# ~
for k,v in enumerate(li,1):
8 m' Z: D2 {" [" U$ | print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
; Q# p5 R' _+ X1 w; V. G# p  N$ Ta. 请输出 “Kelly”$ y. N' ^: E) y& x% J
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]: t: ?: c, b* m# i: g; ?6 m
print(li[2][1][1])
0 K0 L+ H* N- @4 C4 V9 Fb. 请使用索引找到 'all' 元素并将其修改为 “ALL”" X- m, c- Y0 a: }2 K% w8 ]! |! P
li[2][2]='ALL'" N5 _- F" g* [9 S: w$ i
print(li)# L" ]& u* u: V8 V  O
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'). n0 G- ]+ K) o
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')  A/ T  q' u0 I! X, C# x4 k
print(len(tu))
$ P' ~& S# @% a. b! g8 w  t7 i3 {b. 获取元组的第 2 个元素，并输出
' l" {/ D0 X" \9 W( q$ Wprint(tu[1])' S$ v9 b6 _  a' L3 Z5 C7 v
e. 请使用 for、len、range 输出元组的索引
8 {# o3 @$ i' f  }: B5 Tfor i in range(len(tu)) :
: I1 |: W3 {: G print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
# e+ I7 c+ P( _$ f% f+ M" C3 g8 ufor k,v in enumerate(tu,10) :
5 V+ }! \! J& |: S print(k,v)
. c# v* T& F( ^- R4 {2 r2 W10 alex
; P/ r5 k: a$ i5 A# {11 eric# v- e! j* D' ?
12 rain6 l9 `! H2 a# H; t/ z* Z
- o' u! N6 \* [3 I1 `
for k in enumerate(tu,10) :
* V' Z! h# |! i& n! X print(k)8 c- G+ q5 D3 y6 X
(10, 'alex')
( c5 {; H8 B  d) d(11, 'eric')
. v% k# s+ q. c/ i% n(12, 'rain')
! k" o# p9 j3 I# [1 T( \: Z
* F$ Q# d0 H" r" W" U3 x  P
; t; {7 r+ A: F! V25、有如下变量，请实现要求的功能
3 F$ c; e# K: i3 T9 j) b3 ptu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

+ Q* s+ ?/ b2 O8 S& Td. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以$ M8 u6 U2 Z% c$ ^# J7 Q; S
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])3 o/ A3 H- |1 O* A4 `
res=tu[1][2]['k2'].append('seven')2 y/ M$ H' ~4 A8 Q) B  x7 m

% y) x& t$ G4 j4 x: q' z! dprint(tu)
6 O9 F' A5 r5 H5 ]3 ~+ h2 v26、字典
/ N# Q8 f) ?4 C! z0 Ddic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
$ ?! e) X+ i* K print(i)b. 请循环输出所有的 value$ A8 ?2 P7 M, r
for i in dic:2 A: B; @. `) F
print(dic). u4 Y  \- \6 V0 t: E
c. 请循环输出所有的 key 和 valuefor i in dic:
' \2 k+ v3 Z5 Z: G) C/ v  [print(i,dic)! V+ m- J. n# f
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典* o+ D( ?% _& h+ h* t, z5 f" r
dic['k4']='v4'
8 X* Y- {5 h9 S/ n5 Rprint(dic)- C! ]) h* b  n, P
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
# a: j5 B4 o* f' @* `" Fdic['k1']='alex'1 b1 i1 k! D$ y1 i  T) x$ x3 N, B
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典! i! Q! q4 |. `, I6 C/ ~
dic['k3'].append(44)
* }8 n; Q* }6 ?+ ?5 ?2 ~, zprint(dic)
. X5 r3 D) R1 c* N2 S6 n' a' o( N
& w9 d' P7 L" j, N, T4 X( E6 e+ lg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
4 Y' Y, D; |& f9 k2 C: `dic['k3'].insert(0,44). l1 u7 K2 l( y, X( Q' X% o/ v
print(dic)
1 Y; `3 d. F  M3 h$ e27、转换
' h  t$ N. y( |) z8 I1 v, |) z7 va. 将字符串 s = "alex" 转换成列表  s = "alex": Z: b' P7 C  o4 j3 A

5 J1 ~& n5 [1 s: xprint(list(s))b. 将字符串 s = "alex" 转换成元祖
: }7 T- f: Z- Ps = "alex"
2 b& b( @+ r* P8 @4 L9 H3 Y8 i& |print(tuple(s))
% A+ Z% [* p; f3 c6 V) E: c* {+ t1 {8 L4 ?' b# O$ J% z
b. 将列表 li = ["alex", "seven"] 转换成元组9 d2 ^6 I7 m- I; }+ n! d
li = ["alex", "seven"]
+ s* V* B: W8 R" P8 E3 @print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
! N2 I0 m2 x( F2 j" }" y8 Ptu = ('Alex', "seven")/ D, p7 K. `6 l: z! f
li=list(tu)7 W# f6 R- u/ J" T3 C9 k
print(li)" S$ K) d9 `4 P( G7 t
5 U, N( r0 @6 P" x. c

$ y2 a. d4 M0 Q$ `# ~8 zd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增, z( e; V$ K" O' P) o2 E" y

# U9 q$ M2 P4 ]dic={}- C: G. x  H% i- E$ p- s, t
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
& ~1 [3 r4 f; ]; M+ h* K dic[k]=v) q4 ^# Q: Y# }4 t, w* W$ A
print(dic)27、转码n = "老男孩"& m! q# |. R9 G' B# G1 p1 o
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"" P! J$ A9 Y5 i
a=n.encode('utf-8') ' m2 b4 I/ B" w# J+ y8 R
print(a)
* }  h2 Q% n0 \/ E4 d' M/ V& r7 G/ _b=a.decode('utf-8')  ~& \: I9 F% N8 F, e; n' k! I
print(b)
8 S' T5 J1 n. g# }' F  ]b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')7 s8 q" p; \3 N
print(a)
% w+ V0 x; d1 X5 K* Db=a.decode('gbk'): w3 ?1 i& W2 W% v3 j. ~5 i: M+ G4 \8 m
print(b)28、求 1-100 内的所有数的和
. M8 X4 X) o! k  l) o/ ?count=10 s+ Y) L) B$ ^
sum=0
( v6 @( g# M/ [! S7 z1 [for i in range(100) :
- r" I7 C5 m+ J" F: Y! ^ sum=sum+count
* [0 _, |8 Z0 t: W- I0 \* i9 W' x* U count+=1
1 X, z( {2 R& {7 v( Z+ j* Sprint(sum)
9 J' w" z/ \9 c  D+ n9 A- j, Z- b4 D% p# j: L1 R6 i5 q2 i
count=16 ]- ~4 a( X" X: [3 F" ?5 r! Q4 ~  X
sum=01 C2 ]9 {( @% q
while count<=100 :6 m% n9 q( y0 o6 ]7 J% r8 K; O8 T
sum+=count
# k' }8 P% |2 N count+=1
. Q1 `6 o/ \+ f& K8 Nprint(sum)29、元素分类" H4 B2 I% F( [# R; A+ `* S  q9 v8 _3 E
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，0 n( Z1 J$ d5 o+ h! Z6 V2 n
将小于 66 的值保存至第二个 key 的值中。* J/ a; ]+ o3 ^: J6 F( W  C) |6 {$ x: s
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
" X8 c* d1 N+ z* z+ Cli=[11,22,33,44,55,66,77,88,99,90], G/ L9 G6 [  H& T
dic1={( M6 {  T! }$ S$ k
'max':[],
$ u1 a( O6 G# ~. c 'min':[]5 T3 Z$ x) z1 J' z
}
2 i  ^$ Y: G. \  V% W4 Wfor i in li :
( @* J  A7 B; ]% S) Y if i <66 :
& G7 {% t! ~# o) x3 u3 J9 }3 a       dic1['min'].append(i)+ `# L" l4 v9 S: g8 p1 q( O% J8 Q
else:1 k( {; ~$ q, d% i: V: X! b
      dic1['max'].append(i)
9 |1 {$ o0 \  Y) o# v$ Gprint(dic1)
' m3 _0 I$ o' W5 B7 t4 \( ?1 N+ O5 }6 g2 Z( @9 ^( L
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
4 n* g8 @4 E4 e: j8 ?; v

Python基础知识汇总

主题推荐