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、写代码$ R9 N! {8 x" X$ u' F& S
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) :: w2 Q' y3 A# ]7 J
name = input('name:').strip()( R: A& S8 A8 F1 V# l
pwd = input('pwd：').strip()
  g* ^, k* n3 N: e$ v. |
, `( y1 L; }, e! i5 i if name=='seven' and pwd=='123' :
0 b9 s+ y; Y9 Q       print('ok'); P' }9 V6 h8 w, n/ O5 B; F% N
else:2 `; L. @. z7 `' c8 ^( I
      print('error')
7 w5 ^3 n, Q/ Z* d! S- 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" P8 i" y; j0 i7 [7 k
name = input('name: ')
/ h0 l( f; ]7 l8 r- O pwd = input('pwd: ')# g/ O2 D$ U) f) M3 d4 z
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
+ ?4 s6 r, Y2 B( u+ l% x  L% Z2 y       print('ok')
8 v$ s: C9 N' e* \ else :8 k: g1 a9 m2 o, x' C3 R  y8 R. K
      print('error')
% k. d+ S3 f* l4 J' c       count+=111、写代码" y' o+ R; a/ a* {6 S
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) :
' v6 w4 _. q5 z6 A if i %2 != 0 :% {% [* m) q( `, [' b' D+ q# B
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
! K$ a8 Z$ Y- n9 R2 | if i %2 == 0:: c$ K# G+ K2 v! I3 S" H( m+ N
      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"
5 @/ W7 O: C; D& y' K4 J! Ia. 移除 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 m* A, p) X3 a, ~' `3 J8 A% W) f
for i in name:
) J# n9 U& S6 j' R print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain/ n: T* n  w2 a+ z8 @5 s) H2 g
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
" p8 F1 @6 y5 Dprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    , w- [1 m1 N% r
print(li)" L$ o% a9 {1 P( K) a/ H1 e
['alex', 'eric', 'rain', 'seven']
  E, Y, a  w$ U* a% T( {c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
/ z6 h% K+ G9 j% [7 R. Aprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')$ P& n- Z$ k3 @" q; d! P
print(li)
9 U+ o1 U( U! d) n; xe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']  S, f* _' E4 W* b2 g( n
li.pop(1)
, T8 s: [% h* {2 X5 G. u8 Y- Zprint(li) ['alex', 'rain']
- ?% k5 I& U" a" g9 Y指名道姓的删除li = ['alex', 'eric', 'rain']3 X6 s( \# Q% l7 ^1 r5 F
li.remove('alex')* [9 Y5 j. @- `4 l( h
print(li)
; s' d4 v; D. v" M$ [1 r1 [, \; xf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
7 T! J* q7 m3 F- W2 \' y' @9 W, ^print(li.pop(1)), s& r0 W5 F3 v
print(li)
9 X2 T3 N; x) m; c( b: T5 T: p' O
3 n' ~- c# n/ Neric
( _5 X  S+ m& k( v" }['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
. x% N) v/ S4 a) kdel li[1:]* \# d5 M1 U' i* b8 [' ?* Z' [" u
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)- {' t6 |4 k  W
li = ['alex', 'eric', 'rain']
& e7 Z) D2 ]: {for k,v in enumerate(li,1):
6 K3 t; s* i& }! T7 v print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]2 n/ e9 n$ G4 a$ I$ X
a. 请输出 “Kelly”' ]" E& B1 S1 Z& ~- b
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ W: Z+ g3 k2 Y1 X% dprint(li[2][1][1])4 Y# w2 T3 D7 l7 \6 C, S. d" y
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”5 N/ Q+ M& ^2 ~' q" u7 A
li[2][2]='ALL'7 r) T; T1 R9 o' i5 n/ b' B
print(li)
% y3 c9 r5 U% _0 o3 O24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')9 J* S9 d2 W& v( Q5 N# k1 f6 S. @
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
9 o) ?' R; H! u6 N* G5 u( C; Uprint(len(tu))
* X* b$ X  ?. t% S' y' sb. 获取元组的第 2 个元素，并输出
$ R' S6 m6 F* r7 ?& a( W6 ~5 W! e, Tprint(tu[1])
. ?7 f3 w, ?7 s, J( Te. 请使用 for、len、range 输出元组的索引
- a1 A* |/ y. jfor i in range(len(tu)) :
7 g: H& e, O/ j" Y- H- _ print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)) F; Z: p; Y) b
for k,v in enumerate(tu,10) :0 v9 q/ W/ W% c. w, z& p
print(k,v)3 t- s( r2 p+ J
10 alex
$ A, \, V3 z! s' }11 eric/ O- P' h8 @' @$ q* a- _# [: A/ f
12 rain' N( w8 p( C, J( k' m8 h( q
8 X  N1 V) a6 ?% g( G
for k in enumerate(tu,10) :
; a; g% x' r, g$ T print(k)
, {- b7 a" L7 L! j) L6 e/ {(10, 'alex')
/ D  j1 w1 |. ]! o(11, 'eric')* Z1 Z8 K5 ]1 P
(12, 'rain')2 _( |5 Z2 J6 ]! O) T; `

/ V/ [- a2 ]7 @% z( E
' q" P; d, m$ G9 S$ g4 ?0 t25、有如下变量，请实现要求的功能
% Z; U$ m% f- P, U+ Htu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
7 H0 S! P# s' x
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以6 T# n" `5 w5 {/ U; r8 G7 F9 e
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])& \" z4 n8 E7 C' ?! v
res=tu[1][2]['k2'].append('seven')2 z0 Q  N4 G( k

# g6 q5 q0 ^8 c* Oprint(tu)" ]5 i) b' x) j  Z) h
26、字典. P9 }. g! |* u; Y$ u) n/ s
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
; ^. N' ~2 b6 u( _. ? print(i)b. 请循环输出所有的 value, s* H& v, S/ X4 {' {
for i in dic:) G$ F( k: k; R+ E+ T
print(dic)& n& B  S1 O4 m! {$ x9 Q+ v! t9 H3 G
c. 请循环输出所有的 key 和 valuefor i in dic:
: b! e: Q; \4 w9 {; r! lprint(i,dic)4 ]' O# e9 f5 P4 U2 {
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典/ M& J' W  r* \* l/ G9 I) H
dic['k4']='v4'4 c* o/ e& o1 u
print(dic)
$ `2 M/ M  |3 |7 X9 h9 oe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典$ n7 J: J! Y: U( s' @7 S7 Z) e
dic['k1']='alex'  E# O! o( D) w/ Q# A. E! f1 g- E
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典! P( b8 d5 c7 ]+ G6 ]
dic['k3'].append(44)
$ T( U; a2 ?  F4 Rprint(dic)! j0 N3 N4 x" ]$ P

' D- b: h4 {6 O' ]& s% mg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典6 p7 G* X6 U$ u# t( A
dic['k3'].insert(0,44)' u6 `' D$ V, ]9 y" }
print(dic)
+ N- ], E5 T( n: }' D27、转换
% W' m5 @2 h4 _4 p9 h9 Ka. 将字符串 s = "alex" 转换成列表  s = "alex"
. w4 X4 T: P8 z& r& J  r: X- x/ N+ U2 y& a3 N. Q% J
print(list(s))b. 将字符串 s = "alex" 转换成元祖
* D4 n& Q$ t) z( ?& M) Z1 ns = "alex"
: R: g+ Z7 |9 ?; T& H( Xprint(tuple(s)). h: b' e  X7 z+ Z, Z' g

+ |" g! m- |' q, A2 Vb. 将列表 li = ["alex", "seven"] 转换成元组( I+ A" l8 j5 k
li = ["alex", "seven"]
, y% [. K0 q1 k5 N, ^8 \% Yprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
3 ^' `2 C( U5 g& q5 v# _4 Itu = ('Alex', "seven")7 j6 x& ^0 G0 O" B5 [0 T. q2 m
li=list(tu)5 a5 V1 q. B) n
print(li), m# q) J$ G2 U' o
+ J5 M/ X' K( n/ a* n6 C

9 A, G* Y. b, V8 |, e& Q1 ^' Ud. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
1 ^; }1 I7 X0 T* L  ~+ B4 ?
: _' @/ L) y4 E2 `) p  _dic={}' Q- a: D8 |& p2 Y% W# |, l
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
  @, G" L/ q  B dic[k]=v
2 _" n; r8 @& `+ h print(dic)27、转码n = "老男孩"
3 P! k+ N* l! d- s* t7 ?a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
# I. p5 _: O8 ?a=n.encode('utf-8') : P1 ?4 h4 T2 ?* i9 N
print(a)- Z" s5 |& r1 O) `$ d3 W; K8 L
b=a.decode('utf-8')7 p5 l& |: _' ?9 a, Q# `1 C
print(b)
8 {! f* {! V2 ?, J  B- {1 ]) Fb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')- W. h2 e9 Y0 C4 _6 U5 W6 y) W
print(a)+ |. K3 u' E8 H
b=a.decode('gbk')
) p3 c$ ?' B/ `- E0 Z0 A; \# gprint(b)28、求 1-100 内的所有数的和6 Y, g5 V% O7 H  k; I" Y
count=1
/ l; O# K$ H# G6 k2 Esum=0
5 L8 v% F* x9 S8 ]# Dfor i in range(100) :
  d+ t# T( W- m; S+ h6 D) k sum=sum+count' j, c( y, M$ S$ ~6 \4 x) {( b! G
count+=1
3 T) B5 k( J( Z8 uprint(sum)
$ E8 [0 \" m* s% k
3 |1 J3 ]6 U: T! R3 Vcount=1
3 I& g: ?' |( y9 i3 }9 k4 h# psum=05 o! R5 L' z8 I9 P6 s0 |) p- a
while count<=100 :
( f! }3 X# G2 J0 p sum+=count
  v/ F# O, n" d0 k/ R6 n9 x count+=1/ W) A2 F8 l8 R9 C! p4 J
print(sum)29、元素分类
, _, i8 W* \2 q& _4 \# \" R7 Q' T有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，8 ~7 O- H9 F/ j( m
将小于 66 的值保存至第二个 key 的值中。: ]1 S- q$ t# a, ?% ^
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}# p$ @  `9 f. G2 w+ o
li=[11,22,33,44,55,66,77,88,99,90]
$ r* b9 d5 j5 I% U- @+ u7 G" Bdic1={
! d) E/ j$ ]% k$ E 'max':[],/ L& v0 ]4 }5 A4 K# _
'min':[]
& u) L. S2 q2 Y' e1 F}
9 O: M+ C+ o4 G- {2 k% l6 wfor i in li :
. G$ a5 k4 S0 j if i <66 :$ i- U9 f" K1 w
      dic1['min'].append(i)
( N( q2 i5 r6 @2 t6 z/ ?1 v else:$ G+ L, \0 b4 v' q! v; v4 C4 M
      dic1['max'].append(i)$ g' q7 N& p5 p/ G  e
print(dic1)6 |1 @. R* q+ A# ]3 C

& P! y. s  h% v$ h' O1 e  w8 m, p---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
3 _; [+ L! W; u1 a4 K

Python基础知识汇总

主题推荐