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、写代码2 [1 V% L- y; x$ M) ~4 v# o) ^
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) :9 q' H& U- |9 f
name = input('name:').strip()
- }8 g# t" x- s7 L/ v1 \ pwd = input('pwd：').strip()) q) _9 ~  |2 ?. ?

1 S% ]) x8 l! C' R# M% d( Y if name=='seven' and pwd=='123' :
! T! h9 J* M) G7 v5 J       print('ok')# {- J! G5 z% [7 Y+ W
else:4 c  X/ `, s6 x5 F3 A
      print('error'). w, M2 }; g% I# I8 D; b
      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)  :9 w% `/ n! m' L2 L, K
name = input('name: ')
+ p' g8 q1 O) ?3 d pwd = input('pwd: ')  G/ Y" c& H  W; i/ h/ o! ~; _
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':8 N5 M' t' v( _1 U; B) n0 s! `* U* w
      print('ok')
) f8 z9 u  E2 J% D0 p else :# O7 B- J! Y9 ~7 Z( s! }/ l
      print('error')  ^5 s+ {0 L. `- Q3 A2 {$ Y
      count+=111、写代码; O2 s& ]2 z' p$ I! \! @1 \: q' e
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) :
# l2 t  x% }9 j# N) t5 {6 [+ l if i %2 != 0 :! [4 u) u) u# r, X' Q
      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 r5 \4 \; V- s9 v8 d if i %2 == 0:, M# E1 ~1 u# c  C
      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# M( c# F2 r* M1 \; Z% @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)
4 o" _  B8 Q$ e9 L# vfor i in name:
0 g3 F% J  R. a0 c2 e- E& }: ] print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
" F/ W- i+ D+ ]4 ~$ y22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
% m) l+ r8 n6 {print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    1 V! B$ b, U/ k' y# k' R& `4 G/ o
print(li)8 t2 P$ f0 m# u) u) J+ w& Y
['alex', 'eric', 'rain', 'seven']
+ V# X8 B/ W0 R0 n! S+ f' r0 dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')) ~# t  Q5 L0 W. d
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
) u3 j1 V, @. L  {. D" S# p9 P5 uprint(li)5 c* `4 w! w5 L& l$ M
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']! Q7 B% Z2 ~' q
li.pop(1)
4 g% e7 n( t6 tprint(li) ['alex', 'rain']
& e% ?) w6 D* D8 P; p$ L% z: {0 q指名道姓的删除li = ['alex', 'eric', 'rain']
; Q; W# _7 q) E2 ~2 m( z! u! fli.remove('alex')+ o8 E$ e" J6 {# c. n
print(li)/ p4 G1 Q, f9 n# X, A
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']* P) V# U+ X, k
print(li.pop(1))  k3 N( N. _% B, @7 a9 H
print(li)( a, k8 `; e4 p& o5 U- _
' x5 Z% ]) f: h# W
eric/ [1 a  A% \/ O+ s! @5 A: k
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']6 m: I" g6 M8 Y' R  y. J  m
del li[1:]
! t" u) v+ a4 E7 O' p/ s! Wprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
$ h4 b7 c) x1 v/ R! wli = ['alex', 'eric', 'rain']5 ~  [) X) L1 z
for k,v in enumerate(li,1):* _5 T+ z3 V8 S; S3 V
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 u. _) a* u8 L+ k* D5 S
a. 请输出 “Kelly”
# H5 z, j! T5 u9 i) jli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
( w) {, m1 Y8 V) h8 @5 j9 D# C/ xprint(li[2][1][1])0 `& V+ f7 O2 \3 W, ~$ X% U4 H! K
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  J- p# i, y  O& h6 S& ~% zli[2][2]='ALL'& X. g( N* L2 c  t8 o6 b0 C; S
print(li)
0 o$ O) }3 W2 \; v# ^6 R: M, y24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')9 c# L. }- A0 c7 k# g
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')% g& E3 ^& m' ~5 Y) S; a
print(len(tu))
  \$ N9 U: M$ ?+ `$ t( xb. 获取元组的第 2 个元素，并输出. ~0 I( U+ g+ [6 d$ M+ b( Z2 L% y
print(tu[1])
2 {5 S+ u: g9 Te. 请使用 for、len、range 输出元组的索引7 n. @; w( Z# v; n# _3 K# G* b
for i in range(len(tu)) :
7 |/ \: }+ F" } print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
' }; J% _: c) S7 _! Vfor k,v in enumerate(tu,10) :% k) o3 h7 F3 [2 |' H1 i
print(k,v)/ q. N3 [( C- N% r% ~5 H/ D1 r
10 alex
! F  [" R' x  x! W( I1 e% I11 eric9 s, B+ G7 ~! y9 C& ~
12 rain1 P3 I' t/ s) \5 h8 |; G4 }
" G' ~7 ?# v  ~, c6 i1 ]
for k in enumerate(tu,10) :. ~) i& m! `/ a; J! V
print(k)+ b9 e. X% b9 g
(10, 'alex')
* P4 Q" r$ ^$ x: i5 c  L& r(11, 'eric')3 p5 {( L# O. ~# l: i$ ^& `6 M
(12, 'rain')
4 b% i9 @" Z- W, Z. ~$ M/ j4 g& [% S

% U6 i9 U8 Q4 h0 x  t" X$ b25、有如下变量，请实现要求的功能
% D1 k4 D8 w: ]7 R: r4 Stu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
% B6 u' R3 I3 F+ N9 G5 Y
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以" @) J+ g1 J! [  o' j& B
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
- X8 t3 }/ L- K: ~# e" w: ]res=tu[1][2]['k2'].append('seven')3 x" z% n; p3 k* t; g

2 A$ S$ q7 Z; \  m* m( D* lprint(tu)
! l# {+ t; X( I! b+ E& h' o" }+ i26、字典: s- Z3 i, W# u
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
. V9 H% m! K2 i+ x1 K' o+ T print(i)b. 请循环输出所有的 value$ `8 c7 G4 O; W+ G4 w; m  g& p
for i in dic:* [3 P) }  F' z7 @
print(dic): l- D' O$ k/ z; C! C; q9 d' E
c. 请循环输出所有的 key 和 valuefor i in dic:4 d- S/ x6 x* `
print(i,dic)* t& r3 j4 I* ?2 p$ A  {- M
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典0 O9 N% \& {! J! ]  o5 w6 X
dic['k4']='v4'
( X: y: a& x4 M1 _& D4 y& lprint(dic)+ @( L( W% Z3 v# P3 l& X
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
) L' a5 ]1 @7 u4 d7 a3 S  p6 Adic['k1']='alex'
! t4 O4 }8 ?1 Hprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典& m8 F. I( Y, l# q- _
dic['k3'].append(44)
4 s  H! l4 Q3 C1 U: N& Sprint(dic)/ _8 S" R9 ~: Y4 Q5 G5 S5 h2 n

, H! f  J( J/ M- q* U7 bg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典% @1 G8 o" G$ E; n. _
dic['k3'].insert(0,44)4 _0 d! E0 [9 V) c
print(dic)
* M$ K0 O7 N6 N! M# S2 w27、转换
9 n. m3 L  }. ?/ h9 b6 oa. 将字符串 s = "alex" 转换成列表  s = "alex"6 k/ c$ {) P  ]/ Y/ G
% |  \# A$ f9 @2 H5 s; K" ~$ a# Z' g
print(list(s))b. 将字符串 s = "alex" 转换成元祖
8 W8 c" L" i! N5 es = "alex", ~/ W: ?$ O( _- q8 Y* X
print(tuple(s))
9 I8 T. E7 Z$ D' m1 Q4 A+ P! Y! B
! r* ?- v; s! G" U$ Yb. 将列表 li = ["alex", "seven"] 转换成元组. \% ], ^. s6 B! Y: I" }% F# X
li = ["alex", "seven"]
3 J' p3 ~  f0 m) d  G0 jprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
. y. e7 v! G7 Y8 ^tu = ('Alex', "seven")$ |& t- r5 N  X+ z6 v9 x
li=list(tu)
' x+ s* n( ^% V% Nprint(li)
6 B" @. J$ e. F# M) {7 L7 G- g
& s4 E8 D6 q$ M% [8 [# j6 e* Y5 Y! K3 a* z9 o1 ^) `
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增; H& V! O6 D6 o  H, W, Q

% c! k( b* v+ E( W( a8 Z  Y7 {dic={}, N2 v! A7 e3 P7 I0 |" k
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面: y. D; c3 c9 L7 ^1 H; ~' {7 t
dic[k]=v1 Q0 z/ {" E- b$ R
print(dic)27、转码n = "老男孩"! q3 `- c' E7 U0 ?
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"; ^$ ~; k7 S$ l( i+ ]
a=n.encode('utf-8') / s1 P$ W/ m5 f& U" A
print(a)5 W! N, _. |" n! J% w; \
b=a.decode('utf-8')% [( ~! N, a1 U0 p
print(b)
; }0 [+ x9 }& L% Z" \) B: H; @b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')6 }$ [& r: }" p* R3 e: t
print(a)% n% Q. H$ q% B; h; S
b=a.decode('gbk')$ U+ @& H* J# P0 s+ b  q+ u% U
print(b)28、求 1-100 内的所有数的和* I3 t9 p0 k2 F% l: O9 o4 T: {
count=1
: C7 p: Y! U% E$ G. Esum=0
+ ]( E/ U5 [: R+ r; v# n' f" cfor i in range(100) :$ t: Q* M5 i. l' L5 v  L  \# E
sum=sum+count% [1 T% r! j  x' p% z( i' m
count+=1+ _8 B0 ]4 r0 `& |2 t  k3 F3 E  B
print(sum)) p$ v, G( P% r# b* ^& _
; p) U; g/ h+ Q$ r# T+ M9 D
count=1! F3 G% U1 E! p
sum=0
) g  }0 Y# ~; s' M; kwhile count<=100 :" {/ F  @9 ~5 e) a; ]5 f4 a
sum+=count2 z- N' A5 n7 X1 p; l" B  S9 m
count+=1) w( D* t& P6 V
print(sum)29、元素分类
  H/ ^8 z- O4 U, Y6 ^6 K2 n; P有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，7 [$ L8 f7 n" k  s$ Q- _2 R) {6 ^
将小于 66 的值保存至第二个 key 的值中。0 E0 a/ e) s- m* ]2 m% H  r
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
. J( `4 P  I; p( bli=[11,22,33,44,55,66,77,88,99,90]
$ b% D' K/ F- _+ C4 m  e' f: edic1={
' `5 ?; [; Y0 c' m5 D: r; P9 M 'max':[],1 G) U3 P5 }& F$ V/ h9 q) u# ^. q
'min':[]
; v. n& m4 Q+ m- K% Y2 o, X}
5 L+ A% F/ W+ R- H7 N3 O+ n# Sfor i in li :
5 _2 h8 p" H' F if i <66 :: H5 Q9 a* m9 x7 k( n8 ^
      dic1['min'].append(i)
* v; s* c" D& j/ d! b6 ^ else:& C& i. T& B5 Q. Q* @/ I1 v" e$ n% i
      dic1['max'].append(i)* X, o/ {; z9 p+ W
print(dic1)
4 Z% u# |/ Q/ d
: b; z* e; s( Z& r6 Y---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}2 S/ _) k8 |, Z7 S

Python基础知识汇总

主题推荐