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 z2 ?9 q, B3 d0 P* B
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) :
% f$ o  g2 c8 O" z name = input('name:').strip()
! M& M% W; I: V1 y, [ pwd = input('pwd：').strip()
0 h( J% i" _1 t: X1 l, \3 c4 a6 A
2 A% y: r% g1 o, S) N: L if name=='seven' and pwd=='123' :
1 y( C' z3 L0 V6 s8 ^4 O" E* X       print('ok')5 j6 S, _/ V* u, [/ p% W
else:0 L2 r* d, v& N7 j% H/ [$ t
      print('error')* |) n8 }- q0 s1 U/ n( [
      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)  :( k8 W+ H* Z$ d9 w6 d8 q  b
name = input('name: ')& d: v& H- \/ K/ M8 f
pwd = input('pwd: ')
2 O8 z9 R# _; b/ Z% Y# T3 v( I# s& ^ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
- T6 S% ~7 C% u% g. O, |) W  a       print('ok')# Q! u8 f" P  ]+ }( q
else :6 y0 _5 h2 g& y8 ?/ S' }
      print('error')  l. ?8 l2 Z  q, {& L5 b
      count+=111、写代码
- z" k7 X1 H# \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) :! O% \- w+ V: A- B: O7 l  T
if i %2 != 0 :) \/ d1 f) j! e- z" l
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
9 @0 ?* y9 ?5 Z* ~& e- @- N% l if i %2 == 0:
  m* n! u" i. W5 q/ ^       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"
" x$ `8 V5 Z+ I- wa. 移除 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)
; s! k2 V2 ]; j: A# ifor i in name:; E# g% y! Y% f  Q3 \
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain  B$ S9 O. J. m
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']# |+ G0 h, o+ D! q5 R: r4 v
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    4 r5 J$ s  A; \( x- Q
print(li)
: @5 _  k. y/ F3 _+ p+ j9 W) Y ['alex', 'eric', 'rain', 'seven']
1 {, m2 ]. M* [' B1 }' lc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')1 N7 F, J* [7 G  F8 L: g/ S
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')! _7 C* n2 b6 v+ Y) k
print(li)
# Q; j9 e) b6 H. U- K, d: X6 ce. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
- J' s/ @: s5 mli.pop(1)7 V! h0 E$ D1 y) m8 R, [2 X( w/ R
print(li) ['alex', 'rain']
! V4 l) H2 T" c7 z$ ~5 M4 D指名道姓的删除li = ['alex', 'eric', 'rain']
2 L9 M* A: q0 Z$ q) C9 `  X# Ali.remove('alex')
. c& ]- |4 E2 ~, X0 Gprint(li)  B7 ?$ ^( d( r: l: k
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
4 J2 x% T& K0 k: B7 p8 h/ t/ R( Nprint(li.pop(1))7 M. j: F9 ]. _& ^. ?2 S8 M6 o
print(li)* o6 B! a$ W- A! p# H5 O  H
6 M% Y& U4 |! j9 D% l3 i' B
eric
4 `, b% R) B; O- L% P['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
) ~7 e+ i: _! y: j, v% H% Z0 Y- adel li[1:]
+ _. B0 }4 ?  I2 kprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始), y4 n4 V1 N8 D2 J- H/ ~1 D& M
li = ['alex', 'eric', 'rain']7 S1 Z0 P# R/ i4 z2 \3 c% U' }
for k,v in enumerate(li,1):3 d$ `+ N1 l: `; N! ?
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]+ w) U2 P" T& o4 b6 k
a. 请输出 “Kelly”, \1 Z# C: m2 Y! J
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 M3 Y1 @9 X3 q0 @1 ]7 gprint(li[2][1][1])
; _8 h! I, x% G- xb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
, H+ i3 S% b; k5 P( j& ali[2][2]='ALL'
6 [( V, U: `  N$ L' e* Uprint(li)- `1 S- T; u1 H, r# u
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')6 C3 e0 l3 Q/ G
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')& g8 x1 I7 F# `8 C1 b
print(len(tu))
1 \$ x5 c5 s' _b. 获取元组的第 2 个元素，并输出: |' F2 v% N4 z8 m  ]
print(tu[1]). D- ?+ f- R+ g( ?* O+ h
e. 请使用 for、len、range 输出元组的索引
! u4 J2 g9 s1 w) Q, pfor i in range(len(tu)) :; W4 }3 d6 U, I0 ~8 T, y6 a
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
' U( d- t/ ]* z) |7 {( H- e4 ofor k,v in enumerate(tu,10) :
0 b! i: s& `) F2 x print(k,v)
2 D# I8 f% E$ [% @+ @" @10 alex# D- t0 n& M; Y
11 eric( \2 s6 u! e( }  g; k2 X2 a
12 rain! S: I& m" {: z" K# b9 B2 k
. d" z/ F1 |: I; R) w
for k in enumerate(tu,10) :3 \/ ^/ v; Q, V, g& x
print(k)+ r, ~, x$ Q2 p0 t
(10, 'alex')" y9 ]6 a9 T1 ]2 p
(11, 'eric')9 ~9 c, w+ A: m+ P
(12, 'rain')
. \1 [- x- M0 b+ I6 j- Q
2 d/ `0 |( h; W+ C+ a) L  t+ v) g
# _8 g" `/ p2 o3 |3 X  m0 A25、有如下变量，请实现要求的功能; i- t$ s/ n6 q: G: `# c
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
- G: O$ C+ ]  d" g8 j
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
6 ]1 T/ r, X6 Btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])4 O( j4 M2 X8 V
res=tu[1][2]['k2'].append('seven')
; }& Q' s8 V' S6 T/ D5 N1 d- E* o. t% I" W) x( O
print(tu)% p0 t5 I! g/ V$ P
26、字典
* N# ^7 c# G3 M, l. X, `dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:5 N  C7 a9 Y) }, s0 A2 K
print(i)b. 请循环输出所有的 value
- T' }4 I. K0 nfor i in dic:- y; a6 J6 V: J9 ]/ ]/ |: ]
print(dic)9 C6 |2 b. V. k8 R5 H- G) M
c. 请循环输出所有的 key 和 valuefor i in dic:
8 _6 o; R2 ^9 L; R/ Mprint(i,dic)
1 K, a) w3 @( T/ M$ o4 v4 D7 rd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典+ Y! `! ~2 O8 r) K4 `' e
dic['k4']='v4'" B5 U- g! m- Y
print(dic)
' u! Q) N; \' be. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典; C; `# S( |( }6 o
dic['k1']='alex'# N9 V% e# f- {5 L
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
- g3 n! K. L$ v* y+ ~( J4 @1 w- [dic['k3'].append(44)
# Z7 C; D7 e, C' sprint(dic)4 @6 z8 S7 c, d5 v# C+ y. F
$ b* h) B) E9 y( u
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
: `! @) n* w0 ~/ h: Mdic['k3'].insert(0,44)9 G; n" z$ R8 t: _
print(dic)! j1 d) D- G  A2 T3 k3 E0 b4 U1 y
27、转换
. W" R% k. c( e7 h$ k- _  j0 la. 将字符串 s = "alex" 转换成列表  s = "alex"
" i4 r5 h7 t$ b6 z
& m! p; J9 b/ I8 u; f8 ^print(list(s))b. 将字符串 s = "alex" 转换成元祖- v, H0 z4 F: u2 R
s = "alex"+ u# E; n5 s- Z8 h  J$ q4 X1 n2 R
print(tuple(s))- H/ B; H: N# p4 \. G$ R0 p9 w
+ w- o3 C0 v& ]$ C
b. 将列表 li = ["alex", "seven"] 转换成元组  K/ D2 P. L1 \: S
li = ["alex", "seven"]* V0 s  M2 {; V8 o
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
, F$ [# X6 T: Ltu = ('Alex', "seven"), o5 }5 W: C) c
li=list(tu)" n% c( x: T6 [
print(li). B6 L# g9 o& o
( l) ^. O) I7 ^/ w. A
) ~7 @9 L% U$ P/ O) z: a2 {5 L
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
- m7 p# u9 D  @1 k8 p$ R. J6 q- W/ R) h0 m) c. Z
dic={}6 P8 S3 o+ z" t# \, n
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
! p/ _4 p$ X# h. k dic[k]=v
9 {  U! s( h! C) x! h1 ~9 T5 H. R print(dic)27、转码n = "老男孩", Q" C( j! M0 W
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
" ?0 U) Y: h; P, U' w5 pa=n.encode('utf-8')
9 r2 K6 [$ @! W4 Mprint(a)
2 K! S2 C/ x+ P2 yb=a.decode('utf-8')6 x4 |0 M( ?4 p
print(b)0 D- t' V4 s9 W( A9 Y
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
  h) `8 |6 a, ?print(a)9 e4 c2 w, i2 M# p( ]! Q8 t5 l
b=a.decode('gbk')
8 U" c4 m. `4 hprint(b)28、求 1-100 内的所有数的和
& ~3 A8 p) A" q% c; ocount=1
# A6 b8 s) y6 J) A% ^sum=0
7 n4 g5 ~$ V- h( [3 }& Nfor i in range(100) :4 w4 ^% H( G8 J3 H
sum=sum+count: ^/ R# H' U! h7 T, q1 g
count+=1
% d, k, A- w  O0 O5 G5 c" bprint(sum)- {+ e: y% n% O8 }1 v

, a9 d, a4 L$ ]6 _- v4 ?count=17 I3 x; c: h* q- o4 E8 H: a6 B
sum=0
& H# p8 `; T, ^* u9 I' nwhile count<=100 :% t! d0 s* `' w' n) h* u
sum+=count( D" C9 q3 d5 P3 R* q
count+=1" G. Y; H1 _, H  A
print(sum)29、元素分类  m1 ]' V: B- ?/ g1 Y
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
& P" K# L3 @8 T" u! P将小于 66 的值保存至第二个 key 的值中。' u7 a' A. ]0 m7 ?1 |; N. n. r
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
; r9 K5 n0 w/ M- nli=[11,22,33,44,55,66,77,88,99,90], q" N$ ?9 r0 d; X% S  G9 j( V
dic1={
: e4 \. f! d# z+ H% H& V, ]9 h 'max':[],
9 m1 R8 D( Q7 W+ Y7 i5 L* c 'min':[]
( G( V0 T" J, {2 }* ]3 ^( a0 [9 R}0 G, w, G  q, f5 ]: m$ {7 e
for i in li :
5 Y* x# D0 Z: Z, n1 ? if i <66 :
* [5 {. d0 M3 {: \# B! b       dic1['min'].append(i)
else:
+ v$ d+ [: W/ A9 p: x       dic1['max'].append(i)3 N- ^4 W$ w; a4 U! x
print(dic1)* T( D; M- y! I% Y- W0 _) V6 ?, c
% h2 L( ~/ ]( Y  T) u
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}4 z( P$ A9 H2 V: x4 {* G

Python基础知识汇总

主题推荐