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、写代码
' v/ c& [7 j% e( o- pa.实现用户输入用户名和密码，当用户名为 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) :( I  ~& W" \( ~7 T$ y
name = input('name:').strip(): ^/ I  h: ^; V% T. d  G
pwd = input('pwd：').strip()7 P! i- J& F. G$ |! z9 S* c& W/ I

, N3 a* l7 {/ o/ F if name=='seven' and pwd=='123' :8 T: W# j8 Z- L5 t$ u* c
      print('ok')
8 w) D3 |! \, v: f" ^ else:- u% @# g1 |" N
      print('error')! ~0 z  U& P* r, X' _3 n9 P$ ~
      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)  :* e. {* B$ t! g' R# H6 Y
name = input('name: ')
1 K- V" Y* M- `6 \$ r, Z7 }( F& s pwd = input('pwd: ')
$ X% b" v5 I( u* P! ~2 \1 D if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
8 Z2 P+ g# B; k- F$ L: r       print('ok')
2 e& ?3 G+ v) H6 o3 W else :7 M# a2 ?( ~  F
      print('error')
0 s  a4 ~" j, O4 Q       count+=111、写代码
* e$ s& _5 M9 d$ h& b4 b7 ca. 使用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) :/ I0 q$ N" l- |5 _% @
if i %2 != 0 :3 T1 {& g7 d( Y6 D9 w' s% 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) :" ^% E6 Y  c9 x2 z8 Z2 S: i% @
if i %2 == 0:* i- {8 G6 q) i
      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"
) U' B7 Q2 @9 o: S% F  [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)
( l8 v; m; Y( m2 r) Lfor i in name:
. k4 @' j  u0 V- t, Q# H print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain6 e& z. x) D" [8 i- O4 v' H5 Z
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']- `) u- E* n% D7 c' {' E. i. [' s' m
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    ; X, }! ]0 t2 e. N
print(li)
: Z1 P7 E/ O( I/ L ['alex', 'eric', 'rain', 'seven']
' [! k- M4 |% P" Lc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')- j# N! n: ~7 p2 J1 q5 u' g3 i
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')" P; i" U, Z8 l. m7 `" \4 D
print(li)1 E: g: H5 i$ z5 F" y! w
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
  T0 [2 N6 U- f, w- {li.pop(1)/ ]& N' S1 h- T7 V* m& Q$ g
print(li) ['alex', 'rain']3 P/ b$ l1 P" Q, E' v( P
指名道姓的删除li = ['alex', 'eric', 'rain']
- Q. U8 \* s+ D( A- d* P5 s( Kli.remove('alex')/ y  v6 d% x7 t+ t# S0 P
print(li)4 o2 B: Q) d" a. [" F
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']: J9 v) u' L' N
print(li.pop(1))
( L1 p" ~; _) \4 Pprint(li)
) K. S, u# S8 p2 o: |( }
- d6 p9 o# |* jeric
7 n# x4 J% B: e  o2 F& z! ~['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
2 r, G5 l" O; M' Zdel li[1:]
2 u8 j7 D# m# X( ]" bprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)# x8 U$ y! ^' w3 F. F8 O( I
li = ['alex', 'eric', 'rain']1 R- C$ ~* G& l3 |' y; ?/ h0 m
for k,v in enumerate(li,1):
1 U3 `, M3 G0 ]- `, V/ _9 V' M print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) q% _  p/ x' _- P+ e1 Q3 {a. 请输出 “Kelly”. H( Y: G) b$ l) ~. `  z, r
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
8 n7 I- g- a' m; |7 q2 Gprint(li[2][1][1])2 o& g9 h, z8 ~( e* Q
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
$ ~. x% x: c$ _( a* xli[2][2]='ALL'
8 p7 ?( g* J* o/ d( ^print(li)
: J+ \; J. R2 ^( q: v3 W' G; K24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'), K9 h2 W) y: o) u2 ?% _# x
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
; G( p7 M# @& O5 _7 ]print(len(tu))5 @8 L+ h2 n8 s3 Y# }$ O0 N1 n+ a' T4 o
b. 获取元组的第 2 个元素，并输出
# _+ Z) x7 u  v# U. }print(tu[1])
  u: c- x. a$ F4 d) s9 v( Ye. 请使用 for、len、range 输出元组的索引
% W. r5 D- L" F) U- ?0 ifor i in range(len(tu)) :, Z: `- ~1 Y; v8 Q3 w5 o
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始). j: U: W  {7 t* r
for k,v in enumerate(tu,10) :
/ `. s- i  R/ o+ [* F" D4 u print(k,v)
2 }7 j7 t1 P9 N* K+ \10 alex
- w* P& u6 e, h5 d4 G# I& o11 eric
9 x( u8 D: V' V; r12 rain
; [5 A3 N; t# c/ W+ d" h
4 ?6 E$ ~1 X; lfor k in enumerate(tu,10) :: C7 G2 M+ l  M" X$ f3 d: ]
print(k)
9 q- Q9 X% N& {; q, j# L(10, 'alex')
% @. L9 A0 p( {$ `  j; b1 q(11, 'eric')/ n. m  K. r6 k, L- _  ~: r* \) e
(12, 'rain')
. D& s& V  j  O) `! D7 f: A
! U4 S4 |' V) h. @
, K4 C. {! \; [9 a25、有如下变量，请实现要求的功能
8 t+ @# ~9 s* a- \8 Y5 i2 m5 Ptu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
4 f$ E/ o" G" f6 p: s/ d& L
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以& U6 J- j! R+ \" X, x  ]) a
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])  u, B) j* B; j! R6 ]/ H: E! t
res=tu[1][2]['k2'].append('seven')4 S" r8 v6 }' {% j3 t' q5 y* x- L

7 q8 o6 }/ F4 F5 g0 y- M3 q9 Sprint(tu)
+ @2 t7 z6 T- p# J5 K1 n26、字典
3 Q7 Z3 y6 X8 M( z$ D. R( _dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
6 F  A( L9 s/ Z9 }* p) m+ | print(i)b. 请循环输出所有的 value' R0 P1 p5 W0 ]: N9 P- L
for i in dic:# b* `. a, k' R# U
print(dic)6 K4 [7 R! I7 P: U0 q6 l8 i
c. 请循环输出所有的 key 和 valuefor i in dic:) n8 j7 n1 s! ~# {( O2 `
print(i,dic)+ S4 D+ w$ p- w, {9 S8 W( T9 m  L/ r
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典& s3 f2 D+ M. ^, }* V: f1 |4 k
dic['k4']='v4'
8 Q6 H7 S- y2 f) q. Tprint(dic)
. E8 h  z! w' ze. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典2 n% X- S& d8 Z. N1 P
dic['k1']='alex'' U6 {. P' H& J: b6 S9 N
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
. U5 R. o5 `# X* c  P, ~dic['k3'].append(44)% \; n& @# O9 C& f9 K5 `& b
print(dic)
6 U8 {) A4 T( c6 S
. m5 M1 I* o7 J* h$ \& ]g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典  W2 `* |& w8 x; j' V5 R$ H
dic['k3'].insert(0,44); |2 _% R4 H, O2 _
print(dic)
4 X, C' \4 L' U7 ]6 X) I27、转换
$ J9 ?" j  j4 R$ S8 b6 va. 将字符串 s = "alex" 转换成列表  s = "alex"
# q7 t0 y: Z7 p0 _2 c3 Q% v! e* j  j# k' U
print(list(s))b. 将字符串 s = "alex" 转换成元祖
2 V+ I0 s" M  q* I" Ms = "alex"
- m0 T7 o3 ?+ b/ s0 Aprint(tuple(s))5 M* X+ Y; X" I
3 B0 L) U1 O; T% @' E# d6 o
b. 将列表 li = ["alex", "seven"] 转换成元组5 f- @: l" ^0 h, R) T
li = ["alex", "seven"]/ L% ^7 n9 T6 f* f
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
6 F/ u9 }8 G* itu = ('Alex', "seven")- g' f6 H/ t/ Y0 y& c. H
li=list(tu)
) l! W8 E+ h. H! d# x; w- b8 N+ rprint(li)
2 w* D: N) N+ v( l9 t# ~- P5 B: }2 H1 ]0 _
) w( a; i, e' G! K+ f7 B6 M# C+ p0 L5 ^
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
; ?# w, |0 \$ s2 U& W. S( P7 k
! z5 H; L1 ?/ o& n) B+ Bdic={}
0 X, ~: S3 w, Cfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
  z+ K( ^% z9 g( y dic[k]=v% n3 K" \) x6 t2 a2 C4 S
print(dic)27、转码n = "老男孩"% H/ X) A% U7 c8 l- I# [
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
! ?: b0 {8 E+ {- {3 s; @; ia=n.encode('utf-8') & A  I1 \' t6 L  `, s" R7 f
print(a)
+ \; o1 J. h3 `2 H) db=a.decode('utf-8'): `/ K1 Q& ^3 y- ?* r
print(b)
+ v- a3 M1 G! ob. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')$ v  r/ e4 w- Y, q/ P. |* [0 c4 p! p$ T
print(a)* A8 W0 [' P, }
b=a.decode('gbk')( u3 f: I* R; i' w% s
print(b)28、求 1-100 内的所有数的和) ~; ]; F! ^2 L
count=1
7 F4 M3 c! `7 Q3 T: n  N! @0 U6 @sum=0( Q. `" G+ a5 X0 Y4 b
for i in range(100) :8 N; G! C/ w1 M/ P. \7 t
sum=sum+count
/ {' C4 O) b( \8 D count+=1* N+ l! _; b5 q
print(sum)& E) _# N) h# j' {+ O0 `" ?! ]! v

( r$ v0 _3 U" U8 w7 F( wcount=1, h/ @: `& h2 ^* b9 n
sum=00 k$ d4 I8 s2 z- m% \4 y: A
while count<=100 :) Q& P* w: B1 X9 y
sum+=count
! S0 k4 F: F5 [ count+=17 I: ~& e7 v% Y1 i8 U& J0 k0 L
print(sum)29、元素分类6 O6 z8 x3 x7 T; E: r8 Z
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
, w! N% H6 `5 u/ y$ f$ H5 q7 T& B将小于 66 的值保存至第二个 key 的值中。
1 y* j4 o& T& |8 P, Z即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}/ Z; x5 _: }9 Z
li=[11,22,33,44,55,66,77,88,99,90]
& }% W( x7 t* B/ x: g& odic1={4 S2 f6 I: o" |" ^9 E9 `' d, \
'max':[],2 ^4 ?1 u4 M. ~) y& R
'min':[]
3 D3 R! @# v: e+ |4 q; g5 j! n}0 o) ?* a; _6 n& Z( d! `. ?( ?* n
for i in li :+ D$ w/ l; ?4 x1 k, D# _2 o! _
if i <66 :
( d0 u) L$ \* J! ^3 I; u9 d       dic1['min'].append(i)
, z8 D" M0 T2 ` else:
, }" `  u* Z1 _. ]/ ]3 r% u       dic1['max'].append(i)' n, T8 Y- ^5 l5 ]) f+ Q
print(dic1)
6 i; ]4 P$ d4 D: q/ e+ w8 U6 g% a
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}& S& t. b0 e6 Q* F& z2 p- w; e) J

Python基础知识汇总

主题推荐