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、写代码& a/ l. `, D, W) R/ M4 @
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) :4 S+ S% M$ n0 |1 O
name = input('name:').strip()
; u7 i5 w+ e. H9 j pwd = input('pwd：').strip()

8 z: \. w! p; _9 k if name=='seven' and pwd=='123' :
+ N. X7 P! `$ n6 l. o& e       print('ok')
( t4 [' s' S7 Y+ v" J else:* R  i( ^, \1 k2 j; N
      print('error')
' Q/ [: B: ]4 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)  :5 b* z6 n1 C0 M# N* P
name = input('name: ')$ `, o% c7 p( B5 L* G1 L4 H& @
pwd = input('pwd: ')8 ~% V& z+ [9 N
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':' s* P) O% E% G, x0 V( p% q
      print('ok')2 F& w; M5 l: F! K5 ^; g
else :
3 `7 Z4 F5 C& q       print('error')
. J7 R% D1 h% g  u& f$ x# F9 x/ J4 q       count+=111、写代码
# t. C7 j6 v# J. ra. 使用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) :
) @/ ?3 m0 P' E8 }, D if i %2 != 0 :# v( K7 L% v% m3 v& l) h
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :% I  U' f% O  B* p3 n% d' H
if i %2 == 0:  o; e* s% e. K# Q' J! G
      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"
3 ]  p" [5 f6 m) {! 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)
' T1 N+ H0 E. A# W# ~6 Ufor i in name:
0 v( q/ R4 S- J! _( Z print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
- E4 l0 R) f6 W0 `2 V2 X22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
- |# T7 y" K6 U' N; \3 k/ vprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
; S- Z9 G6 a( y7 I- q- i6 tprint(li)- c8 m; A3 U) O% d- W5 D
['alex', 'eric', 'rain', 'seven']8 P1 s9 c3 V7 A, O" l
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
0 I* y# O  z) L/ Q  _1 E; p+ T1 ]print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
2 \6 G' }0 d  qprint(li)$ H. z  M% h4 l! ]1 e0 ?/ j
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
; b; n  O9 C- u7 z& l, a0 rli.pop(1)
+ ~7 f/ n6 p  X% v3 g" T% {% tprint(li) ['alex', 'rain']
( ?+ Y" I% z: D! k, F% ~指名道姓的删除li = ['alex', 'eric', 'rain']# t( _* @1 K, ~3 n% G6 L
li.remove('alex')
. D, V+ B& Y$ vprint(li)$ L1 Z+ Q* ?8 ^! g4 X* s. x" ?
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']/ @+ P1 k- F( {
print(li.pop(1))
# r0 _$ Q: ?' j/ W* d$ kprint(li)
/ i: _! A, x7 X' ]8 Q5 Y( C( }! M; ^3 @6 |6 r" T- @7 F' ?
eric
& A) b! i' |; M; E6 l['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']$ n, A$ _7 s9 f* D) ]
del li[1:]
4 `( s$ j8 Y# X: X' B' W$ @5 Dprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)% @( [5 n) e9 H
li = ['alex', 'eric', 'rain']
# L0 C, ?0 x- {for k,v in enumerate(li,1):! R# R3 T* s0 s; l0 i7 a
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
9 u$ \, w8 z0 j( B) \a. 请输出 “Kelly”
, m# z3 a7 G- u7 [  Cli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
. S% i3 [4 l5 h8 e: Y. u" pprint(li[2][1][1])2 X& v( `2 [3 G) K5 Q$ U# Y" q
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”- l  a1 P+ b. f/ g" ?9 d& ?) D6 ?6 Z
li[2][2]='ALL'0 S, L6 E8 n( n+ ~9 _1 o4 G
print(li)
3 E& b1 f! y6 N% C; l24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')/ c* H% F% ?% P; ^) L4 f7 R, R5 |
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')( E+ i6 z5 M0 [
print(len(tu))
" J& u" B( E  i, ?1 |9 Y( rb. 获取元组的第 2 个元素，并输出
5 u7 e. e$ r. G# V; \$ A1 P# eprint(tu[1])
9 ^$ P% K4 p, y+ De. 请使用 for、len、range 输出元组的索引
( r: c. O  r$ b: K! e+ hfor i in range(len(tu)) :
' D7 W2 k- o9 a print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)$ f7 P5 @1 q& ?
for k,v in enumerate(tu,10) :
4 |# U. K* H( ~# T print(k,v)" V7 D# ~$ \9 C8 w! l  c
10 alex$ _1 i, D4 k8 S+ r! ^, ?
11 eric
" H+ q7 A3 A$ J3 W12 rain
+ H0 c2 ^8 t% V, o# }9 T4 g4 D! r. O7 B" S3 J8 u2 e# ~
for k in enumerate(tu,10) :+ F& p0 a1 t( m4 @9 d
print(k)
0 F9 M) X+ ]6 F$ a' g- D* E# C(10, 'alex')+ x% M1 J: D+ C/ ^5 D9 s9 N
(11, 'eric'): M0 q( P* X# L5 |5 q  o
(12, 'rain')
$ ~! K* M; {' H6 Q8 F% b: P$ P4 m5 D0 E3 `
9 ?; K/ p& D1 y7 w4 N
25、有如下变量，请实现要求的功能5 ]  A* H6 K0 n: n4 ?$ N
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
2 `: [3 o' g( F
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以+ g$ W9 b& D* ^3 c2 g
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
+ ^. {/ x) V1 K/ @# m8 \- Mres=tu[1][2]['k2'].append('seven')
, h& k3 O6 N- M! x+ @& U7 l/ j' A' V. i
print(tu)$ D% R' S! r: [- ^! k6 J( [( S1 N9 I
26、字典4 H* C4 n8 y) c; Q0 P( v. ?! A
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:/ Y: q: U! e5 o; j$ ^! k* L7 |( A
print(i)b. 请循环输出所有的 value
( n' x. i$ }5 G# Ofor i in dic:
/ T7 W* j* a) K, ~/ c print(dic)2 G9 g% g2 T# o" R
c. 请循环输出所有的 key 和 valuefor i in dic:
5 S  \2 v3 e! p+ E. rprint(i,dic)0 m. G  y  F5 B* q; w" Z' g
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
  j% B- y& R  D8 ]7 @9 j9 \dic['k4']='v4'
: Z  w0 o0 ^* C. Nprint(dic)
% j: z  l/ S% C3 p; ae. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典7 Z2 X9 \4 e& G$ ~4 K* a' H! `
dic['k1']='alex'
, @- w$ W" I0 B' U6 Kprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
$ n, ?1 H/ Y# x$ h) Q$ j. Jdic['k3'].append(44)
& W5 F* d- @; S8 l" ]print(dic)
, O/ F3 _' e  G! m0 h2 J3 I3 Q5 X' q( f" b+ G4 a2 d! E; n
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
  c8 h8 j( |' J( wdic['k3'].insert(0,44)4 V# ~. `6 q/ Y* Y3 x6 h
print(dic)
" p/ z+ j1 H: s0 C2 e5 u27、转换% t+ `$ k( ~& l  S, h
a. 将字符串 s = "alex" 转换成列表  s = "alex"
/ S( U# M. ~+ `, v. a5 H) ^0 X. w: L$ `/ ]
print(list(s))b. 将字符串 s = "alex" 转换成元祖0 y6 g1 \9 w5 [* B3 ?& g
s = "alex"
/ b# P, I& g/ {% [! mprint(tuple(s)). f  _, q9 W8 C8 m2 q% [# O

( Q7 V0 E1 _5 E- B0 X1 e8 ub. 将列表 li = ["alex", "seven"] 转换成元组
1 [$ V5 _, O; bli = ["alex", "seven"]$ P. A  a+ X! W$ f! ^- I. g
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表- x, `1 R0 l3 m0 t9 L
tu = ('Alex', "seven")
" _: d0 _0 L5 Sli=list(tu)9 w! K% h) i$ \3 N: J) ]. i
print(li)
4 _, o& p6 N4 [/ n
2 g- W" c; ~& H6 D3 j8 K7 K
$ k$ L7 e! N4 E- Q& L9 [: G' ~& J$ md. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
2 A$ p+ ^8 v% P7 C5 C+ B7 K
: a1 Z& m& ^9 m6 \/ qdic={}
( M4 ~8 g1 V1 Tfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面* N% `7 X& \0 W5 W  p6 W
dic[k]=v
5 X! H- Z2 H5 | print(dic)27、转码n = "老男孩"+ r+ a2 s% ]  m$ D9 f0 m+ Z7 H
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
" `& R% |1 c  z4 b1 P7 Ua=n.encode('utf-8') 2 l" B9 X9 E8 A( G
print(a)9 Q2 w" Q7 h0 o
b=a.decode('utf-8')
; O6 I2 U) t% z  y% \* Lprint(b)
4 K5 {: z2 ^/ N/ hb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
6 C* j$ m3 P  x1 I0 M7 C. _: c% uprint(a)( F! u& Y- l& {* h: G- t4 P2 o
b=a.decode('gbk')) _- z' j7 F% ~. J2 ?
print(b)28、求 1-100 内的所有数的和
; u, O0 X, m  q6 R  R% Hcount=16 {: `; H# u+ w
sum=0% k* a6 a& a  [) W' X, W* O
for i in range(100) :
; M0 o- }1 N$ o/ i4 l; G8 { sum=sum+count
; ]) x3 o; l! I: U1 O count+=1
0 \* C* I4 D7 Tprint(sum)
/ Q0 |. t  r2 T3 i, L/ |
- S/ S5 }6 ]) H$ m9 ~. ]count=1
8 O  z4 t4 Z  M8 t2 t# d' `sum=0
) w" u2 L  o9 Y4 H& [while count<=100 :' T. K6 L- P; K$ C
sum+=count) R  }0 K/ A; X  _. y" L
count+=1
: l0 D7 P! X, ~print(sum)29、元素分类$ [1 d* e. c5 T' A0 N" A' L/ O
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
' ^' Z5 ~/ ^* D5 `5 D4 }将小于 66 的值保存至第二个 key 的值中。
0 f& h; j$ [. u" A3 x7 A即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
) v# F6 W( {( \5 _" tli=[11,22,33,44,55,66,77,88,99,90]& T9 ]) S8 X) y2 K( I1 R% T
dic1={% z4 }% J6 g8 y) t, J
'max':[],( a6 x. D& _' ^9 q
'min':[]! o7 v: B& u* t- p0 a
}, V* \8 {$ k* M! o/ z/ U
for i in li :
) f- ^! |& P2 E5 w if i <66 :
$ Q+ U+ C" e5 l* f       dic1['min'].append(i)' x/ u1 h8 Q+ i6 p  Y
else:0 |8 d. E! ]& t# p
      dic1['max'].append(i)7 q" V- Y3 {: f4 [  O/ C5 b
print(dic1)
  h; J2 x# \1 u0 |
8 H2 v+ [) }; {1 j. o- L---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}- n' X8 c' o8 b+ e4 P

Python基础知识汇总

主题推荐