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 ~' H7 ^7 ~0 s$ ]  I. i
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) :  d3 C" @2 ^6 @# K
name = input('name:').strip()8 a% r( @& L7 C0 u" s9 ~6 P
pwd = input('pwd：').strip()2 [1 W% K+ ?5 G3 y' l
  _1 G% \/ Z# |
if name=='seven' and pwd=='123' :& ^0 R( i0 |$ M6 G  g0 w; v
      print('ok')% K' K6 p* i8 t- a
else:6 y3 F0 |7 \6 T* s
      print('error')& ?1 X5 q4 F% h# M6 Z2 L# P3 q
      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 |) }5 m0 s1 L2 \1 Q. e3 N8 G7 [9 [ name = input('name: '), M% Z  G) b- d: @$ ^
pwd = input('pwd: ')* w- Q3 J* Q# r8 @+ g
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':/ m6 G$ S" s& n+ X6 g6 K/ r
      print('ok')6 `- R7 [4 m4 [1 z* I% s7 Z, v
else :
: z  D0 j6 A, Z8 N0 _' ?       print('error')
: L! g* r8 r# W$ f: m* |0 C' \       count+=111、写代码
2 D( z1 x1 Y! G5 h; Ya. 使用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 I( @8 T2 k1 o* |2 ]8 R2 w: m
if i %2 != 0 :
$ D* T; P" ~& y, P% o: J       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
0 M/ \% m, b& ~9 B if i %2 == 0:- ]& G+ O& I/ A& M4 a9 u5 |
      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* K; B/ C7 a+ Y* V  L; d$ V
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)
8 y0 U5 V- X+ ^. ~  G" I: yfor i in name:% T3 W, j4 b5 Z7 P" ]0 M& ?% T  P
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain/ {& L0 \; `7 }  l* v4 h) w3 ~
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
, Z2 ^8 S2 `8 _2 ]% pprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    7 y  h% n2 l- @) t9 n  h! n$ A
print(li), S* E; G; i' T7 y/ w# s
['alex', 'eric', 'rain', 'seven']# }9 M0 O$ ?" Z3 U! j7 a
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
7 L( ^! g% p2 ^7 a2 Kprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')( Q5 z1 E, }0 ?5 w- Z9 x* i
print(li)
& ?4 K( l# C  G- z2 k/ b# Re. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']4 j( ~2 x9 }) S" }6 ~
li.pop(1)) U* p1 h0 K  e+ n
print(li) ['alex', 'rain']
7 @( f- x5 e9 s: G9 n5 t/ r指名道姓的删除li = ['alex', 'eric', 'rain']
/ P4 E* Q' O$ @' w9 A9 oli.remove('alex')
  {  I4 x' _9 {2 p' i* Gprint(li)' m& i' C! m/ ]$ t  \2 L) _
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
5 k' [+ ~! p/ O7 dprint(li.pop(1))  R. c! t% T; v- X! j
print(li). y5 _* P6 W. W* ^
. N0 X- e: X" m
eric4 p* g  D! T1 D! U) N" E
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
# v5 Y7 y. a% |+ L9 Q: w: T  ydel li[1:]5 F$ B' n& U5 q/ @
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始): o/ c( `+ N+ d8 H+ U0 h/ x
li = ['alex', 'eric', 'rain']
/ o  [; V8 D) vfor k,v in enumerate(li,1):7 f5 |3 [' K- c% s' t' r
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]! A4 i8 L% v9 z8 R& H. R9 E* s/ ]
a. 请输出 “Kelly”
4 B$ K# b, H6 }0 a5 t3 ]) uli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ o; \( y  w3 b7 V7 s6 s7 Iprint(li[2][1][1])
! j9 q* ]  K$ {4 M3 E$ l7 Z% Tb. 请使用索引找到 'all' 元素并将其修改为 “ALL”, f. O+ p  L+ x) }; O6 ]* v4 m
li[2][2]='ALL'- B& P5 V( e" g; }* M. k
print(li)( a& P- q, |6 I  n/ a; }3 F9 b6 |5 f  k
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'), Q+ k: q- i# S
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')' X# t* _  D% x! Z  V( V% b) E
print(len(tu))
2 O3 z0 q8 N) f; p3 J, @  Ob. 获取元组的第 2 个元素，并输出/ J+ w8 ]" `- g4 n
print(tu[1])6 s5 ~6 `. Y# O0 k) T& N
e. 请使用 for、len、range 输出元组的索引4 i' J% f( T! D7 U
for i in range(len(tu)) :6 U$ B3 c: _# J& l6 {7 Q& B
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
9 E# x  H: f6 Gfor k,v in enumerate(tu,10) :# v6 C% R& j/ i' \# |
print(k,v)/ m) S+ v4 @8 D, [: ~8 f' x1 b- q# f+ t
10 alex
3 N4 ]0 J4 W7 L: H; h2 D0 Q11 eric
$ z7 p5 H1 L  J3 ?" I12 rain5 x' m: p: o- P2 A0 D; g

$ t: N" ~" }( N% _for k in enumerate(tu,10) :9 @  e8 H! [/ P/ O% l
print(k)  Z# n( [/ [- z* w/ d
(10, 'alex')
( v( r. ]' A1 D; ]  z+ C+ w(11, 'eric')
  m2 X5 l7 p" H/ F3 |(12, 'rain')7 @6 t' ?" ^! f* |2 D6 g
, v" i: ]) v) Q7 P  _1 I9 d

5 T3 ]- V3 W' w, U. u4 d( M25、有如下变量，请实现要求的功能
  V( ?  R+ s3 o. Q$ O# \tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

$ {$ l! P( L+ p* i4 U' p. L3 W# H" yd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
3 Q7 O; H' z% W' C5 V1 ~2 }tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])4 l, N: m9 U' L0 F+ D( o8 ^
res=tu[1][2]['k2'].append('seven')( L7 Z, r2 E* a: r; \

$ a7 I5 @4 B( g' U! {$ J* pprint(tu)( o1 E7 @8 ^) D1 N5 f2 P: k
26、字典& z; G3 T6 A0 L! d) d
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:$ M7 f" Y* l% M) O# [
print(i)b. 请循环输出所有的 value) C* g  ~0 M0 g2 ]: D' V
for i in dic:
" H7 \$ i$ u' P8 } print(dic)7 m' S8 H* O: o6 d1 y' f' [" C
c. 请循环输出所有的 key 和 valuefor i in dic:
3 u% T5 x0 J6 N  _1 F& x- j: dprint(i,dic)" A! ?  T# @# c
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典# G6 z2 M7 Z0 ^" d. O+ w9 T. y
dic['k4']='v4'
. {0 O9 N$ u, u0 A8 H0 f0 Jprint(dic)& F: e) {' X: _0 Z7 _
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 v" Z# X" L  d) d3 y5 W6 f$ vdic['k1']='alex'+ ^$ w) L! l6 J2 t5 M
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典' {1 Q9 o* f1 ^# E' X4 D$ _
dic['k3'].append(44)4 D( p. s: `( f1 a! H1 ^
print(dic)
, z- T' k0 Q  I' Y% C" V
* b) X# w& ~0 E0 Lg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
9 }6 x4 V( H% n5 t& U$ P( \6 Jdic['k3'].insert(0,44)
4 T) B1 O' v. l) {. y1 Bprint(dic)# j7 [0 h- V7 W
27、转换$ i# b. D: u; T9 Z' V
a. 将字符串 s = "alex" 转换成列表  s = "alex"
3 {* I# F( P. r  }; M- s) ]: |8 n9 _9 B$ \9 M: F8 j! ?
print(list(s))b. 将字符串 s = "alex" 转换成元祖
" x6 H1 y) p& D5 R( ^s = "alex"
2 U) L5 k1 k# K& Q" w; n6 ~print(tuple(s))
) }. T% e: p- u5 W
" k- _" b: _% j5 ^b. 将列表 li = ["alex", "seven"] 转换成元组' X: e8 Z, a! |1 s
li = ["alex", "seven"]
" t+ F2 @8 t* k- Z$ L9 Eprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
# a! Q. B! T/ ~  x% S3 Qtu = ('Alex', "seven")  X7 z7 E+ Z+ Q, Z
li=list(tu)
# z$ H. ~; l8 Xprint(li)0 L% x) p% \- K2 I, Q. w

+ U0 B# L+ u7 S: c' Q' N7 Q" r
0 W" C& e9 s+ e5 pd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
: d4 a0 U. l% P1 r* S# z! m0 c2 s0 Y% R% i6 F6 d+ N
dic={}& O/ H  N7 D9 A. C3 q' M
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
: L2 J; i" h, P dic[k]=v
+ f( W- O5 G6 ]* E6 j9 \. C print(dic)27、转码n = "老男孩") k& d. B9 |1 y6 X
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"+ s/ M' M: Z$ s( I
a=n.encode('utf-8')
  [2 o1 e2 U2 J+ z+ Vprint(a)$ G5 q: o" E$ X8 N) L& U# _, w
b=a.decode('utf-8')
  [  {7 g3 m% F( V% xprint(b)
& J5 G- c* r* fb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')" v7 G4 B: h4 @
print(a)
  a- ?& ~9 _1 P' q* p0 y% Cb=a.decode('gbk')' l0 h& ^7 V; I; }2 @2 M; n
print(b)28、求 1-100 内的所有数的和, g% e0 ~" c2 D; r5 N! J- P
count=18 G2 p7 S  g: I
sum=0
2 `; I2 ]1 g5 J' Afor i in range(100) :# p. y$ U% b- g  r8 l7 ?/ O% t
sum=sum+count
. a* [) Z% e* m/ P- D3 A# c/ p count+=1
2 p* b% i- p: v& r7 t- H% dprint(sum)! ^/ u$ ?, D6 P" ?- r
: O1 n4 i( v6 h6 O, B6 ^" r6 A- Y
count=1
! d1 k* L3 l: c: q  Gsum=0
' ]0 ?& R6 f( Rwhile count<=100 :
7 N( |6 \' o) J; A: k3 d& | sum+=count3 P: g( n( z* U4 i
count+=1
; H2 \: M+ n) \% o5 d3 Wprint(sum)29、元素分类
- U- l$ d2 }9 r0 T有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，& F' z4 u  ~, I* l5 o3 K$ ]
将小于 66 的值保存至第二个 key 的值中。& G' u; K6 l0 Q5 ?; F& [
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}6 {0 V0 y5 a1 i
li=[11,22,33,44,55,66,77,88,99,90], g1 s1 F% ^" M. k8 q
dic1={
( \6 k1 M7 b" O6 O 'max':[],7 g. |! p% F  k, O+ n5 g
'min':[]
2 r+ E5 e3 Y# K& O9 ^}
8 `; X" ~, D! R/ sfor i in li :
* V" k  u& G) v& b+ o; ~; c if i <66 :3 y0 }- @, A5 Z
      dic1['min'].append(i)
4 t' e0 C: ^; \' ~3 n9 M else:" o( }# p6 m* |! F
      dic1['max'].append(i)
2 }! w8 N. q/ O: }' hprint(dic1)& Z' b  I+ J- I  C% d7 R: n
8 Z+ `+ V( ?% C
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}' Y9 ]$ J; {7 E! |' n

Python基础知识汇总

主题推荐