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、写代码
( z9 G$ T( C, N! X8 X0 ca.实现用户输入用户名和密码，当用户名为 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) :! P1 G4 A' M3 [* s; O6 O
name = input('name:').strip()3 F, M0 B& F0 e, [2 k, Y
pwd = input('pwd：').strip()
; w: p5 S+ J+ k: p/ J9 Z% ~
' V' z, C' D! p# v3 c/ O( G5 W4 d$ r if name=='seven' and pwd=='123' :
+ V5 o  ?9 d& |9 n. E7 b; A       print('ok')
( i3 t" {2 G* R* x, a else:
: R/ G! e& k( u+ K, H       print('error')
  G& z2 Y. ?( a: D+ F- e       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 o5 \  D( i8 f& L; u
name = input('name: ')  d: p) e1 f* v. t
pwd = input('pwd: ')
7 v1 F& F$ M6 `+ z( q, q" Y8 M if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
' Q# ^- Y- r  l. S, G       print('ok')
! x1 h5 C% q5 I0 C" J: M0 @$ {" W0 o$ d else :* m: G) i6 l3 M' t' ?' y7 W
      print('error')* x" e0 H" E" u5 g8 g
      count+=111、写代码
& ?" @- o( Y8 y% ?+ w9 T7 ya. 使用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) :4 d( j$ ]8 u. \' U' t0 N9 l/ j9 t) P
if i %2 != 0 :+ [% T( o* t% z! T
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
6 T8 t- O* q- s  J if i %2 == 0:
0 D+ s: U" \  v" Q       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"
' t% W+ J# C% ]- H# B- ba. 移除 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)
# }8 g3 n$ C$ S- ?for i in name:% v9 o. u& p9 W5 @4 C3 s
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain% R$ a! l' z* Q- p
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
7 x5 ]0 |/ @6 W# pprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
2 L( L. H! P$ u0 ]# g4 |) aprint(li)
6 s  V* L+ b& y& B  h% ^/ Z* |# j ['alex', 'eric', 'rain', 'seven']
% E3 n$ f) ^" Q- x8 Xc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
) s7 _$ V( B& u+ R/ g5 d9 _print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
# _& B& C. W" j0 ^, d. |print(li)) E5 x. `0 C6 f
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']) N! E* Z  L1 L9 K2 a# b
li.pop(1)7 h/ ~% r1 a) g' u5 h4 p
print(li) ['alex', 'rain']
3 v  j6 N0 \" c" n8 w指名道姓的删除li = ['alex', 'eric', 'rain']* q+ U' _% T5 {& d4 L2 `% y2 Y
li.remove('alex')
/ Z2 {9 t' A* _% kprint(li)
( P1 n! N5 e) s7 N) uf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
# `, V& G. f$ Z8 |$ @8 M9 t! g' O) m: Oprint(li.pop(1))
: l  s) S9 b6 P6 X  S- ~4 g+ e. rprint(li)8 e( p  _8 z3 n! z4 _

* c: W' c; u0 ?4 W) \eric
: g+ f: l0 W2 G7 |7 w['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']. G; a7 F# B( g" |9 ^. Q
del li[1:]
3 O9 x# P% z2 K; E. \. kprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)7 U# {/ V$ f1 k7 G4 m
li = ['alex', 'eric', 'rain']$ N/ s6 X; U7 t  C* ]
for k,v in enumerate(li,1):6 E  r' G* w$ i' l2 w4 j6 z
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
6 _7 ^3 b1 l3 e" E( @( n5 E+ Za. 请输出 “Kelly”
+ X$ D$ @6 Y) f3 Dli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]9 k, u6 J1 q, d( x5 N; x4 b- w% t
print(li[2][1][1])+ ]" ]% A/ m5 p, y- A+ [' m8 Y
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
9 F3 D0 a5 N$ F0 P% p0 a8 o4 oli[2][2]='ALL'
" s( b0 U) A' H5 n3 p) d) yprint(li)
; Z( V* u6 V% m6 a; `7 [; a- z/ F24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')& E% M- j3 y% H2 J2 E
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
1 L, `9 E1 k! F3 p  L' G0 n9 ?print(len(tu))' I) d' u, x+ b3 }2 [, l
b. 获取元组的第 2 个元素，并输出
/ U  U6 e: T4 W' ?8 `2 Rprint(tu[1]); u8 J8 h+ G) e% z
e. 请使用 for、len、range 输出元组的索引
8 X, w0 `& \6 s7 Q! q5 K" |8 tfor i in range(len(tu)) :
3 H3 X* M1 q# ?3 ~ print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
7 H2 a! q. s4 |for k,v in enumerate(tu,10) :
4 H+ [5 Z; H+ q: s print(k,v)
" e. E* m2 e0 g3 J( Y5 E8 ?) [& ~: ^10 alex
5 P* u  h* Q. L$ E1 Q1 A5 [11 eric  j8 _7 D) c+ V
12 rain
  f  Z, M& w( p7 n
. p* L: J3 x6 y3 G6 n1 u+ Lfor k in enumerate(tu,10) :1 ]+ L1 I$ |) e; b. T8 w  Z
print(k)- n: f' }8 V2 ~% T' x0 n
(10, 'alex')( B8 u& }7 t2 p# s' Q
(11, 'eric')2 E/ Q3 R, T6 o4 A7 {
(12, 'rain')
' ^; R: i' C0 A) m1 H
' U* t6 j0 `2 [. K- \0 s" I
8 @5 K  _' n( \( r25、有如下变量，请实现要求的功能8 D) v- e9 w$ S* Q' o( U- ~9 _
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
/ ?4 h7 P2 _: I$ f- y. v/ j; k+ K
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
+ ?8 L& }) a8 T. htu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
! e: K4 R4 `; z) l3 c1 Sres=tu[1][2]['k2'].append('seven')
; L( a4 D3 X( E" U% T; w( ?/ @+ o; d9 T2 _7 ^; f' `
print(tu)5 e8 x6 K& @2 D: e
26、字典
6 K8 W, s  i. z! D/ Ydic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:  d: n" T. j+ ~; I7 l
print(i)b. 请循环输出所有的 value
4 n; F9 m9 z! p4 R2 k' gfor i in dic:9 K! f# @6 B9 R, t( \, f/ z, f
print(dic)
/ R. Q' l5 u, _c. 请循环输出所有的 key 和 valuefor i in dic:
! ?" W& Z9 @7 v' }$ H) T. lprint(i,dic)
# s- |* S: M" q% Wd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典) `7 ]* v# e1 ^0 H/ {% D2 `
dic['k4']='v4'% Q& g: t6 L# J
print(dic)
; p' q* C' K4 g$ |7 S5 we. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典4 g/ ]6 X4 K9 p' ^' ^9 A
dic['k1']='alex'# q3 l0 `( [9 O% Z% `
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典8 f/ ?1 v1 V/ t  S& [' G
dic['k3'].append(44)
9 p, `; S1 u( B2 ?  `( kprint(dic)- N- A  D, w/ U6 E" U0 f
( z" q0 m0 `! e% J% g1 Y( @
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
2 u* c. s' \, D, y- N: a2 Rdic['k3'].insert(0,44)5 f! B* O1 {# o) q2 W2 s8 b
print(dic)# P' Q% C& E7 z0 L3 D
27、转换
( ]6 x& `1 c- Ha. 将字符串 s = "alex" 转换成列表  s = "alex"& Z, _. C0 S: o0 z. P

% |, s8 s$ {& oprint(list(s))b. 将字符串 s = "alex" 转换成元祖& B( y/ j6 d* \' [+ w6 N! G
s = "alex"
2 L: @/ j/ F0 e1 J+ Mprint(tuple(s))" w6 f" l1 z6 q* s0 m7 P
  B0 [  e3 A* c, O5 M* k# H- h9 `0 V% D
b. 将列表 li = ["alex", "seven"] 转换成元组
$ r: ^8 w4 l2 S. R+ yli = ["alex", "seven"]
0 V8 E. b5 T  ?- qprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
' Q( M, t( v& [3 ]+ U  W, btu = ('Alex', "seven")3 M8 a( _* d, i' N, U% I3 F
li=list(tu), W2 ~3 @5 d& x
print(li)6 V6 Y7 o9 T7 c; @* E/ r
0 P, t( v8 M: k8 g2 k0 s
: Z' P+ n; ]; @  |# P
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增0 M$ l  _, a: J' @9 v
' D' j0 }' Q; b6 v9 ~7 K- ^9 \
dic={}
  r5 j) Y6 j8 mfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面" ]$ U6 Z' K( B0 f! h# t
dic[k]=v6 H) J! X. x* C  o
print(dic)27、转码n = "老男孩"
7 j" [1 L2 ]) d! z# \a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩") m! o$ u: ^0 h' R5 K
a=n.encode('utf-8')
7 H8 D0 P3 {5 Z' q: x4 L6 r: qprint(a)' N* f  D3 S( H8 ^0 ~9 _9 R/ S
b=a.decode('utf-8')
5 x' K% c, o/ ^8 e# Hprint(b)$ n$ P0 M/ J3 Q
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
4 P2 I. C* u3 t1 k( \/ O) l3 J# Sprint(a)  h7 B# C' b4 ^$ ~
b=a.decode('gbk')
. f, z6 |& m1 L/ ?print(b)28、求 1-100 内的所有数的和
; L- f! c1 h" _! I1 _) A+ C7 \count=12 T  E9 _) I& k% ~6 R) N
sum=0% ~# Z8 s( y8 A6 `
for i in range(100) :% _; r# u5 ~7 L7 }. U
sum=sum+count
. V  ]# n4 _+ ?! g" s% Q8 g* y5 N( r count+=1& ~0 t/ m$ t5 r% |$ z/ T5 Z
print(sum)
2 K# K  X1 b+ R. [* x- G) J. M5 ?5 T$ @+ s6 a3 X1 ?6 _
count=1
* g; m+ $ `+ V% H, W5 e2 N: Fsum=07 z1 Z0 v6 E; `7 z6 _5 c
while count<=100 :3 V. E% V0 B; ], r# \5 n; G5 t
sum+=count
' N6 ?& k( k# @. b8 O) L# o count+=1/ R+ @$ m' U$ z3 d3 X& t* h5 i
print(sum)29、元素分类$ G6 u6 |8 Z& d) x' O& `
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
' D$ B+ R$ S  L7 L将小于 66 的值保存至第二个 key 的值中。
! }6 A+ a/ v+ \: |1 G2 Q- z即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
7 Y) K" Q0 L% b& u3 ^* T+ I- \li=[11,22,33,44,55,66,77,88,99,90]
0 _3 P2 I$ h8 L: N' ^# Vdic1={
  r- I8 Y: W3 I7 s 'max':[],
/ r) S# C! _6 {) G5 {) _ 'min':[]
% X. S- f2 z% @( [7 D; G}) d+ \& R! b2 u, W! z7 $ t1 n
for i in li :9 l/ n4 [$ |' H" }7 e; b
if i <66 :& ?1 l  x2 w1 x" N0 x
      dic1['min'].append(i)6 }4 f0 P2 E7 H
else:
6 u1 ]; Q+ n# L: p7 `       dic1['max'].append(i)
4 C4 F$ ~* q6 P  \; J2 ~print(dic1)2 l! a; Q" a5 w4 a# M
  |$ \% d/ G5 ?7 n
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
: ]( B; o, ^# v. p' Y7 U

Python基础知识汇总

主题推荐