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、写代码
$ ~, F" }4 z2 [! _+ Qa.实现用户输入用户名和密码，当用户名为 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) :$ _$ J& T8 h* I$ d$ F; g
name = input('name:').strip()
- ^; s: D% X# x2 d/ _5 h+ {5 O pwd = input('pwd：').strip()
2 u( w" o4 A; b/ d* I2 b
* K: p( q' a4 S1 z  W if name=='seven' and pwd=='123' :% B5 `9 c, }4 M- N+ t/ N
      print('ok')
# c1 f+ i) t  i2 c" z3 R else:
: C9 }  O4 I8 R, x       print('error')
* I* F8 |" l0 A. V1 p       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)  :
8 a8 S8 e0 r* q- [. g3 \ name = input('name: ')
' t% T& E  V+ d" @% w4 ~: H pwd = input('pwd: ')
0 c0 Y: u& _4 v if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
6 [% E1 M' c' n# K/ R  `4 U       print('ok')
) ?/ Y. `' L% P7 ]( v1 D else :7 M# ?' Z: @' R! ^0 e
      print('error'), l" Z/ I; T( C5 p) }+ b
      count+=111、写代码# ]; I, \; I* P' X& t, S) R
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) :
# z# p3 K9 ^  v, r- @5 y1 j if i %2 != 0 :
4 |$ ?- o; Q/ K' f2 r* D       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :3 p9 p2 ?2 Q$ |$ `
if i %2 == 0:) Q6 t. |; P7 Z/ U) o5 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"/ z# l* M& X& c/ \& D, L
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)
% G. k2 N: r! v" {+ _4 U$ Y. q- mfor i in name:+ V2 c. k4 `* e; {6 L; {
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain% e: d- r+ R5 J) A
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
" g: T0 c! e& U4 w. {, \print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    . r& l9 ~# N% {% G, u8 m
print(li)
; e5 b2 g6 F  A2 w ['alex', 'eric', 'rain', 'seven']
, Y$ s8 U3 ~: g6 ec. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
5 g* e2 S- t2 _! N! M, zprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')  P8 o$ S( ~4 p
print(li)
  L1 p3 U. d2 u9 U, U. ~1 ~e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']4 Z3 F  c" T. u9 W
li.pop(1)
% Z8 y* l5 w( M3 N1 R  F- bprint(li) ['alex', 'rain']
' a9 C+ Q& c# G1 q指名道姓的删除li = ['alex', 'eric', 'rain']
4 R( [9 [0 ?! \$ v  ~' Q) `  x" xli.remove('alex')9 b! l( S9 J6 H; g/ R$ N* ?3 S$ F
print(li)
$ O8 q3 l$ W8 D5 B7 s; C' wf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
2 M7 d* l; t2 F# w; g% gprint(li.pop(1)); L4 W3 b& W) }  I7 u
print(li)
+ M; y( m' ~+ ~5 M
5 c! O: l& C7 o' a/ G% Teric  d# E0 Z! [4 [  t( W7 ]' \4 Y( p
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']8 ]' p% U* p( N8 x# T) i
del li[1:]' n, n4 P% [( D# k2 P2 o( N. n
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
5 r) q2 J& W# V) i( e0 u9 Bli = ['alex', 'eric', 'rain']
0 p) }- z9 n" ^6 ~/ m3 lfor k,v in enumerate(li,1):$ q0 [/ d" g' s( b  J7 M0 ~
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 r! a" m& D) Q/ e2 V) n$ na. 请输出 “Kelly”, m# B8 R; J" [" \8 v/ T
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 [1 a" Z* M# @  s' ?4 m* vprint(li[2][1][1])
1 R# R9 ^' N% F) N! Ab. 请使用索引找到 'all' 元素并将其修改为 “ALL”
6 V1 Q. |. f3 P. Nli[2][2]='ALL'
8 B" }7 c8 e5 E9 uprint(li), A+ e; u" a2 R& i
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')9 ]$ {2 T$ d$ ?- _" Z/ W6 o3 ?
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
& d2 F( n! w! W) ~  V: Q% l2 Iprint(len(tu))
5 E4 O5 e( F( nb. 获取元组的第 2 个元素，并输出5 u; l1 Z. g0 N( M3 @0 C
print(tu[1])
  N8 A+ R/ i& E5 O% H8 ee. 请使用 for、len、range 输出元组的索引
* T8 u$ M9 u6 U+ @' ~( ~for i in range(len(tu)) :1 q( m  _# p+ E  t& R
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)% @( A$ X" O6 z
for k,v in enumerate(tu,10) :+ ]- N& A8 k" ?+ k6 `
print(k,v)0 U, P+ u2 @9 N8 I+ u
10 alex0 }8 [0 h3 z' i4 y+ Y' ]4 Z* n) {0 D
11 eric  ]9 ?  ]7 R! L4 c" D0 w. o
12 rain
# R* b2 w$ }/ q. ]2 E
+ Y! G: b: M, Z! w0 ^for k in enumerate(tu,10) :
  m; P  M: ?5 y1 j3 S$ x print(k)
4 u# i& M$ n8 h(10, 'alex')
2 ~8 ^- d9 }* z! @(11, 'eric')6 O  d* n/ s+ E2 h/ o7 b
(12, 'rain')4 P) r  _- G; V$ [5 z2 ~
8 n, N$ |5 R4 f/ v2 T: ?3 G8 z1 _
) B# m; {) ?* H4 r& ^. F
25、有如下变量，请实现要求的功能7 w9 t, B1 K0 [' P& J, o- L; e
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

  k( w7 H7 B. z$ G7 w) id. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
8 `" P) E# s- L; ztu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]); T6 @5 M8 [' L5 a1 e  j/ R
res=tu[1][2]['k2'].append('seven')
! u8 K3 r9 U1 C* @$ M! X# V( Q. J) w1 y2 W
print(tu)
5 i' H5 L+ s7 H; t1 m& x26、字典
: @6 T% I7 g+ o. \$ ~+ c# p! ^2 _2 }dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
. B: ^4 P5 b) K5 b- \" h print(i)b. 请循环输出所有的 value
! _8 c" d' f, c5 gfor i in dic:
! p( V; D/ q, I4 j% r print(dic)
9 e# J  e0 a. ~- B) pc. 请循环输出所有的 key 和 valuefor i in dic:
) S  P( {/ ^. [2 D) Vprint(i,dic)* }8 p' A6 a0 L6 m
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
. l$ V1 h5 q* c' I* Pdic['k4']='v4'; @( I/ m' v( N7 p2 O7 n* G# b
print(dic)
7 p- l8 B8 ?( F9 p1 v. m3 z' Ke. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典! ]5 i' c+ c/ }
dic['k1']='alex'4 U* l4 S; \% Q0 x% Y$ s
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
: @  Z$ v& q! x/ a+ v8 T. }) G7 Gdic['k3'].append(44)$ @5 H: ^+ S. c  Q2 |8 g7 Y
print(dic)
& W% ?* |8 J! t
" L, k! z$ B  L/ n& G, xg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典, @& Y& d. L/ m. `2 k" Y/ o
dic['k3'].insert(0,44). ~- {/ X' D8 A0 g- {! A( g' `
print(dic)
) P9 t/ i9 `! q( U27、转换
0 d6 d6 w+ A  q* C* Ka. 将字符串 s = "alex" 转换成列表  s = "alex": V+ r% M& D8 C1 v/ T. o0 E
4 S- a8 L7 o1 }( r
print(list(s))b. 将字符串 s = "alex" 转换成元祖
8 g: ]) J3 s9 W9 M: W% as = "alex", i( @2 j$ k% b( [; I+ G5 M8 h& T
print(tuple(s))3 g' a6 O5 x: P- O4 H% {
/ q4 I, r  C' l9 r$ n+ k
b. 将列表 li = ["alex", "seven"] 转换成元组
- u3 ^! ]" ?& N* u9 S' qli = ["alex", "seven"]
" o# t4 A! j! |9 ~3 D/ X$ dprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表  Q& ~* @$ m& p: r4 v: d$ q
tu = ('Alex', "seven")8 J8 H1 `0 w# D
li=list(tu)4 v+ q, v, s& g  ^( Q- r9 `5 S, M; ]' r
print(li)0 ?7 v% T: j5 L  p3 O: e
: y2 `" K3 [1 [$ P9 c& _7 d
+ b  l" o9 V2 O4 |0 s$ `/ u+ {
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增7 j( ?, x: Y1 z0 Y* O
/ r3 P- J5 V9 a8 T" O4 _
dic={}  o! c6 m/ _% p
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面1 q: P) J' `. h: d+ Y
dic[k]=v
/ b$ O1 r3 F  O6 L2 z print(dic)27、转码n = "老男孩"
9 U8 q: z' l% c1 }2 ]; qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
0 l/ o9 L' D( @4 U4 @, Y& H( Ma=n.encode('utf-8') : C, v% q( R' c& q
print(a)
' `2 Y; `: m( k$ Ab=a.decode('utf-8')) u  K* ~- n% l! Z2 N0 H; D
print(b)
  q9 h+ v% Q: K+ _: O- Y6 X. Y) x( @b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
) G; C: t: i( o* \$ Q! ]1 I7 `& cprint(a)
% d' j& A( L& [! qb=a.decode('gbk'), D& F' ?- U: K& Y- _6 Y* w
print(b)28、求 1-100 内的所有数的和
6 p& X- w5 X, S. c1 Ycount=1; e' M7 _3 l& T, D- }
sum=0
! N- A' F/ _1 r0 y9 cfor i in range(100) :
9 C, G4 @# D. O$ T# ~ sum=sum+count
3 e- ~" Y2 [% o" W* | count+=1
3 |3 ~9 \% d8 _" W7 A7 zprint(sum)$ C+ s1 m7 m( v& O5 S
0 m9 X. \+ P& {+ f' h' a
count=1
* j! B8 P9 \; [; l4 Isum=0( N5 q& O5 G2 {# g7 X0 |) V
while count<=100 :: p" o: I$ S( A$ H! `
sum+=count3 \3 n& i& j2 ]) S6 N
count+=1  y& `; G+ Q+ d9 J3 i, _% c
print(sum)29、元素分类( |5 F2 L/ _8 {4 f/ |; p6 [/ c- S
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，- j. @" G) M$ E; ~- E9 b+ `- h( Y! D
将小于 66 的值保存至第二个 key 的值中。
# {0 F( X3 w3 N! D) P: P即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
/ @0 l7 |. P7 F$ {8 t- P6 ?* d/ Sli=[11,22,33,44,55,66,77,88,99,90]
3 u. l3 l5 r) i" Zdic1={
  n" C3 o6 t4 g. F' [' t- M 'max':[],
1 s2 W! V- e+ c 'min':[]# v: Z: z: K! f+ Y6 X" L$ B
}
$ G1 ~. a1 e  V0 t5 k; hfor i in li :
' ~: {" B" x+ A* N: L if i <66 :
! S0 ~$ W5 F7 j$ W6 r       dic1['min'].append(i)2 d% y8 }0 r9 Q0 x) \9 M7 A5 k
else:7 v) \: J8 r$ q
      dic1['max'].append(i)
9 @& E6 R; w4 U6 e8 a) Qprint(dic1)
) {) W# Z( |2 n( Y! Q0 ?1 ^1 A' W. C+ H/ i( ~7 Z0 c
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
5 o7 n- D( G( o, ~1 h

Python基础知识汇总

主题推荐