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、写代码) t! G$ N; t* i  l/ b5 ~( V' q
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) :
$ s, Z) }0 f5 x. @0 T name = input('name:').strip()# T8 e' `( L1 w! ~( P& K
pwd = input('pwd：').strip()# ?8 b! L4 o) _0 A/ `9 K1 O

" h/ z( H9 s& Y! W if name=='seven' and pwd=='123' :: K! n7 w$ ~7 Q0 I
      print('ok')4 C* W! n6 P% a5 F
else:
+ A1 y9 y! W$ F       print('error')6 G" ~( H1 @) F4 G+ R
      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)  :
, ~* G; S: s4 ]2 v0 r' S+ ] name = input('name: ')
9 r7 @' e- l$ O4 N+ l% ^% v pwd = input('pwd: '); l# H" M8 A) k- S4 x  o" p3 d! d
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
& z/ O1 B$ o9 r7 ~$ K& E       print('ok')
6 ^1 q% Q  D2 z) d' \ else :  Q9 m; o2 J3 R7 b) l% ]) F
      print('error')
: O" H6 Z  R9 [/ c, p# h7 A  ^       count+=111、写代码
( Z# j5 R; H1 t3 X3 X* w# Na. 使用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) :
# L7 @4 ^. F* [7 @0 S, w8 G% Z4 r# x if i %2 != 0 :
; ^% o0 M: w8 G/ W! P       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
$ e5 p1 s  C/ Y. } if i %2 == 0:: F3 V! B) ]% W5 I1 q6 Y& m
      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"  r" G8 A) J0 R$ Z0 c0 O/ C
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)
: p8 T% i+ Y- s9 y" p: {4 ?for i in name:
2 k7 E) E$ b+ G! r print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
8 k9 I' ~' ^1 h% B5 E# K/ j22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
( {  b7 V$ z: p! q6 ^$ d; ~: F/ uprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
! a: E$ P5 G" m8 o# ?3 mprint(li); F6 K/ m4 }: ^
['alex', 'eric', 'rain', 'seven']# Y% d; \/ K# s: G
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
9 E8 \! F& w; i* B0 ]. ~0 G& U! Eprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')5 h* J% R/ ]/ g. t8 o. S) S  R" e
print(li)% m# w$ f2 c$ @* j/ v
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']! I7 b: \+ L6 n* M
li.pop(1)
5 u7 g% V$ N, M1 d; v! yprint(li) ['alex', 'rain']
, q. Y4 `9 k& V: o5 l/ m指名道姓的删除li = ['alex', 'eric', 'rain']6 ?" Z1 ]% O+ M/ i: o" D/ `% @4 z
li.remove('alex')2 {7 q; v/ K% _0 X9 J8 Z
print(li); |. u9 Y" P' S2 z" D: ]7 |( ^% [
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
' m7 \. m3 N0 M2 x+ Pprint(li.pop(1))
4 T- W$ a$ v$ _0 Nprint(li)
2 t, ~- d7 A4 I$ c- R0 i' Z* L" P2 i1 G9 y
eric
% R5 _( q4 C, g1 j) F  ]% L['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']& m' t. p8 M2 T% H" T0 a) n
del li[1:]  ?; Z* V4 x4 N" L
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)/ [, _: R0 Q# W% e
li = ['alex', 'eric', 'rain']$ s7 O( U+ c/ u6 K8 F# B
for k,v in enumerate(li,1):
) z( ~) u7 g; x1 H2 @% J! O print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]/ f, t' @- |9 I& N  c$ b/ f
a. 请输出 “Kelly”  J6 _$ n/ Y7 V. D6 A$ [1 M) f
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
* x" d3 w. L+ S$ |/ k+ `print(li[2][1][1])& l! G; X  A- {: q, Z2 L) u: g
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
# c9 H9 E) t7 a* a* w4 Jli[2][2]='ALL'$ c0 G1 G8 S) p9 D( H
print(li)
7 L9 h2 c" y3 k  B; |* R24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
# {; M% z- V) Aa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')) t! B# M; g; h% b. K/ O- }
print(len(tu))
1 W5 r3 z& X: A' e, Db. 获取元组的第 2 个元素，并输出
, ]: ?* U9 k" Qprint(tu[1])1 P# J" k/ f2 X& j/ a
e. 请使用 for、len、range 输出元组的索引
' \, I8 h- ~% w+ k" k9 J+ r" _for i in range(len(tu)) :
3 I/ p' V1 u, q2 g print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始): @" M2 s5 t3 q0 E- i- @
for k,v in enumerate(tu,10) :- p6 a1 y& X: j* d. P' F2 h) h/ E
print(k,v)4 V+ {/ W) F* S5 q( V; U- d" n
10 alex4 k4 z: A  b$ O6 F
11 eric& r/ e: P) e! Y* k
12 rain
3 z% Q1 [2 m0 g, B( i- Q$ I4 A9 }
for k in enumerate(tu,10) :
  ^# O( G+ r% g! u print(k)4 c6 ^6 X/ d7 {) |+ Q9 A3 j# V' V
(10, 'alex')
% x# J4 I) A! w, K" `/ h(11, 'eric')
0 [( E9 \7 \& E; q(12, 'rain')
$ y0 q% H3 m# L; {: _% {" g' P
. W* V' y. A6 l, L0 o0 d4 W  R& d5 E; |: d+ Z
25、有如下变量，请实现要求的功能# e: k4 ?9 x2 w( o% d
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
  o  D5 D, W/ {5 P! W2 u; y
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
! T  G$ O" z. b5 H4 W0 K; |7 etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
. S, ~! \; ^6 q, O& G* hres=tu[1][2]['k2'].append('seven')
/ [4 u$ A: w$ L! L" @+ i, J( H
, U9 m+ \6 J( p$ fprint(tu). j% H  ~: U& ], ?. Q( y, s
26、字典7 _- {" s0 g0 k- ?3 ~
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
+ k0 B+ `: D% J0 t& x9 b3 R9 z print(i)b. 请循环输出所有的 value9 n! k& v( l; N( V* Q. A
for i in dic:
$ E3 o( H& m1 i9 U3 X print(dic)# d* J3 C2 i: J4 G! ]; V
c. 请循环输出所有的 key 和 valuefor i in dic:* R- V4 _7 }: Z3 b+ y- Z
print(i,dic), ]- q6 f  }* H; e! s; B
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
  N- D5 E+ _' ~! A1 J0 E+ cdic['k4']='v4'
: D+ [; g; o! ~2 E, `  s' Kprint(dic)5 v7 J. Y8 f; n1 u
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
  E0 b" E- {! H9 Adic['k1']='alex'! t* x! @: y& w- c9 [
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典0 V3 |6 G: M& ^
dic['k3'].append(44)
. ^. W5 h1 ?' T5 I2 \5 jprint(dic)! e& h7 ^% n3 ?2 \

" y7 A0 r$ D' D) C0 jg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
& W/ b7 J9 H. ?  Ydic['k3'].insert(0,44)+ ?" y" S* U# a% o+ n( ^5 c
print(dic)( y7 |2 R% P" j
27、转换
7 E5 I  l9 }) t7 C. ^! g# S% na. 将字符串 s = "alex" 转换成列表  s = "alex"6 L- _# E: \6 V& r* Q1 r" k4 c

2 C+ C. M4 j; m% P7 i+ P$ {4 z2 F$ eprint(list(s))b. 将字符串 s = "alex" 转换成元祖
! q+ C- i, {9 T- ]7 v2 o6 Fs = "alex"" r2 z6 {4 ?% F: T
print(tuple(s))
( S; M. Q' ]: ^: `! f6 Z; K4 [% Z; V) S! n, y7 S0 w# f
b. 将列表 li = ["alex", "seven"] 转换成元组
  T. d8 X6 y# Q0 h. Ali = ["alex", "seven"]1 g( ~  f; F' R! X- K$ x% r" g9 y! O
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
0 [+ \' b. _) t. K7 T$ Ctu = ('Alex', "seven")( f6 f* C+ K/ T' G  A% m2 _
li=list(tu)
. }) ^/ ~! e$ I- D9 F+ [# V9 Q+ C" wprint(li)
5 X. M3 g8 z* M) Q- F: ^* m" i. ]0 |' u# B* w( M6 r" l& C: I9 P

9 \& ?, N* {8 g! @* v' zd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
) v: ~* ^3 i) ]: K. H" P. `; X9 l( s- u& k& i
dic={}" B. t- Y+ J1 W2 i& J" Z
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面" A4 X* K. A$ k0 E& o
dic[k]=v, N* M0 k8 u. ^+ G& t) |
print(dic)27、转码n = "老男孩"
1 F5 `1 F7 j8 j: H9 L% _a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
- \( K, I% H9 N1 w: F, x$ j2 u/ ya=n.encode('utf-8') ; u" q6 k7 _8 Y( d* k
print(a)
, @: ]+ |2 i$ t% Tb=a.decode('utf-8')
7 m" {9 g. f* M9 `7 e9 J, oprint(b)
: C" \. p* s& K4 {6 M- e/ @b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')% v8 g2 H( F; ]; x  X+ t; q
print(a)
$ y2 G( N  M; d* Jb=a.decode('gbk'); _6 h. K/ G) m, o) W' v) j6 K
print(b)28、求 1-100 内的所有数的和
5 R) ^+ p4 c. v3 x0 |count=1, {6 |8 L  o" N3 K6 X
sum=0
! B" Y0 T' U2 u5 afor i in range(100) :
3 ?  }* g: l( N sum=sum+count
- q+ [* M0 x1 _8 S count+=1
* C" g' w2 m8 Vprint(sum)
& x$ @4 F5 c2 {3 p) T' g; R9 S* I- ]. v3 ?
count=1
. Q' s! A& d. w( T0 gsum=0. b& m+ l4 E9 n$ Q- S: c
while count<=100 :- n1 z. n, g7 m
sum+=count
. \2 T  w) P3 r3 x. Z count+=1
8 S4 K6 v7 X; p$ R- j6 ~& s- e" x3 jprint(sum)29、元素分类
5 Y* h' q8 P, {# Y+ I有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
7 i* T+ f; b3 P8 q. V9 s, |将小于 66 的值保存至第二个 key 的值中。
+ U9 k9 `6 m, d% O. e- Q8 d) K即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}  G! y7 _: u3 }8 O, a1 v
li=[11,22,33,44,55,66,77,88,99,90]
/ }! \  F$ c% w" |$ }dic1={! P6 W% ^0 D: ]$ q
'max':[],% A  Q9 W3 q0 B+ A5 K) @0 J9 {$ E
'min':[]
, @0 ]* \2 H" s! f}+ \! ?* _. ?) U) H
for i in li :
" R, G' d% p# b' A$ A if i <66 :
+ E0 u+ O; y$ A9 w       dic1['min'].append(i)0 o, q  a& V# _, [# N
else:
: U% d6 ^1 b* K! a4 G       dic1['max'].append(i)! X. _4 w  l2 ?
print(dic1); m8 [0 A( e* n! i7 Y0 s
- X, P! c( E9 N; M$ D/ z
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
: @8 E2 n) |" e8 I( @# @

Python基础知识汇总

主题推荐