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、写代码7 c  `/ C3 k+ V$ V" f
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) :: E$ C% A7 x; j! K8 }9 B3 s
name = input('name:').strip()% Q3 z* ]8 x3 |- K
pwd = input('pwd：').strip()& q4 G# M9 b& T5 o5 h! v! T' d

2 A1 [, L9 ?% T( ~6 E7 K' \- `/ a if name=='seven' and pwd=='123' :
2 p) I7 T/ p& l       print('ok')% f0 R; C, {$ m. x/ j2 f
else:) f+ T' \' b2 F6 v7 m: g3 U! S
      print('error')
7 u" J, d9 R$ @8 G# [2 }       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)  :
# j6 i* j& E2 t  Y) U5 n# ` name = input('name: ')" q3 ~! D, n) j0 O% o4 r
pwd = input('pwd: ')
" z( l8 }# v5 W0 q6 V; _# w if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':( x/ _4 Y7 o  i! `  s1 j
      print('ok'): U0 R* c' s8 ]6 i; M+ }: a
else :
2 O+ U! J" P+ ^* W; a; k- ^1 R( f       print('error')8 F) n- p4 t( [. X3 h# t
      count+=111、写代码
& W4 n, ^) N9 S+ k0 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) :; B3 T7 q. l$ s7 m, u* o
if i %2 != 0 :
) V3 A5 z* [6 i       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
# X8 Q4 |4 q4 H- R# P6 H: D if i %2 == 0:) K9 ^" O- y* }4 `4 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"
$ Q8 y/ X" T2 |2 ]3 q5 H' B. ga. 移除 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)' r8 z* t! ^, a7 F6 ]* g
for i in name:
: i( Y' @7 y9 Q; y) n  o+ } print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain7 O4 f2 j# ~, T# p6 h1 D  o
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
6 b% X, f- z3 {$ r1 m: n0 a' Eprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    + f- c- x) o, Y4 K
print(li)% [- v/ T! G0 J, Q
['alex', 'eric', 'rain', 'seven']5 {2 e+ C* j8 q8 V8 T6 T+ j/ j8 \
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
% T& X" t5 Y( Wprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')% p2 F  C6 z- Y$ t* T, d
print(li)) l& h( e9 o7 c( |% j0 z
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']: t& l4 B/ C, u) r# I* q
li.pop(1)$ |5 j4 r. M# m6 p
print(li) ['alex', 'rain']8 l/ A3 ]0 O/ U
指名道姓的删除li = ['alex', 'eric', 'rain']8 X/ V% I  q1 _. Q( L
li.remove('alex'): }! |: o, i% W2 Q/ x& C9 S
print(li)
* Q0 i$ K9 m- c; zf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
' o" z( j1 s: X9 b( p: mprint(li.pop(1))
6 }8 J' J5 v: G" J* r% s6 u9 ]7 F/ uprint(li)
  x- B1 C% k5 d5 p5 X
+ o, e3 f+ W& F0 P# B; U# ~6 meric1 P  X9 M1 |" m2 M. k: a( c2 B
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']* Q+ C$ ]3 W6 F; Q; B9 `
del li[1:]/ f$ a, N9 J6 ~6 {! d  z
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始), s, f. J; L! m) I- N# v5 n7 R
li = ['alex', 'eric', 'rain']( x/ I" A* q. R
for k,v in enumerate(li,1):, ~& O% i$ K% a2 ^
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% p- H5 t" |( O; ua. 请输出 “Kelly”( A8 N7 s7 ~: ~& b; Q
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]+ G5 \! s1 g8 k
print(li[2][1][1])
) l8 O8 K- x; e3 u( [b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
4 v2 B$ d" R- m1 Z  Oli[2][2]='ALL'8 p: @2 {& k8 |, [- p) r8 c, q+ Y4 l
print(li)) |; u# x) r- a4 l$ r# k- m
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')) d8 x( I9 d" Q8 P1 C9 I$ ^
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')% ^7 O; x. w' K5 c+ j0 A
print(len(tu))  o: Z) W1 k& H) y9 G9 H
b. 获取元组的第 2 个元素，并输出
- X, k  ]2 d" Rprint(tu[1])
' ~6 I* T: w4 A2 e5 u9 Q: ee. 请使用 for、len、range 输出元组的索引( ?* x. S$ g; [% o! o+ l* a
for i in range(len(tu)) :
  C4 M& R& j; `3 j print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)1 S9 \0 v/ M& W0 O: K+ B5 z
for k,v in enumerate(tu,10) :
8 B( `/ w7 Z0 w6 a print(k,v). ^. P3 {0 V( O9 z
10 alex
. U- J0 x4 Q) l8 K+ \( T: \. @11 eric5 Z# u0 k+ t) Y& V) j' ^
12 rain/ s& j$ ], M6 j: a' D) J2 h* S8 X5 B
3 T, P7 p7 {6 v# M. H: B* o
for k in enumerate(tu,10) :
0 p8 }! @' S% o" G1 P  R: F; K print(k)
& @4 z5 w2 O7 E) s0 k( k(10, 'alex')$ k, w5 X3 }2 e/ R' d7 E
(11, 'eric')
/ [# x0 t  g, ^( ~& s5 `(12, 'rain')$ T- Q3 j8 `3 z, q3 K$ q

  A1 L* A9 z3 U) S
( r9 ?  L6 O3 L25、有如下变量，请实现要求的功能
8 g% }: H9 H) f4 @$ }& C- f) qtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

, I6 N0 s% r3 X& ?3 [d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以; R0 G' o8 ]6 H
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])* Q& K* B/ a6 l2 H, B, G5 Q- h
res=tu[1][2]['k2'].append('seven')
/ G- `, m7 ?; `% \; p& {, l1 d" Q. F: {2 k: L; d$ t& @# m
print(tu)
3 {# s  v7 _, t6 g0 `, Q& o2 q  B26、字典4 K9 u+ g& T6 R7 a
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
2 C- m2 J7 u  S2 G& _1 i; V print(i)b. 请循环输出所有的 value0 W. }5 y% @! m0 m' _% k0 K
for i in dic:: y: j0 Q4 T, G- t0 o, Y6 L" g9 q4 I
print(dic)! H7 y0 ]+ }: y/ o  z+ K
c. 请循环输出所有的 key 和 valuefor i in dic:2 F3 k; j1 d. n! o, b; U2 {/ U
print(i,dic)
! m. f! o* ?4 ~2 j- q: Cd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典( W& k* z& N2 g' u& [+ p: B
dic['k4']='v4'
2 w; ~" _2 i  g- j6 k+ O2 o( {print(dic)1 y5 ]( V  U: Z/ E% U% L! J4 ?
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典3 |$ n2 ?' V7 s% O% S' [- }
dic['k1']='alex'
2 Q$ y( ?6 n: M! }1 Q1 mprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
' q% B; P( e2 q% e) O- }dic['k3'].append(44)- B  D4 _# B; Z
print(dic)
; n4 y: \1 B( `( ~7 \, o2 A/ E  `( W
- P) w$ v+ V: ^0 ?) o, pg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典% Y5 D1 b# n  k! e$ @- i
dic['k3'].insert(0,44)* S( k/ q' z# F1 n
print(dic)
* ?4 `( V; B' ]: ]- {$ r27、转换
% q1 b. z! n% ~  {5 o$ {: x. ia. 将字符串 s = "alex" 转换成列表  s = "alex"' G1 K0 k/ c2 x
$ c% |/ L" m& _  [- N$ P
print(list(s))b. 将字符串 s = "alex" 转换成元祖3 _% H4 ^' b. u! H( s- g
s = "alex"
3 T7 U; s4 R* q" ^8 ?print(tuple(s))2 ?# R5 W" Z- W) I

1 K- [- T# a7 G" C2 s" v/ vb. 将列表 li = ["alex", "seven"] 转换成元组; W, q( `3 O6 G5 h) C! G3 m
li = ["alex", "seven"]+ \1 L/ ~) r! D$ F* d
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表- Y( R5 q. G$ {
tu = ('Alex', "seven")! ^* W! C) d$ t+ x' z/ Q$ {& R; x
li=list(tu)
. E* i. h9 O! b: yprint(li)
2 I; a4 M# [1 d% }' E  X
+ \) L! d- W5 m% O9 I4 N
/ N0 n5 U  ?) g+ t( p$ od. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
! u, A# d6 _  U- W) y" y' ?5 Q
" z$ Q4 l  E% W! t8 n0 C  Z5 bdic={}
# W+ L; r2 W+ N  i( b# kfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
0 w: h& G( r7 _6 |" V dic[k]=v6 Q$ Y2 d. d7 }5 R/ ?* z; x
print(dic)27、转码n = "老男孩"
6 P* A* C8 c3 M/ c1 u5 A8 ~2 Oa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
( N4 e/ I$ Z2 Y9 j! fa=n.encode('utf-8')
5 |8 r9 ~. a" N' m( Zprint(a)
0 n% ~& Y" W% y( }0 T) pb=a.decode('utf-8')
$ R% m( ~6 M1 a. Nprint(b)* A6 P3 d5 U3 U
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
! i9 h( U7 C: s0 ]print(a)5 ?  F/ q) S+ B& n- @- o( P% M" l$ e
b=a.decode('gbk')
, \$ |; y8 w1 ?" b" @9 gprint(b)28、求 1-100 内的所有数的和7 {+ Y  k1 B5 C& h8 ?
count=1
3 s! k3 k* f+ j$ msum=04 G3 l- L  P) N! w- ], L3 q
for i in range(100) :9 i" z. B6 v5 b* g+ K
sum=sum+count( d3 ~9 T* e- u1 _
count+=1( a! e# _6 e3 S9 m0 A. q
print(sum)
( d3 r' N; k# h! E  U, G2 `' l
" v4 C4 O1 t& c' h" M, S' gcount=10 q# r. s/ A% F0 g/ `/ O+ W
sum=0
4 @0 E6 k& K% o& z4 }, O. xwhile count<=100 :  y* h, C  f$ |9 r) y. C: f% a
sum+=count
) y8 |3 u) g' y! _! o count+=12 `+ z3 ?# U! j# o7 N+ X
print(sum)29、元素分类
  \" w" W, `$ f6 K- x/ c4 Y有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
1 \* K- Z) g0 W- e+ Q' _2 u% C将小于 66 的值保存至第二个 key 的值中。
9 v( @& b& n0 f  r即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
+ U, ]( p' |6 w2 Wli=[11,22,33,44,55,66,77,88,99,90]  d% x$ O; c( A! O
dic1={( Y$ g& w, M8 y. P  J
'max':[],' b5 e6 ?' Z; T! {1 Q% X
'min':[]
2 ^4 k4 @3 Z, j% l8 U9 f}- L8 E5 w+ \/ h( x
for i in li :- Y2 S0 ?# |# r# Q  E* s
if i <66 :
2 u1 ?# x+ O* V: m       dic1['min'].append(i)
; U8 S6 s: _& j4 T2 I8 T else:1 z! C, d1 I/ A, e2 j; q
      dic1['max'].append(i)# J2 {  d' r4 `1 Q3 Y  n
print(dic1)
$ X! b) Y" T+ J' n- ~5 ]0 {' o* L. c9 j1 l+ ], f! e0 k# h
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
! Z; a8 o+ r1 u

Python基础知识汇总

主题推荐