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、写代码
( I$ @1 Q1 c+ |$ 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) :4 I4 E  e8 v+ p" C+ k: d5 X* I
name = input('name:').strip()
$ O& h, s9 D8 D( S5 Q pwd = input('pwd：').strip()
' I7 J4 x) V) G) Z3 y& Y; D' l  `4 f4 h
if name=='seven' and pwd=='123' :
7 v5 X7 i8 s0 |  W0 }       print('ok')
% z, P- s- ~. S! s7 J  [ else:6 J3 W5 ^& w7 U; K3 Y$ x
      print('error')
: m* p: j( ]1 \! s+ [2 f       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)  :
) l6 V* I# Y% F% w# v8 A& e4 l name = input('name: ')# n9 a" ^7 ]# i2 `* K. Q
pwd = input('pwd: ')
. G) c3 e. h  w: e6 o" z if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':  K' H; e2 v4 r4 x1 j
      print('ok')3 b7 C$ a5 `  ^9 ?- [
else :3 l8 m8 b3 `+ ]) a7 J3 z9 D
      print('error')8 y* Q2 Z9 r* q+ C/ {
      count+=111、写代码
0 A( N7 ^& X2 N/ z' Ua. 使用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) :
. o2 Y; a) i2 ]- ^ if i %2 != 0 :
% F, ~9 N( ?: ]2 C6 t0 @* s) [0 P       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
7 ^& e* a& ?, E if i %2 == 0:. y' T& R9 o3 r, Y
      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"
# l4 _: k3 |/ \1 t  h0 ba. 移除 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)
  N* l6 J3 p; P# g! c3 x) Cfor i in name:( y5 m3 u# z: ]; }
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
9 y8 q% {6 Q+ d) e; i1 T22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']7 o" C' G% ~4 h7 v( d5 Q
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    9 P+ y9 \, r& B% ]
print(li)
- g3 G1 C1 z* J ['alex', 'eric', 'rain', 'seven']5 h; `2 O7 M% L7 F5 W4 Z
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
( t* s/ h  ]3 C/ f' I' zprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'); X# E+ S, w. S2 {! G
print(li)
  _9 T4 u" a7 w. _5 @e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
# }0 U- K# `4 {" Q: ^6 O; Hli.pop(1)  n; M! s. f) r( A- {6 C' x
print(li) ['alex', 'rain']
2 ?: W. O0 q7 Q3 Q指名道姓的删除li = ['alex', 'eric', 'rain']- V! Z' J4 {- c0 X0 L5 u
li.remove('alex')
3 O* w( F' }' ~; y; V8 x, @0 x$ r3 qprint(li)- u% r/ v$ w: L4 u1 R7 h  b# e
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']' O% r2 k" V8 T! E
print(li.pop(1))* J( _' H& a  j
print(li)! }1 V+ {" D9 w/ z4 j5 Q/ N

: ], w2 c' D, V5 @5 M6 t! T8 Heric5 l9 Y9 v) `% A% }8 T1 T
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
" ^; g  L8 C/ C7 Q( _, r" Mdel li[1:]  r( A. y- ?+ s2 a2 L- L
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)1 n. m3 ^8 W: |$ N; G  n; ?" E5 i
li = ['alex', 'eric', 'rain']
4 O4 S3 O/ s! B5 I7 ^3 s2 ffor k,v in enumerate(li,1):/ R% Y. S  y! F
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
2 r7 i+ |- F( C; l4 a+ ]a. 请输出 “Kelly”9 l2 |) k6 i0 S
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]) @3 X0 u! `( O
print(li[2][1][1])
0 p% p+ x2 Q6 a: c$ w* wb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
" {5 q/ P& N7 a1 _( T1 g& Pli[2][2]='ALL'
; F' m) m: E4 w* \( H$ t' ?3 Hprint(li)
9 e  N/ H( o" L  [9 ^" U2 ~24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
& U  d* W/ ]- C3 x7 La. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
/ P5 h2 W. w% R: E; Aprint(len(tu))+ d8 W  w# q& j. b
b. 获取元组的第 2 个元素，并输出8 o) v9 r* m  Y5 m
print(tu[1])
, l: T5 k! y, ke. 请使用 for、len、range 输出元组的索引
. h, n  |! g6 x+ c3 p" wfor i in range(len(tu)) :
) f" j: X6 I) n) l print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)5 \% h- z9 b! F9 K5 N0 }
for k,v in enumerate(tu,10) :
& C7 F! f; ], t0 |  V print(k,v)
- B0 u% }1 i5 B" x9 B10 alex
/ l# j$ \6 M% m$ S3 v11 eric2 s$ b+ }3 _- X" n! m4 y  W
12 rain7 ?) z# E) T% C4 B( d/ {
( y0 r  _3 ]0 K, }- M
for k in enumerate(tu,10) :. k7 d- ]$ j/ R3 m  y. `6 F
print(k)
# p  [3 v/ T* O0 ]  H" r  A(10, 'alex')6 x5 s' W) \/ o) l
(11, 'eric')
" s& o1 F  ~+ `5 j(12, 'rain')
* `+ `  ~$ z1 `8 G- Q2 I. q* a. ], Q% P, @5 P/ f- R

$ l+ [3 y: D! D) U- O* d" l2 E! I25、有如下变量，请实现要求的功能" ^  M  V( r) C+ w: s. t
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
6 O8 U" H) s6 F
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
  U/ S& p, e$ W- C, {! C. Ctu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])& O# q6 m% L9 m$ m
res=tu[1][2]['k2'].append('seven')
5 K1 |& \' b3 o0 u% V/ n6 b% ]3 p* K2 ]% u) W9 `0 C8 k
print(tu)6 V  v1 _# i/ c% a* m  x# K6 O
26、字典
4 W+ g  t& L, N( K7 j; Ddic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:1 {1 o% B9 X6 I5 C  A$ A/ X
print(i)b. 请循环输出所有的 value
4 V; Q& Y, Y* o% z  z0 `for i in dic:
+ f! A0 x6 Y- c+ N; y1 n( Z, y. E print(dic)) z% n! \. E% @* g, n& Q  l' l1 D
c. 请循环输出所有的 key 和 valuefor i in dic:6 k' W# I7 @9 ~7 l
print(i,dic)2 \) t9 L4 e* O& [, n
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
5 I( P/ a- J+ z6 S" c8 J6 B! T8 Bdic['k4']='v4'6 c3 |2 |& B' Z9 z; a! M) ?, ?
print(dic)3 o  ^5 a" g' g
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
" E  n" ~5 p% ^* O6 hdic['k1']='alex'
5 r+ L& p$ n3 ^( B% lprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典5 {/ i! D/ a- J8 b. H
dic['k3'].append(44): J6 _& u" A) I; m* `3 F! N% K* k
print(dic); h; C/ `+ _4 e7 b  L
, d% P( G; \9 t  S* s: U9 A: b
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
" V" S5 \* C5 b# R7 I. cdic['k3'].insert(0,44)
' r7 W) f" v2 n, G; F5 r- sprint(dic)
. {9 m# v" [- q: _+ V' x  T27、转换
# J1 Q% m3 X; I: H4 w  T' d- \2 |a. 将字符串 s = "alex" 转换成列表  s = "alex"8 M8 A6 D7 P' t2 H1 T1 b
1 x6 h! R; B9 j( X0 m' B" A4 j
print(list(s))b. 将字符串 s = "alex" 转换成元祖
8 ]1 ~" \% a6 L) z9 _+ ps = "alex"1 p: f0 ^; _" A, W8 k4 w8 p
print(tuple(s))
! K5 j2 M* |" c7 z8 u( N: _
# g+ w, m3 d. Z$ Z5 \  hb. 将列表 li = ["alex", "seven"] 转换成元组
; g7 e6 p* `1 Z' i& `/ F: Tli = ["alex", "seven"]
0 G2 [3 o3 x# A4 Kprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表# `) |3 t* }; [8 U1 J* j
tu = ('Alex', "seven")3 j# |* \: b7 r7 ~: b. s
li=list(tu)! d. ?/ P+ {4 A" |4 w- [/ I
print(li)
4 U$ k. h" }1 g9 T  a- _8 n
* p- b5 P5 ^8 ?$ E+ f
4 d- k& n0 U- A7 D1 td. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增' X! l- |' O) g: Y) ~; i
8 K+ D: u1 X: ]( x* u7 e" k
dic={}% r' {$ z0 G% M2 X! X
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
4 A; O0 h# {+ G6 Z3 D  G dic[k]=v. O6 ~: Q$ f: R: c, b7 f' W; U5 }
print(dic)27、转码n = "老男孩"! p9 ]# T2 j4 l
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"0 x! E/ F- {. `
a=n.encode('utf-8')
0 f6 b; p7 M3 N; [  ~: u. x/ Y" Gprint(a); n3 D( c) @1 y# F' f" P
b=a.decode('utf-8'), H" Y" ~: O/ S' c4 B, g8 D! t+ b
print(b)0 e' O6 i+ W) D+ w$ y! ?
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
4 k1 A3 {: D3 h' _3 f  k) n! r, Dprint(a)$ X" q% X7 V0 F5 m  b# ^/ v1 B
b=a.decode('gbk'); Y- j1 ?& T8 S. Y; j+ P# H5 Z3 Z+ D
print(b)28、求 1-100 内的所有数的和3 ~9 h3 ?7 x, T0 q1 N
count=17 i; H4 j& \9 ~+ H
sum=0
1 y, C: s' G2 ]% [! K' ^$ m$ Jfor i in range(100) :$ S8 y; U( x% g6 k  }6 y
sum=sum+count
8 u7 H6 A/ o. Z' y) T8 V count+=17 r! T% y5 s& C8 `1 i9 o
print(sum)
2 _+ D! F3 P6 k- g7 K
4 Y, W% k* i+ S6 {count=1
% o( v; q5 i/ }( o1 _8 o+ Q  O- Wsum=0  W3 R: U2 m% k3 ]8 }) a; p- \$ B
while count<=100 :: _0 [$ B. G; u: W  u
sum+=count
, s8 y; F* W( ?: B+ B; w count+=1
& j8 z: R: H2 M6 oprint(sum)29、元素分类9 N. [: R5 i$ W# i' t$ L$ }
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，7 x6 x& Y" x1 q/ K
将小于 66 的值保存至第二个 key 的值中。
3 S0 C" U# F& ]% D' ~: b' ^# t  h即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
0 p* E" A% F5 _, S/ @li=[11,22,33,44,55,66,77,88,99,90]# }0 V3 I  f$ d- z9 b( t( `
dic1={
' n$ t8 N: K$ c* P 'max':[],
" f( F9 t% Z  s$ |0 F7 J" _ 'min':[]
& K1 h/ |$ N6 `, @/ V5 n}
3 r, A$ q, ?( A! A" a" ^% |( Dfor i in li :
6 h/ u. b& v9 ~- P, w/ n if i <66 :! L4 I. l) t( D* ?' _
      dic1['min'].append(i)* e3 l; m  ^7 P" _; s
else:
- Q8 y' K) ?* i       dic1['max'].append(i)! J' d5 \! o# L. D
print(dic1)7 p) `  J0 ~  l. {8 H

3 f9 e0 M* R; B" u---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}" A2 J6 w9 o5 s0 a4 y

Python基础知识汇总

主题推荐