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 X: v1 x  g" K
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) :3 w! Q* ?4 D' {+ B' d$ ~8 p, w, K
name = input('name:').strip()2 K$ m0 `3 d: y/ m4 ?$ P
pwd = input('pwd：').strip()
# }1 j- K' ?9 q& r- |
# l3 f) M- z- m  I if name=='seven' and pwd=='123' :2 @! t4 t) F/ F' y7 s
      print('ok')
" B+ c! X9 j5 j- N5 ~ else:
$ @/ K$ ^8 t8 q* N       print('error')1 i* X& X* {  l) m) D; E# 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)  :
2 @/ f3 W& ^% D0 f% N! ]# ?/ M name = input('name: ')# ^. `1 X/ t, O3 ~% e
pwd = input('pwd: ')
# k9 q; P% D8 j- n* M0 E if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':% E$ k1 Q  d: X- d' V: O
      print('ok')
2 v9 k( Z+ }  q3 R; b( X else :
) p" V% ?* T) m8 [$ A" e       print('error'): O# Z0 i' z) z0 B
      count+=111、写代码0 \$ [' Z# M; [, |6 b/ Z, @
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) :
8 o9 y" i; |% ]3 q4 Z. |- |/ R if i %2 != 0 :: l" z5 A; E0 J4 }* Q9 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) :
2 O: Z$ U3 j" f$ z% i9 Y if i %2 == 0:9 i  u7 Y; R: ]# K/ d
      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+ V* H/ j3 Q  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)
( n( N5 d1 O/ f, C1 f- \: mfor i in name:
# a/ M9 ~8 O& Q9 m: |# { print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain% B9 s* g  @- y) {" C  r* c
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']% B6 P" @1 F) V7 f
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    # c7 i, {/ s7 W) _) `
print(li). Y7 _6 }/ S9 E7 j# A# P
['alex', 'eric', 'rain', 'seven']
  d5 d! r; G- ?$ s1 [+ Nc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')5 i+ S/ Y- t% J/ @! F
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
: p: N  I5 A& wprint(li)
. M) X0 Y3 ~: e  w: ^; N4 v# de. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']1 ]9 O% d' s' @6 _  H
li.pop(1)
1 l5 h' U4 `! qprint(li) ['alex', 'rain']
1 {  ]( |6 y! X/ l8 ?/ e9 ^, H指名道姓的删除li = ['alex', 'eric', 'rain']
+ x+ u0 v9 J2 y. S& `4 Tli.remove('alex')
- T% H2 C4 v8 n7 Y" Q+ X% |$ a. s7 iprint(li)* c: j9 u* D# Z0 H4 b
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
! h/ W& ]9 N$ ~6 @5 X& _print(li.pop(1))
- B. V; F# _' _: o. ?( Rprint(li)
, d: C8 c$ ]( u* Z& l0 ^+ l$ ]& J  M- R' j4 y$ O
eric/ z3 O2 I7 y; G% Z" q! l9 _
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']! i4 j/ E$ O" w' Z' E" w  ~. W
del li[1:]
& u# `: j8 j/ g$ B) n) eprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
0 Y8 H% D# @  S0 e1 ]li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
9 V& p6 S5 @. s9 `, e% j  W  ~ print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]) ?1 P; L( j+ b8 y3 Z
a. 请输出 “Kelly”
0 I! A3 s- A* x1 Q; ]9 e! V: k; Cli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]' S6 ?5 l. c5 E& J8 d6 i" `3 I
print(li[2][1][1])
' O2 y( q' I/ u+ P  n. N& k+ V: Gb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  R+ U# e5 l! R4 g; `li[2][2]='ALL'
! K. T# k2 ^: s4 u0 Q( iprint(li)
. U6 y. m# q$ {" o$ k4 H24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
1 m6 S0 ?& H6 x2 l' z. ha. 计算元组长度并输出tu = ('alex', 'eric', 'rain')6 A0 x3 _5 M. a9 L$ k* I/ w
print(len(tu))# Q0 g- z$ I3 e. y
b. 获取元组的第 2 个元素，并输出4 i4 B& z& B- O# X& M
print(tu[1])
( g* m8 h+ D: we. 请使用 for、len、range 输出元组的索引% h# _  B. p" }/ u" o( U
for i in range(len(tu)) :- ~: O: W4 k5 x, s4 \" v. c% q
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
2 W/ r; k5 A1 ]for k,v in enumerate(tu,10) :6 a4 W& M: G4 B& m
print(k,v); R; F: ]/ K* L) Y5 m9 T! t
10 alex
/ }# C* N8 |) A' v8 r11 eric  y$ {+ J9 x- Q, o. I! s8 g
12 rain, k) q2 ^- n) t- U8 f3 E
- g0 U& u1 \1 n! ?
for k in enumerate(tu,10) :
+ ^& u! A  |  K3 e: M$ \0 x print(k)
1 ]9 }' @3 i: {% t; c9 O) f( M1 U(10, 'alex')$ O1 z) s3 p" K2 M. U1 K# I
(11, 'eric')& k, Q- J, [1 f! P9 z& D! a
(12, 'rain')1 p4 F" ^- L% T4 ~' p( r

! F2 h6 x' K/ Z/ A1 m$ B7 I8 D2 q% Q. n* T
25、有如下变量，请实现要求的功能
; C+ ^9 P! x7 h' Ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
5 k9 i3 i( a# i
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
. E& \, |1 h$ V7 o3 H* v3 W- }$ _tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])6 [- t* N- w/ f- q9 g0 D; c
res=tu[1][2]['k2'].append('seven')6 T5 r. J6 A; ?% f+ d

7 ]  a9 ~+ E1 P$ l. s& T( m+ Tprint(tu)( s. K* Z1 X7 [' i+ t- r
26、字典$ D5 W/ u# b6 Q
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:- Q) h5 X* Q3 T$ f" T8 e2 ^* j& Z
print(i)b. 请循环输出所有的 value
2 A8 S, E& _& v, H( j7 l* Sfor i in dic:0 R9 P. P& X# M6 y
print(dic)! b5 s- m9 v2 m* d6 C
c. 请循环输出所有的 key 和 valuefor i in dic:+ Y% J& S& b/ L, R0 Q/ T$ i* k* Y# t
print(i,dic)
4 l2 Z7 E9 _% Hd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
6 V# b7 x* Q3 |* |% b2 _dic['k4']='v4'
, V1 K/ x" F' f4 H6 u5 ^: kprint(dic)
6 q$ H8 i0 P  T3 s8 j3 i5 Z. |5 a5 Ke. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
" ?$ H+ |- b; O3 {2 V6 ]2 ?. kdic['k1']='alex'
3 I3 N$ E$ G& `. _+ f" ]print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
( x. I. P% \+ y- s' z  Hdic['k3'].append(44)3 Z2 E% U  f! T" g, `! k* q
print(dic)* K4 U# P( R$ y: ~: K4 n

) ]! d) `7 d/ \g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
5 X# j" R. Z6 z4 U! z0 f2 I* U( hdic['k3'].insert(0,44). M5 K0 R2 m& Y7 O' u/ o7 G* Z
print(dic)/ e% U8 k, U  n0 y) Z5 ]3 K  M. X+ P5 e
27、转换8 c7 x; Q$ C2 b9 G. P1 E
a. 将字符串 s = "alex" 转换成列表  s = "alex"3 D4 G9 b4 ]& M- _, G7 f

# a2 k) e% s+ Z" w# R, Q1 @; oprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
* v4 @' H# ?! C0 R( f1 Xprint(tuple(s))
' [1 i# w/ S/ t1 r, z, ^) y/ _5 F( y
$ X: k( I/ g2 K$ @  J5 `b. 将列表 li = ["alex", "seven"] 转换成元组* V' V. ?9 m" S" w1 d7 T
li = ["alex", "seven"]0 a* E* u( j% W( H" ~7 i
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表' \0 Y% Y. z* |6 X
tu = ('Alex', "seven")
: u- e+ g; O& a5 `$ ]8 Kli=list(tu)# R& f& f/ o1 ?) d
print(li)1 V, N# V7 ~8 W
# Z9 {& F# {+ _0 M
1 R# k9 g5 l3 ~1 m3 `/ v; j0 _6 r
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
# e9 V" U# J) c) f/ s$ V' U- v" ?2 Q0 v
dic={}
. m: h$ z/ f+ |+ P+ }1 ?" ^& Hfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面$ h6 `; a6 A) h4 j. ]) [* X
dic[k]=v
& X, g$ m5 i4 q9 V: h7 P- m2 Y print(dic)27、转码n = "老男孩"9 ~/ w/ ^$ ^, e
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩". N- |6 h' _: A' `9 H
a=n.encode('utf-8')
1 u# i# c" r9 r" Xprint(a)( a8 x  x3 N* C9 R( V* m, x4 c
b=a.decode('utf-8')$ h2 h. V( l1 Q/ h. q3 U2 z% I
print(b)( \! Z& g2 W- g# ]6 g5 ~. B3 r
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')8 w/ I6 \! B/ P9 V9 ?
print(a)
$ ^- d8 j  a- k) R# Z9 _1 pb=a.decode('gbk')
  c' n  I/ }: b) v# _print(b)28、求 1-100 内的所有数的和/ K* H& Z& q3 t0 L
count=1& `6 q* j1 [! J( T3 I, O, S
sum=02 G& p, [9 R, B& Z% W
for i in range(100) :6 I/ y6 U0 ?: \! C5 x8 W$ R7 X9 |
sum=sum+count% }) ?5 k+ N& x. S
count+=1' V+ p3 D6 [0 h7 R
print(sum)7 q8 g9 R+ I! _* n

/ s8 Z9 F# h- p% ]" O5 N9 i5 t+ Ocount=1
9 Y6 F/ c0 G- ?6 W; N0 |; ~8 r9 Esum=0. u8 H- l* e3 ~2 W' {" n* g
while count<=100 :
% D) n: ?, W7 z* \ sum+=count
* U% A6 e* q0 n8 F# W4 U count+=15 c* B5 r8 y. [* y& \) [' i
print(sum)29、元素分类, }* a3 D3 g, t# F) g. b* J
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
6 Z1 c4 F: R5 u1 q( M/ a将小于 66 的值保存至第二个 key 的值中。) d$ D. k1 P  c+ q1 K5 T) X
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
- r- t& n3 K$ K+ zli=[11,22,33,44,55,66,77,88,99,90]* a' z5 w  N. Z' `$ M" W
dic1={& G# [, w+ E9 S+ w. O
'max':[],4 S' v5 B  f( D$ ?, |3 O
'min':[]: U, \+ j0 O2 H
}8 K7 S9 l6 u* ]' N5 n
for i in li :
! R+ _$ i/ j2 {( m if i <66 :8 q+ {- E5 j0 A$ p4 w3 J5 S* }3 \( T3 s
      dic1['min'].append(i)
7 ~( K% _) l, Q, P5 v9 T else:- X: P$ p+ y$ V* M
      dic1['max'].append(i)
6 n% s. y) T7 L# n! a- K( `print(dic1)1 G0 v( i! n' d
9 [# r/ a. `) C( b) z9 P$ q( k: J
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}" o2 ]2 ^: u, h4 k6 K1 w6 z% g( z

Python基础知识汇总

主题推荐