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、写代码
) j" y% N( n3 z2 R* Ia.实现用户输入用户名和密码，当用户名为 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) :$ Y: A6 t) \: w7 @. b# w  z+ A5 F
name = input('name:').strip()& v" i) h2 B  W" s5 X
pwd = input('pwd：').strip()& c* H" D4 f4 B9 u
: X& d! v9 B; c$ ?4 w2 J+ G/ i
if name=='seven' and pwd=='123' :) _/ @2 X: _+ S, R
      print('ok')
" j* x: Q# \# @7 I, M2 R else:
/ D# Z: S4 d$ P       print('error')
. f) N7 T3 x) k2 b( s' 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)  :
4 w  q  r( G# u9 {$ \# ^9 Q0 o name = input('name: ')& B4 K0 J6 F' {# ^! c% B" E; ^) L5 k8 F
pwd = input('pwd: ')7 c! G! f: W- s# j' L
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
$ s4 x& e9 v2 D, o+ S( x/ R9 J( \       print('ok')
% h. T7 l/ A* _5 |5 Q- h2 P* P3 h else :+ [" v5 f$ E# R# i/ a2 D1 b) R
      print('error')
% P% E( @) h2 J7 x# |1 W9 l       count+=111、写代码
9 i2 a/ r/ O. f+ L. M5 [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) :
0 _$ P& L/ t5 J" I4 {8 P. q% i if i %2 != 0 :# \+ O6 m/ u' Y( z/ C: q( X" I3 e
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
0 n  |4 \1 W# f3 F' m if i %2 == 0:
7 h- d. t& u8 \       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"$ d# C5 r$ G6 r8 U" \7 y, I
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)
/ V( m+ g5 ^! h3 u. Q8 hfor i in name:# N) j# Q/ e6 ^& k* i6 O
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain- o, w  d. y6 g& a% B
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
' ~/ h3 ~' q  V8 l7 r. E1 B# D! ?) Gprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
8 [7 u. x; ]( U- s. h5 ]print(li)( Y5 E& ^6 h6 h7 @3 q; s
['alex', 'eric', 'rain', 'seven']
/ ?* Z- K0 p2 B3 dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')+ |7 [4 v1 @, o
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'): h$ Z' d# P  ^1 o$ `3 h
print(li)
2 e. \9 r( B- R7 }. U7 A, me. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']1 a1 n8 r  N/ k. H3 W$ W( }
li.pop(1)
, k) \) B- t6 h" yprint(li) ['alex', 'rain']0 j  a5 o: O2 x2 E6 _
指名道姓的删除li = ['alex', 'eric', 'rain']
; B) ?5 F; ?/ Sli.remove('alex')) s+ M7 M! x$ _. R+ C8 x$ Y0 m
print(li)) z, ]% y8 {1 K1 h
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']6 ^! t% b7 h/ U) h
print(li.pop(1)): h$ K: Q3 ]5 H/ T
print(li)2 W" ~9 Z" d, A( p# }$ r
/ ^  _+ w/ Y# g, B' f* s3 t$ ?
eric
' Y3 U5 T& v- H9 N['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']) f9 ~3 c6 e1 I# Q2 f
del li[1:]: B; @) t8 U, W
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)  M" B+ _% a# T6 l# A, U
li = ['alex', 'eric', 'rain']. G/ X2 o, C% Q
for k,v in enumerate(li,1):
. |3 t3 Q8 k0 h print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]& @" i& m( C% W: p& {- _8 w
a. 请输出 “Kelly”
* j2 a& G! H; p; `5 ?' Oli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
1 l% [4 v4 v& C9 Bprint(li[2][1][1])+ [. B, ]0 s1 u0 G( B6 ?
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”- z# _2 k8 d5 Q
li[2][2]='ALL'
! B0 }" u& V8 I# b9 W8 J5 R4 Aprint(li)) k" ?8 ~0 E: D$ f; i! K
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
2 Q  r2 D3 q- S" Wa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
; t( \0 v! O# `/ S) G/ o2 v6 Bprint(len(tu)), s8 ~0 {$ Q) s5 {8 k6 M( c
b. 获取元组的第 2 个元素，并输出* m9 v, L9 G  T7 V7 q8 g
print(tu[1])
; J9 `5 s/ x' k9 b5 E/ u0 De. 请使用 for、len、range 输出元组的索引
( V! h7 r+ q% ]6 v6 E4 Qfor i in range(len(tu)) :8 w, E# f( K" F, d% _+ J
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)* f8 p, u( I7 g% v# C: m
for k,v in enumerate(tu,10) :) }0 O- q3 h' ]. o; S: P
print(k,v)
' Y& o2 ~' N/ N2 m/ w10 alex) X: z# H' S+ a# s0 l
11 eric8 G" n! [+ L" I& }# H. M5 I
12 rain
0 {" B7 B+ b. S! d8 B
6 e% J4 Z" W, ~( V: a; s% W9 hfor k in enumerate(tu,10) :
$ k: S# q* H: t4 k; O# @ print(k). J( h0 B* W8 z' R. o" Y/ K
(10, 'alex')$ a) `4 O7 T) ]  ~. X. m( m" H
(11, 'eric')4 c+ ]' V1 ?- _! Y$ F( a
(12, 'rain')
: a! O6 J* G& x! `- e- O
- G' m6 E6 }/ r+ j* d$ A% i. N/ h' I& [4 X: K. H  X4 j
25、有如下变量，请实现要求的功能2 r0 `% x; v/ F, O3 }3 w0 w+ q9 F
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

; x2 H/ J+ O' z- e' ]7 bd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以& d' s( ~5 V! x" e/ [
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
) e  z8 a# T( u, T) @; {2 vres=tu[1][2]['k2'].append('seven')
% F  Q2 {2 v3 f# ?, A
6 J, A# E% M/ P4 Q" E/ Lprint(tu)
! S- c/ A/ h4 g. L% a6 r26、字典
3 J$ e8 l  B0 Y) Kdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:8 O" E" l+ ^& X- J
print(i)b. 请循环输出所有的 value- Q" X8 f: q9 e1 V* t
for i in dic:4 z: M6 w( f- W$ b  W
print(dic)7 ]3 X; Q; s7 l6 A: f0 T; ]: `  ?6 \
c. 请循环输出所有的 key 和 valuefor i in dic:5 \$ z' |1 w2 p% K# U5 b
print(i,dic)
1 P0 j& ]2 M  U0 ^" g' u/ D# ud. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
1 n' X  F, ~& Q! I1 l1 ]dic['k4']='v4', O. J+ z( `6 V% f0 y
print(dic)
& j* S1 i4 c/ h: b$ me. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典2 z7 T2 ^5 b+ v3 H5 H
dic['k1']='alex'- H& x, E* T4 T
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
) n1 k& _- v, `( Y( rdic['k3'].append(44)+ b' ?- X$ c" ~6 t, m  b
print(dic); W, J; A$ d- R# c4 q+ |
) V- d9 j) ]* a- L) D8 {4 `
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典$ ]1 z* A+ G) r; Q! v6 v; {3 }  }
dic['k3'].insert(0,44)' e/ W" Q. Z9 @
print(dic)1 z: K6 J" U5 g1 G
27、转换
! r* e2 S  x5 q& ra. 将字符串 s = "alex" 转换成列表  s = "alex"
7 `# U9 W7 \5 \/ k9 c1 @  F6 f7 q  R' C2 ?9 r% M- F$ o
print(list(s))b. 将字符串 s = "alex" 转换成元祖
" J7 G6 y( T# x( p% S  a  ]s = "alex"
' ?1 G" j- L* Fprint(tuple(s))2 d3 k0 E$ v% [, C$ N

1 P/ b8 u6 s' N+ D1 C/ |* P% cb. 将列表 li = ["alex", "seven"] 转换成元组
2 k' ?& r8 k2 J7 ~) B4 Tli = ["alex", "seven"]
4 C' z1 Y  B# R0 e! }print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表1 B2 u& O) ]& a
tu = ('Alex', "seven")
; x% ]' g. z- c% H( G( P0 _li=list(tu)
$ L* P: p; c- O* Z  ^5 C# dprint(li)
" V7 ?, M1 m! h" n" e% W! W/ u# p) u! i

! A9 O# E( G2 [, ]7 [- I) Md. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增* m. G" s8 i# K% i( A3 G% g2 H

# B5 m" e* A2 w, P& udic={}
9 p/ m, N0 z: K7 \5 Dfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面. `- }. k2 t; e$ J* s1 c3 p
dic[k]=v
: \; `0 G; {" A. i7 {, r/ T print(dic)27、转码n = "老男孩"0 e2 c9 y" O" O7 |9 ~1 m  C
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"* ?, J+ s: |6 v3 j/ K
a=n.encode('utf-8')
, S$ F$ u# K9 S4 ^  kprint(a)" _4 h- U+ n$ }- l* X
b=a.decode('utf-8')$ A8 N" Q& u" d0 r1 B: _
print(b). ]. Q$ }) A" \; q; P
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
4 n% B9 G1 h* H2 O1 J7 ?9 Z( f% O: mprint(a)
9 e( L% o. @3 i& B0 Nb=a.decode('gbk')
0 }% a4 z6 H- X3 q+ ]" zprint(b)28、求 1-100 内的所有数的和
+ O8 ?* `# g6 M& {9 Mcount=1" E! U5 F7 _% _1 s2 W, P& R6 R
sum=0: l& I& Z) }4 `1 b1 g4 _
for i in range(100) :
3 [0 d3 Q+ u3 j* D sum=sum+count
) y! s. }* b3 v, `0 [ count+=1  n6 h5 G) y- L+ h4 H7 d8 I9 _
print(sum)
# {8 W5 u. [% I* e8 x" m. S( P; v" _" y7 r' q1 e
count=1
' H& x( `5 O7 K( E2 asum=0
" L( j# [4 N( [0 P. zwhile count<=100 :3 r1 `' P* z5 G
sum+=count
3 u+ }. ~$ I" e count+=1& r+ {/ I) \4 X2 G3 G. b) w
print(sum)29、元素分类) |) D8 q4 J7 z. N! ?
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，1 A* r) J4 J5 S5 i( n3 M* |4 f+ \
将小于 66 的值保存至第二个 key 的值中。
4 p7 F7 |) I( [* I6 @即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
0 r# m  x; ~6 ~) S0 [# Uli=[11,22,33,44,55,66,77,88,99,90]
2 K8 Y2 t: h6 r/ idic1={; v: j1 ^. f% M9 x
'max':[],
' S; r5 x& O; @( G- X 'min':[]3 Z1 K9 h: S, f+ H" x' A/ r
}% e8 Q% d8 m3 A  w0 b
for i in li :
5 w6 k8 U* P8 }5 ?% l1 @* I2 K9 i  L if i <66 :$ v$ m/ j+ L0 M" w3 L: a# B1 _0 Z: p
      dic1['min'].append(i)
2 |% e0 E' a6 b" V+ V* l else:* ]( r, _. g3 Q7 q5 I2 ]! u
      dic1['max'].append(i)
/ i+ H& {: W6 q% O! Z! Dprint(dic1)
- X  {% M+ B! m* N4 \' H4 \$ G
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}8 Z. L& ?( O) A& P( |

Python基础知识汇总

主题推荐