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 Y. ^" M6 P7 Q5 R5 Y1 C) G1 da.实现用户输入用户名和密码，当用户名为 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) :- p. ^/ J2 c9 z3 _" G* y1 X
name = input('name:').strip()
3 ?9 I3 L" h9 |$ N- \2 q2 P pwd = input('pwd：').strip()
3 U% X) R5 ]3 D4 i" F5 P/ _* D* z
if name=='seven' and pwd=='123' :
/ R* f# b& D! W1 {) N; a       print('ok')7 |4 i% \( t+ h1 ]0 p+ h! h
else:5 n. b$ ~2 P3 x3 d% O5 D# C* e
      print('error')9 @" M* S% A+ [
      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)  :5 |6 L; J7 v8 r) @: q
name = input('name: ')* I- V0 Y. R+ d, f, `, `3 D
pwd = input('pwd: ')
1 e; Y7 @! ], ~5 r; n1 O if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':0 }% ^. `3 q2 x% ?( G7 q
      print('ok')2 z% F& U7 x; |) n# l# e
else :( z5 }4 T0 ?8 n1 ^& P6 s
      print('error')
( s7 K$ j, j5 Y$ g& P       count+=111、写代码; m8 q" Y  h, D/ L9 _" Z& U. F) T
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 X% t$ ~. y& v1 F7 Z0 ` if i %2 != 0 :
/ w/ X' @* U, B2 \) Q       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
/ m4 d0 q4 B) X8 I4 u, a if i %2 == 0:
( u, G' F7 l$ E       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"
- j( B  O2 Z2 @; u- Ua. 移除 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)# l3 A3 z0 J5 ~$ i  _# z
for i in name:3 B, F% S4 H5 ?
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain! V9 g4 c, ~) i) N/ {" S9 _% ^
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']/ ]( K  n" N2 T7 R( j
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    / ?3 ?9 I/ w9 |7 _
print(li)7 ]. P/ _' b& G" Q* |
['alex', 'eric', 'rain', 'seven']4 s6 J. ]- r/ k% J6 n' K
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'): t9 B6 o9 q5 C) c3 h/ Q
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')$ A6 Q. p3 b7 \: ^, u
print(li)
/ f2 N% a3 l3 m+ @1 G" w9 _e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']& R" P: p$ {0 K) b( R' I; `
li.pop(1)0 _/ I" T4 u9 ^4 x) M
print(li) ['alex', 'rain']
& q4 x1 c- O* C- ?1 W  B  U1 t指名道姓的删除li = ['alex', 'eric', 'rain']
2 h: H* o" A& uli.remove('alex')
: \, S" q$ C# I, c  A% S! t+ w) ^print(li)
0 }* U7 c0 T* g. _5 X/ |) b% Rf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']3 v4 Q# t) i/ M) B6 _4 k% O
print(li.pop(1))" a; }, f" G: i5 A7 U1 `
print(li). V. T2 u+ L5 M" m( {

& ?2 d; Q1 H* Veric
3 ]; Q5 O5 S$ a- U' X['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
8 C- [7 c9 h) n& O/ w; }  wdel li[1:]
% ^9 U) B: V0 M1 J) hprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)$ i, w. n& I# p: e
li = ['alex', 'eric', 'rain']0 Q" [1 y% Y. ~1 f" U' }) J
for k,v in enumerate(li,1):$ U/ |# b" J9 P2 i' T/ }4 ^& J: l
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ ~4 Z+ A$ C  ]a. 请输出 “Kelly”' j& J2 u+ R$ ^& P
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
: T' @" A: f  lprint(li[2][1][1])* ~5 \) V" `) g& H4 z1 i
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
. U- Y! f0 O/ @. W# l# g. M9 @li[2][2]='ALL'
, E& S; B% x/ P! ]print(li)1 A$ U# M+ F" E) \: W
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')7 t* @% }; U, ?2 I% _
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 m4 i$ Y, {9 N0 J# e: \print(len(tu))
  v+ h7 y+ w; A6 V8 F+ }( {9 bb. 获取元组的第 2 个元素，并输出
6 l* M- H, [% |( kprint(tu[1]). e; E* ~6 U7 x) j8 _
e. 请使用 for、len、range 输出元组的索引' A! m! l: R" g* }) |8 j
for i in range(len(tu)) :& \. \" O; x* A- h- ?
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
- r: D+ y! W5 m! i  ^7 z; Y5 qfor k,v in enumerate(tu,10) :8 A8 i& }: Z" b! H
print(k,v)& ^  X2 N7 y& N2 I
10 alex
4 o# X+ r3 x3 w' j  }6 B11 eric, h5 u) x3 U) v3 p
12 rain4 ^, _$ Y) Y: s. t& u
+ P1 _! V' Z# s  E
for k in enumerate(tu,10) :+ j$ b' ~) `- V/ }0 F( S/ W
print(k)
& t# Z: J; p& ?8 m(10, 'alex')
7 N: b4 r- r. \7 \, Q+ J, M9 k(11, 'eric')
  _. \: H' _0 y  ?, B4 }9 a(12, 'rain')
5 M! ?# S: r7 u* y! T  ~0 r
9 m. f- f( v- e4 F* J
+ J9 Y0 m  J- A+ q25、有如下变量，请实现要求的功能3 Z$ [" T4 M6 D( W/ j+ g
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
( W, L. ]" P) ?7 i7 b' f2 Q
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以6 }6 h% i4 _- r: `
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])2 S" g, q! f) c9 W0 @, x, M$ _( e
res=tu[1][2]['k2'].append('seven')# i5 `) U/ Y7 N* |- Z
' h' o/ _- o2 ~& t% d. c% d% K, Q
print(tu)9 q3 v  ?0 @$ v$ k4 x9 r
26、字典8 R8 ^: ^1 R+ G; B
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:0 |( K. ]- R' w
print(i)b. 请循环输出所有的 value4 v! g& P2 b: u0 n1 P( D
for i in dic:; ~& f& ~7 K1 Z6 G: }5 o: ?
print(dic)+ d3 s( S/ F8 N8 N2 `, R$ |. d
c. 请循环输出所有的 key 和 valuefor i in dic:
, X+ f" x! _8 H; m+ r% Yprint(i,dic)' m. _: v6 l' P6 j) D4 W6 b; O1 ]
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典# u1 C; T  p& }* ?1 M$ X1 f- [* q
dic['k4']='v4'# T4 h5 H$ u  h" k
print(dic)' c2 m% }. J3 V1 b. Z. J8 X
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
& }' G+ x4 q: }dic['k1']='alex'" @' F" T' C  ~8 ?2 D$ T' O, |
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典3 _- N# }7 f3 O, `5 l
dic['k3'].append(44)' {0 A- Z4 _5 h' {/ \
print(dic)
1 i& H. G8 j9 S0 b1 `1 s! T; a
) _( N/ z( O/ F6 |* F4 `4 u/ Rg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
1 F% A4 W. Y2 f& q" A! Rdic['k3'].insert(0,44)/ B  ?- w, v; O2 ~- J* v
print(dic)
% i- g6 F* z& N, l; H; J27、转换5 U5 g: W& I) F1 d" \
a. 将字符串 s = "alex" 转换成列表  s = "alex"
0 ^: E3 x' S+ K% M8 Q( G
5 B5 B) {! V; E+ Y* `6 w. W/ hprint(list(s))b. 将字符串 s = "alex" 转换成元祖4 D9 ?' c4 b0 k1 e5 r0 O  {
s = "alex"
4 T* c: q3 X: [" j; J/ _, o/ vprint(tuple(s))
/ X0 O4 r9 N/ U! q8 G& ~9 |9 Z7 ?
b. 将列表 li = ["alex", "seven"] 转换成元组
1 ^. J) R4 o0 N6 e# Z; N' lli = ["alex", "seven"]9 c# |, L0 {# s* j6 n
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
1 X) r2 L  a9 v0 O) Ztu = ('Alex', "seven")8 S6 S: ^+ K9 T0 s9 e9 l% r/ t
li=list(tu)9 t4 g6 K3 y4 b, }' c
print(li)
& y5 R1 Z" o9 ]* i! K
6 u) V) ?! x* T5 c9 q
* j& l0 B9 M. P& j4 ^8 Sd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
! O- R. s" H; @2 a8 b+ j6 }, \# N6 e& ~- L- v5 @+ r
dic={}
( O& t# G  R+ R. H: O6 W7 Ffor k,v in enumerate(li,10) :----li要放在前面，序号放在后面" c5 I% ?8 e. @( f2 p& R/ _
dic[k]=v
& Q/ m' ^, P9 x- d print(dic)27、转码n = "老男孩"
* Y4 x# r2 f3 G! G# z  Z# i. da. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"6 }7 l/ {1 x$ @: b9 x
a=n.encode('utf-8')
9 M. U- k" o: y8 L! ^print(a)
% B& Y; I& M+ Z) V: zb=a.decode('utf-8'). _/ U: X- ], `3 k7 s: s
print(b)
* v' C  N7 G$ A- o/ W* [8 D1 Eb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
" I6 J/ X, _. o# mprint(a). K$ _4 g' }& Z. d3 x7 v, i6 }
b=a.decode('gbk')- v: \5 u3 Z  v1 W
print(b)28、求 1-100 内的所有数的和# S0 @* `( X8 K% C
count=1
+ t* L$ q9 H4 |sum=0
- e0 f  c7 A2 j1 @1 J- v/ @; C; rfor i in range(100) :
4 C- e9 g6 e$ _' o, @. R- Y sum=sum+count
# h) _4 x7 e1 {  E! I+ v count+=1
+ `7 H1 }! t4 Zprint(sum)6 U$ c/ r, V9 K; ~% l( s
1 T5 @! S% ]: k) |0 }9 v, u# g- s
count=13 t, e: U; ~9 b8 I1 \1 ^# n
sum=04 H8 ^, C9 a# c* h, H& Z. t
while count<=100 :
9 k( C1 H9 K9 a3 c4 ?. Q sum+=count( u8 x, d* J5 G$ L5 S% c
count+=1
9 @1 J- A9 F, |, S* X7 Z9 V4 gprint(sum)29、元素分类
, n0 O/ v3 O2 J有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，! g$ D  O0 O! H$ @6 ^+ o/ e$ ^2 s
将小于 66 的值保存至第二个 key 的值中。% W9 F, f, s  e# {2 s
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}7 P+ z0 K3 q9 v; I6 b
li=[11,22,33,44,55,66,77,88,99,90]. v8 K1 I# w& A
dic1={
0 m2 F( c1 k+ v* e* j. _ 'max':[],
' [) F* {  i  k3 Z* G 'min':[]
2 h2 ?9 J* r& ^, n4 M8 K( L}. K: g8 a, u% E- o# [
for i in li :1 y% S. K  l$ L5 s% K0 |
if i <66 :
3 P' d- K+ T, C! t0 i       dic1['min'].append(i)
$ ~& C0 J' b2 c( j% y$ U else:
- _; B' u8 ^* C6 J4 `3 e       dic1['max'].append(i)" Y0 ^- v; v- m1 b' t% b. p/ n
print(dic1)
1 D! D! T4 V0 _
) v7 O: F6 w( \) P$ w" f: U---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}% i: C* k3 v2 r5 @

Python基础知识汇总

主题推荐