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、写代码5 t* \+ y5 p  n4 V/ B+ e* V
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) :
. H' ?/ K. D8 O8 T name = input('name:').strip()
7 a8 C/ j/ _4 ]9 ?# i" d6 W/ E# M1 | pwd = input('pwd：').strip()8 t* S, B1 V0 C; F3 ?* `$ y

- Q& r6 `8 y9 Z: J if name=='seven' and pwd=='123' :
+ s' [. n# ]7 D       print('ok')0 G4 Z& N, P0 p& D# b9 V. z' \
else:
' x% i' B& w' h, n4 g: L  s       print('error'): c. S% Q, k; ]/ `, Z( \
      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)  :3 K$ E3 l" @' Y6 ]
name = input('name: ')
7 g6 W, Y4 |9 ~' m1 H pwd = input('pwd: ')
7 T8 P/ M# Y( ~) \3 d if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':2 y; Z  F4 h1 o0 L, L
      print('ok')+ y& L% f; p7 e, Q/ q& F
else :
! m1 N  _+ f4 @, @; v       print('error')
4 a% u3 I" Z) B6 U% ?% h       count+=111、写代码
0 j0 ?# O' |  h( j3 D5 @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) :; m% D# n, w) k1 W8 i
if i %2 != 0 :$ ~# M: S( g( Q- Y% ~5 O7 k
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :( \. s' t/ K+ }& l& u/ ~
if i %2 == 0:
/ \  Y1 _* ~, U+ X: i% K3 d       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"
* Q. M1 l8 f; G% t! da. 移除 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)
  B$ p5 c: t- `5 ifor i in name:
5 Q+ M6 D: }# s print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain4 W% f' h' _9 A. ~  T
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']: a$ T3 o$ A* X, B2 r$ J
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    7 B+ c6 d) f- r* O" \' m, h+ {
print(li): }/ O) s# L" a% W3 f
['alex', 'eric', 'rain', 'seven']( G, h- ]# B* u
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')- R0 \0 \' T. W+ B3 p- b0 z; H
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')4 k8 \. ]8 [/ m- w3 q  a
print(li)
+ S+ _; i3 S) m5 k& Fe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']- L  ^% k) f- Y
li.pop(1)
/ y. t7 l  N0 \6 ]3 J3 Cprint(li) ['alex', 'rain']1 \! d2 i, ~0 }7 u$ ^( F
指名道姓的删除li = ['alex', 'eric', 'rain']2 n* a9 S' y, }2 _% I  P% P; a% M
li.remove('alex')
: Z( D& q( I7 Pprint(li)9 H6 Y& h; A- T( ]0 f# w. _
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
3 i4 R+ Q* B3 M. J; C) lprint(li.pop(1))9 T; X) s( G/ W. m( K4 w
print(li). x2 X9 F4 ^  M4 \5 a8 e- A$ c
6 J- u( `" j2 c1 y
eric
6 U9 _. O- `& P7 i0 q. A['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
/ o" H3 ?! f+ H5 k( }2 Qdel li[1:]
, F8 g( F3 t$ B% v7 s8 _& Rprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
) S- ^! j/ \4 ]' L: y6 Z3 a$ bli = ['alex', 'eric', 'rain']- U; M; N7 W7 a6 i$ l
for k,v in enumerate(li,1):- ?5 \' f. V2 \' f1 v9 e4 Y' e& p
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]9 H' b5 C1 ^( e# g
a. 请输出 “Kelly”
* W- |& G3 Y0 c* k. Kli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]; F3 ]' r1 w; H( x! A# Y  i
print(li[2][1][1])" c& i) r% i5 U0 {( ?: o
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
6 ]8 r" P8 x8 v/ P7 ili[2][2]='ALL'' ]8 n0 h& I7 n5 j
print(li)
! Q3 K4 s, U& S2 e! u24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
5 q' R1 C2 K3 y0 L6 S* p6 Xa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')  ~0 R! z- {# ~& y! t# N+ n2 A$ C
print(len(tu))
3 {) g& D# y% {( Kb. 获取元组的第 2 个元素，并输出  O3 w0 c, R1 W: n2 c
print(tu[1])
( w* n& k$ ?2 |e. 请使用 for、len、range 输出元组的索引
1 V0 e( Z- S0 f5 |. D1 @) kfor i in range(len(tu)) :. }2 m$ m2 H; h( @
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)6 m2 V2 ^: i, N4 n% o
for k,v in enumerate(tu,10) :+ x+ k, ]9 O1 e" Z% @- i
print(k,v)! f7 Y- V) X1 t$ [% N1 v
10 alex
! O7 ?0 ?' o2 E( A11 eric
4 I% c7 L; `2 ]+ ]. `12 rain
3 H5 y5 a; v4 h3 P, a  V
$ C- Q( y, f  I4 L2 i, }for k in enumerate(tu,10) :  k& {2 W+ }3 ]9 ?/ L4 D; O* o
print(k)! W: ~7 K+ x! I8 g
(10, 'alex')9 Y/ |: l$ n# G7 L: Z' W( ~
(11, 'eric')
9 K' C- R6 g+ ]; b6 l(12, 'rain')+ ]9 v, ^% b! V. m
% \$ e: ?9 u7 g1 W3 }% z
& r; V! [" y+ U% `
25、有如下变量，请实现要求的功能
. {9 u3 `. D- }: J/ btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

0 p3 x: q0 P  l/ N% p+ i8 Td. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
8 `! E3 x* v3 _: v& ?1 S3 atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
+ f; \% Z5 _8 Pres=tu[1][2]['k2'].append('seven')6 }0 Y1 e" t6 B# {
) ~0 a4 |4 A& m( [
print(tu)
; T8 `( X4 \4 ]26、字典  H7 [3 m3 `5 q7 c7 c6 r5 @0 `
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
1 `) O  [& c$ A8 H8 M8 x/ W/ E print(i)b. 请循环输出所有的 value
8 H( g1 n4 x; E- o8 h' a) y7 rfor i in dic:  Z$ T3 D1 v( ^0 S+ {5 q) x9 R
print(dic)
6 P/ Z5 u8 a8 j8 `c. 请循环输出所有的 key 和 valuefor i in dic:4 D- {+ Q3 a. t0 q6 E: |
print(i,dic)
! Z- k0 m7 i" l7 Gd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
+ m( O) a1 _! g7 W" ddic['k4']='v4'& P7 @& x% I4 N* |& \' Q
print(dic)
; Q  B2 p) ]% a6 V$ s* j% We. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典* c* M& h0 O$ E' a
dic['k1']='alex'4 y2 S0 N, Z* ?$ c$ |, V
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典; @! t% ~- ~1 Z" M& Q
dic['k3'].append(44)% q4 ?/ B) X6 A
print(dic)/ y" f% Y) A% g1 V! ^8 [

/ t. z/ G" W& R1 Lg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
. j: i" Z7 C: z1 h7 {) qdic['k3'].insert(0,44)
* T- V( H0 S) a* @9 N! l3 z' zprint(dic)9 T& ^  x8 o# m! F
27、转换
7 z8 p7 _! d( ~/ G2 v5 @6 ja. 将字符串 s = "alex" 转换成列表  s = "alex"
5 e- ?' I# P, w% G3 \+ t" |( U* r* Y' u( S  h' q  i
print(list(s))b. 将字符串 s = "alex" 转换成元祖/ [3 B4 q$ F) p- c5 k) b* H! f
s = "alex"+ |- e. Y. y! {/ s
print(tuple(s))  |* P" n/ u: N7 i3 a/ J
- V0 J. j2 e& y; p7 v/ L
b. 将列表 li = ["alex", "seven"] 转换成元组& p: F9 Z7 [1 P8 a% k- K3 d
li = ["alex", "seven"]
8 f  n( ^$ H9 t5 y# `print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
( q* N; m$ k& r1 Wtu = ('Alex', "seven")
li=list(tu)
! G) j4 ~% O) e) f9 Z; A' L3 \1 Pprint(li)
& f3 e" Y6 m  `" I* H- p, ?" }6 O4 N8 r$ U/ ~
0 ]# s! I& O, H
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增, j6 u4 x+ }! i" l# J1 l$ H
3 M3 a5 m. p. v! Y* c3 R. N
dic={}& M9 y2 D- V8 V+ d
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面7 C8 `- h7 Q/ p3 u
dic[k]=v
4 L2 f6 T8 j8 V( I" h9 v0 N print(dic)27、转码n = "老男孩"& Z$ J) _  V& ~2 x: S
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"+ }! O2 C$ O$ l; f2 j; r, v" z/ |
a=n.encode('utf-8')
, \! d' ]! Q/ n3 x7 Y4 yprint(a)
6 w; \2 G1 g# c- c- P/ z! Mb=a.decode('utf-8')7 A3 k9 u1 U5 N. j- r
print(b)- v. G- @$ I/ V. W& _, N
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')  Y  i( w. J4 B/ o" v
print(a)( y, e4 ^, Z0 C& O8 I7 H( P
b=a.decode('gbk')( R8 ~! k. @/ Q* U& K8 ~
print(b)28、求 1-100 内的所有数的和: g9 S4 r6 N/ W+ ^6 J) j
count=1
1 i# L0 x# a; G$ h0 u% Wsum=0
; T0 y- k. F+ p! Rfor i in range(100) :
+ f1 U0 M1 C; M& ] sum=sum+count
% b- s7 ]& `+ l: W- ` count+=1& u* I0 ?( w( k, V
print(sum)
3 }  |2 F/ `' p7 W; O6 [! x' f1 F8 w: V' W
count=18 w! w1 ~$ ^# h3 W# _5 F, V
sum=0
8 t* N5 A, {+ t! F+ |while count<=100 :
" D; g/ x8 V# u$ p4 Z5 o; V sum+=count
- O! [7 W. H8 ?. W! @. u% J count+=1' a, Z; P6 l: F+ [- z4 o
print(sum)29、元素分类
; J. V6 ~  i0 O! J( S1 a: S9 h有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
: _% v$ M2 [: ^# R% ]  o将小于 66 的值保存至第二个 key 的值中。
  f6 F4 k/ }- y2 j0 \1 y即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}7 N- [8 ]  N+ h3 k
li=[11,22,33,44,55,66,77,88,99,90]9 t3 ^- T: \+ D& Q6 H4 U  _/ p
dic1={
3 ^# Y. Z7 y' ~2 |) j% p 'max':[],
  _" b% S. @- r, U 'min':[]
) s7 e4 [. x4 {5 {}& l- h  K$ |8 T, b* _! W4 K
for i in li :
" O4 E7 X( H* x- N$ s if i <66 :4 q2 d" }5 w. L3 M/ t
      dic1['min'].append(i)
) s: x" [/ D0 R7 R" D% [ else:8 @2 Z; X+ [8 G' p3 a' `6 Z
      dic1['max'].append(i)
( G/ U! U/ P+ N8 n+ a/ M- a& Hprint(dic1)/ `2 k+ T* C1 g
4 t6 Q  O7 l5 y4 s; z, |* H% g
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
4 H# h3 Z7 C; @  [# U  V

Python基础知识汇总

主题推荐