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、写代码! Q' S) m# V: H/ v* Q( F9 v/ ]
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) :
% a& \' ^  q5 E6 m name = input('name:').strip()
9 v$ O+ ?! g/ o pwd = input('pwd：').strip(); i( S9 r& A, X% H& z' C

% z0 d+ c4 `/ f5 n+ e if name=='seven' and pwd=='123' :; Q. _2 t% ~9 m6 W$ O/ }2 ~" s
      print('ok')
+ ^4 b* d7 m3 L else:
3 A: d; e: W& F% _5 [1 _       print('error')1 c/ C9 H6 x* G6 r/ s6 o
      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)  :. {. H  n/ _) s2 R- o9 w/ H
name = input('name: ')
& r3 ]# ^8 p9 L5 `; O0 Q' ^* d pwd = input('pwd: ')5 a: \' w' C" ~7 @5 g
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':( S8 V8 W7 I. p. Q* s+ ]& J8 k# A; ^, N* k
      print('ok')/ {$ x, E9 {6 E# i
else :: z5 D* _% q& z* F) D; e8 I. m1 f
      print('error')
: ~+ A- q7 f3 t, b. C+ p* r       count+=111、写代码: h% R$ c: ~0 c8 \2 ~
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) :
' ]% |) b! V" ]+ y. x2 } if i %2 != 0 :
2 o% e/ W4 ?1 e! X2 U3 B1 ^       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :% y; K% R5 u1 U; V- H
if i %2 == 0:
# O: f* k9 i7 n2 N       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"5 ~+ P  \+ x* [, T, Q
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)% X/ @5 S( O8 O  ]
for i in name:
/ I3 w4 `  O0 \& ^/ \3 X7 H* F print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain3 z2 S2 l) |( p% b! c+ i
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']) w1 K6 d" x8 \. F
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    ' s: g* x" K3 ~+ G6 I  P
print(li)$ T  m+ n+ W+ J8 c: G+ t/ z
['alex', 'eric', 'rain', 'seven']' `% [8 e7 b8 O8 T
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
2 i& O/ V6 \! v) {, ~1 i% \/ Oprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')/ M7 \/ w, e6 i3 F  c2 i
print(li)
' d; Y6 \" G& Ve. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
: u) r$ `4 X2 k( v; G* ?1 c, B) _8 I% Tli.pop(1)
7 `6 ]7 i* d! w! }! G& d+ z6 \+ Qprint(li) ['alex', 'rain']) Q. V: L6 b- ]
指名道姓的删除li = ['alex', 'eric', 'rain']
6 j. X' i  B$ S& j/ a$ |) Mli.remove('alex')) @' U' Y% w6 k0 c8 G# o7 l6 W0 }
print(li)
  \- X% B  B- W: x( ^* b* D' u% rf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
9 W) R) O' A7 [. B; Qprint(li.pop(1))
0 E# }" A4 ?! k1 _, r( \+ H4 n" kprint(li)$ S( I, l" `; q( Z* }2 C

3 G: v0 C' i! W- R% eeric
' r0 o. E! N* L2 }7 V1 w6 @' w; r['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
4 x% r/ V' R' U9 Tdel li[1:]+ z' j3 r3 x& h1 P
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
& a' ?% X) ^  |! B3 W4 {; ?li = ['alex', 'eric', 'rain']* a9 d  P# a2 C7 o8 x
for k,v in enumerate(li,1):
4 m4 V8 x/ ~  ]1 U! r5 _; h8 e0 @ print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]  d( g% m+ H* _7 w6 S
a. 请输出 “Kelly”: V5 [# x; c' ]0 t
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
2 M2 T) C1 J. n/ v' ^' y# S4 rprint(li[2][1][1])
6 R1 z2 s/ P9 T8 h8 B7 {b. 请使用索引找到 'all' 元素并将其修改为 “ALL”3 n3 ]1 W* ^: i3 M
li[2][2]='ALL'
0 X5 s2 R& v0 E/ Q0 ?: I( W1 Hprint(li)' P# r% |. x. Z, L1 Q) c
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')0 E5 p/ C: E9 V6 y" H
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
+ p$ v* J0 j7 Z0 j3 G+ Wprint(len(tu)). V/ z$ T) u( k5 o1 {" h( q
b. 获取元组的第 2 个元素，并输出
+ D! p! z& }( R% X8 P0 jprint(tu[1])5 k9 g9 b+ `3 C9 t, A
e. 请使用 for、len、range 输出元组的索引% M4 N: H( ~5 c) |
for i in range(len(tu)) :* }% [7 r0 l) R& h
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
% z3 f& P4 A) V( afor k,v in enumerate(tu,10) :) X: K, X1 P6 ^. r* y" q& c1 v3 u+ C
print(k,v)
5 Q4 D/ S! P( ?1 l4 R* B/ B10 alex6 B# K3 G( z0 P. M! F' D/ p1 t
11 eric1 D) v( ]" k/ f) c$ i8 }1 L
12 rain
1 }/ z0 u9 _6 h$ R
' D7 g+ w0 v- s0 M& ]2 x! g1 pfor k in enumerate(tu,10) :
% z! q, h, G: l: @$ J6 C9 R print(k)/ a6 j* Y; b, s. ^- ~
(10, 'alex')
' f: P1 s: q9 {- W0 u3 P$ i(11, 'eric')
, t7 c* G5 O- a! g- n$ U# w(12, 'rain')
) V" {: V. F) {& c% `1 _4 m
$ G; D( ]' Y9 T( \4 e3 k6 f6 Z
! l" f& g# Q, H25、有如下变量，请实现要求的功能! X8 o% m0 b4 K! ^/ J" h8 }
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

4 {2 r3 h! D8 D* M9 S7 I: vd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以7 \. o8 f* }( m: E
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])  x- }6 `! M- ~6 O. k
res=tu[1][2]['k2'].append('seven')+ Z4 D/ U' e: y9 \
: t1 r9 I% O  w8 d! N2 r, M/ ?
print(tu)5 k; ]7 G6 ~/ Q; H2 ^
26、字典8 V5 j+ M" l9 o1 O5 f
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
) G* M. _( g, R* L+ q/ |: ]" s5 B print(i)b. 请循环输出所有的 value
$ s; x* X. ~4 }1 \: sfor i in dic:
9 h2 R; G9 {+ F( D! ], S. L6 J, \ print(dic)
4 d  X+ e1 a8 l" l! m* ^1 xc. 请循环输出所有的 key 和 valuefor i in dic:: X  S3 H; n2 k/ ^, {0 t- h- i+ C
print(i,dic)
# s2 }  i7 B- V; Z+ c( B4 xd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典7 r3 e: |) z* t
dic['k4']='v4'+ Y' q/ a; k; b7 G4 }
print(dic)# }) l! L6 S, T- n
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典2 i( d" r/ o* G" b6 L# b7 D7 |
dic['k1']='alex'+ P. A* H9 V2 m5 P6 u/ B
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
3 s% Z/ C: b; Z( N5 ydic['k3'].append(44)
8 d3 U' R2 R4 O2 k5 L  H& }+ yprint(dic)3 L1 U5 F6 ^+ l7 V. ^2 c7 o- S' m( e

& S3 C& a7 t' e, s# \g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典3 F( Z( @5 ~1 C% Z# }$ n
dic['k3'].insert(0,44)
! G1 c4 y: t4 i1 Lprint(dic)
5 _- {  i9 z) w) V4 K27、转换/ q2 U& O; \% U- r" b
a. 将字符串 s = "alex" 转换成列表  s = "alex"! j  Z* t$ j, v  r5 ~# s, r: d' [

( b4 X5 W, D; Nprint(list(s))b. 将字符串 s = "alex" 转换成元祖
' H! W- D$ x* h5 O) i5 h" S& Ns = "alex"
* W9 r! W3 q5 s2 w" aprint(tuple(s))
/ g! l; N6 M+ U- l
( t/ a- `4 r8 W; J4 Y8 D  O: Nb. 将列表 li = ["alex", "seven"] 转换成元组% ]9 e4 r3 U2 T6 h, M
li = ["alex", "seven"]. g3 A7 X8 s4 {8 \* v8 j' f# v
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表% c6 ]) W5 u# B# T
tu = ('Alex', "seven")
" F$ o% e  r8 u9 s/ m: mli=list(tu)8 ]* p7 q" |" l  [/ s( P+ j, E
print(li); Z; z2 u6 n$ Q7 q- k% w/ j
0 T; [0 z* r+ S& E. {
' h! P  r- M$ x- g! x5 q3 \
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
0 g' `0 E; ?: p* a5 i3 R) A; w
$ \7 c5 T; G) p4 i( L, G, g& Xdic={}
7 C: z! v" z6 Z4 E3 C) Yfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面) G3 @4 k3 y- @( S+ ~$ ~; W. I9 R/ h$ p
dic[k]=v
1 W$ \5 F7 U2 y+ a+ [ print(dic)27、转码n = "老男孩": a4 G- b& d$ f1 x
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
% A* S5 F) ~$ M9 a, sa=n.encode('utf-8') / Z% ^5 I( [2 A3 x: T6 D
print(a)
9 d. B& d, }2 xb=a.decode('utf-8')
- r, u) k: \3 d# J7 Fprint(b)
" c' a$ m. B5 T- tb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
0 D2 c6 d  A. E8 ]# B7 |. Iprint(a)& N- w( X" x# ^% v: K2 R5 S
b=a.decode('gbk'); i/ ], O5 P) b) I0 J' o- T8 y
print(b)28、求 1-100 内的所有数的和0 V" {( s4 |$ M
count=1
6 X6 x+ [- o2 x) X0 v/ Q2 L. Zsum=03 F1 p' c$ ~% o; e/ f! l
for i in range(100) :9 I( q6 ]$ C; a" ~5 r
sum=sum+count
4 z6 r% Y, e1 _* O; [# M- Q count+=1
- R% K+ I, g2 w1 tprint(sum)
& v' g5 D- b+ \
+ U9 \8 B6 w, h& x, Ycount=1
3 O$ m, S/ M6 U' @! O; d4 Psum=0
) E+ o/ o" d3 p+ }$ h' k6 ?while count<=100 :
% ?$ r+ `$ j0 e2 ]" _& }$ ~4 a sum+=count
/ q' w) H! S1 g. Q7 S& X$ n count+=1
5 a3 F1 T' _! }( S) ]* Bprint(sum)29、元素分类, I; [% J% v/ c. f  `6 ?* P
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
% B* j2 G6 S! A5 m2 N3 y: i将小于 66 的值保存至第二个 key 的值中。4 d( g3 a. w% x9 c' {
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}3 I! [9 u5 X  [
li=[11,22,33,44,55,66,77,88,99,90]
- ^: H5 x) Q$ vdic1={" q+ Z$ z: z3 h0 m0 E" x7 K( I, Z
'max':[],+ M( R( i8 K1 w
'min':[]
* @0 {# U# X4 C5 J6 B+ ?}; q- j- z" \8 o* \" Y! T% t
for i in li :
( @2 i6 p. c' `7 j+ Q$ a5 L0 H& Q if i <66 :
6 a$ M0 d8 f5 r# }4 ]       dic1['min'].append(i)
1 P# Z- }# C8 m/ ~) G else:
  Q8 R% q  K8 S' j* s       dic1['max'].append(i)
4 K8 Y' J  j4 R2 O( tprint(dic1)
- J' R! ^6 L  p/ N$ k6 A) X1 c9 U+ Y3 w+ Q0 h4 z5 k! l
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
8 w0 V( B' v. q% |

Python基础知识汇总

主题推荐