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、写代码1 `! Y5 I! L/ q* G" [# G3 }4 w
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) :$ |7 l- ^# T, B* p' m
name = input('name:').strip(): C  A- Z: N# U7 ?1 s% B
pwd = input('pwd：').strip()6 F2 b1 T9 f3 T5 [$ T

! w2 |8 b/ L+ @- x" V if name=='seven' and pwd=='123' :3 `. h9 {/ Y. E9 I$ P
      print('ok')
. M0 H$ w* A6 {5 p) Z3 }4 J4 y: i else:
" ~! L- h. G' j5 ~% h% u" ?       print('error')* b2 R7 Z3 _1 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)  :, u; P/ U- B$ L- ~# N3 ~
name = input('name: ')
& m+ L5 w* _; f/ h pwd = input('pwd: ')
: S) E, W+ M" Y: a+ Z, p if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
' ~+ M/ d5 v5 \       print('ok')5 \1 q6 x: H4 N( ^
else :3 f2 `5 g, ^# F; t/ x* W
      print('error')
7 }# Q9 z8 r- ^       count+=111、写代码  n; P  _, v2 T3 |
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) :
/ K# a/ q" m* _7 p, s& T" j% H+ q4 a if i %2 != 0 :& q2 V2 c& _' ]+ x* s1 e; N6 {8 @
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :8 j; ^7 ~; ~5 j! Q, e2 G& S7 I( L
if i %2 == 0:: \4 y: C, @$ z4 V/ L+ z4 A
      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"
. D5 l5 f0 E% C0 N8 i8 }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)( y2 i  L& J" q8 X- d
for i in name:
4 u. O9 c9 f' J, ^. Y1 l3 ? print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
' P% B1 ~* |; q; W% S/ E22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']. p+ d$ D6 E( q2 ?$ b2 ?+ ?
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    ! O- e) T  R+ R3 ]. q- y" S
print(li)2 u1 I; D* f& T1 _+ i; T
['alex', 'eric', 'rain', 'seven']
+ M: R0 e, k/ [9 p1 k& ac. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
! J3 |# d3 F$ c+ R2 ?print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')7 l- f0 E* W/ M9 J
print(li)
! f; ^6 g) Z6 I6 e0 u8 n# t& n. ~e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
7 z( m" O* [0 B, Wli.pop(1)
4 e* E9 f+ y  w$ Y1 p( X8 gprint(li) ['alex', 'rain']
# @0 g4 ^: |! e7 z' g. g指名道姓的删除li = ['alex', 'eric', 'rain']. Z+ O, j. w+ n! h+ G% {4 D
li.remove('alex')
7 K7 p: ?  s+ g4 |/ T$ U) Qprint(li)
7 a, r- k" ]; ?* b: ^- ef. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']0 M! R. z( k; @4 X
print(li.pop(1))
6 j( U5 T7 A9 N7 D1 Y8 k, kprint(li)' I# @! O! X' v9 V3 v5 C6 p1 r
) o2 ?$ Q6 ?& S9 \
eric3 H5 K& D% h1 m
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']) B* w% S- @5 y2 }6 l7 a' s
del li[1:]
1 c8 [- g* q" G. Zprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)5 }% B: n& S$ a. F5 R5 V9 r
li = ['alex', 'eric', 'rain']+ N+ L' R5 R3 _% S6 h# H
for k,v in enumerate(li,1):
& R3 [' z+ X( R print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 ]' @. H0 c5 F8 S6 H- V
a. 请输出 “Kelly”
7 M+ e  e' S( L" Zli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]$ r8 |+ Q; E3 I4 g1 z5 ]
print(li[2][1][1])
# }2 H! F1 }" q6 Db. 请使用索引找到 'all' 元素并将其修改为 “ALL”
( m6 M3 y! M; zli[2][2]='ALL'
/ [. m& P6 w! I2 Fprint(li)
+ w& _, l! y' ]' P$ F7 u24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
; ]0 I9 ?& F; ]8 D  m+ Fa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')3 J' l. A( M: n$ w' m" J
print(len(tu))
+ m% w- D8 k; ^: p7 C4 m2 @0 Db. 获取元组的第 2 个元素，并输出
: N  \, _$ J1 E* ?. Q6 Uprint(tu[1])
6 }+ \) k- h: B2 E2 \9 Q+ Me. 请使用 for、len、range 输出元组的索引  ?6 r; q8 X& S( [9 k
for i in range(len(tu)) :
! y5 ?1 M6 }2 p$ j3 D( o$ @ print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)7 Q; D3 ~8 e) }
for k,v in enumerate(tu,10) :9 j0 _6 s3 B% @$ P6 w+ A; h2 E
print(k,v)' g1 ]# A6 E% _
10 alex
2 ^7 L, b' W3 M3 L& {' \' d/ P7 X11 eric* `4 @6 w3 H: Q: K2 W4 P
12 rain
$ G* q( T( ?9 u6 e; I3 j# i
/ ~* i0 y/ J$ g" Sfor k in enumerate(tu,10) :3 O7 G' D4 i  j4 h9 S
print(k)
% J$ N) e9 s; W) I6 U(10, 'alex')( Z/ y! w0 v6 e
(11, 'eric')
6 C0 e  y, a& S! h) `7 b(12, 'rain')
2 p, x2 }* D% N! E' h; Q
) l$ c* l% u: c4 W
1 y  @: Z! j& p' y+ Q5 U7 a25、有如下变量，请实现要求的功能4 ?- m( f# g) v) C* r
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
) E+ T; E9 \" {6 P( P6 B& v. q5 S  k( W4 [
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
# B9 R0 v/ |& V, Itu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])1 u7 \5 {9 S8 G' z
res=tu[1][2]['k2'].append('seven')% g, q5 z: Z7 e' r5 |

. T0 B4 Q: a3 j0 Y, Mprint(tu)% l1 j/ n5 I" f) J
26、字典9 W) G, V0 H3 b9 K
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:9 Y3 y$ e+ w% y. O2 F: y
print(i)b. 请循环输出所有的 value7 w2 O; F* I/ k* ^2 s8 B
for i in dic:
! W3 |7 c8 ]- ^- S6 { print(dic)7 s  P3 {, H# W/ n+ C6 C# w2 O
c. 请循环输出所有的 key 和 valuefor i in dic:
% b; l3 l: f3 r# ]' \% f5 V; Bprint(i,dic)
. }. n6 }: p; ud. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典/ Z( W$ D1 H' Q+ J( C. @
dic['k4']='v4'
6 P" b3 i2 N7 w% C/ ^; B; |print(dic)
6 n- s7 Y2 X* w6 d" T0 He. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典0 D! |5 [% x2 h! [
dic['k1']='alex'
* X+ h- v7 j7 A8 r8 C# Tprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
& e& m2 {" N4 r& L) j' q+ F5 m& R% hdic['k3'].append(44)! A. f. w! s; t8 z: n: e
print(dic)
& `# O0 K- G! u2 j/ q1 \# |* z$ b. \" s& ?
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
% G; a7 _  j& E2 F, o- J% U2 v# wdic['k3'].insert(0,44)+ m1 ?4 ?0 Z/ R: ?
print(dic)) I9 L8 I/ ]. z# z" c4 U
27、转换
2 _" ^) ~! ?0 Qa. 将字符串 s = "alex" 转换成列表  s = "alex"
" h; H# x/ }# w8 C3 F( a
! l5 K9 X7 _1 Tprint(list(s))b. 将字符串 s = "alex" 转换成元祖
& C7 k' j+ ~( A3 |1 x( ls = "alex") x( c- a% z9 M* m8 C0 k; m, M
print(tuple(s))5 J8 o$ Y: r* c" D
( v3 D) u+ k! D# |: Y! k: M
b. 将列表 li = ["alex", "seven"] 转换成元组! P2 ~- M  A' J  C% f
li = ["alex", "seven"]/ ~. N( y, g# c
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表6 r9 }8 Y% L! P6 P, X
tu = ('Alex', "seven")5 \9 O: N' ?8 z( P& j% T9 V
li=list(tu)
. _" x* m7 m; R# H1 Mprint(li)+ @, ^& c* M/ x' H
) e- T; w6 S9 }
# R+ Q2 c1 i% @0 }
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
# t# B# b: V# c: V  ?! H4 H9 \% |/ d1 v) m7 P6 i7 Q& {
dic={}: @% ?, [  j& i6 y) f9 h, \
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面9 Z) \9 S; a# \8 l7 V4 ?, j
dic[k]=v* B6 j( G% }4 F) V6 c7 r
print(dic)27、转码n = "老男孩"- X3 @6 l' _- h- t" F
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"; z, y2 D8 v2 `/ C! r9 U! V
a=n.encode('utf-8')
) D9 t8 \& B4 Y; u( hprint(a), D3 O* @) i0 a$ E
b=a.decode('utf-8')
) _7 {; b- ?4 K: Lprint(b), R3 W. x8 B: N. c- p- g
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')2 B/ w( \& [! t# ?1 {* P4 X+ T
print(a)
* p6 h6 F: r8 n! U& s* T# c! S: cb=a.decode('gbk')
5 @& X! R" d9 O( f! L- r$ \' Rprint(b)28、求 1-100 内的所有数的和$ A/ [8 x; T; K% U0 |1 o* h
count=1. z$ _( B. q& ?) k' G. r
sum=0; C+ K2 @3 y6 Z' E: o- M! Q/ Y
for i in range(100) :
$ O, g* P2 K/ h$ M5 e0 @ sum=sum+count
5 b1 `' S0 p! s! N count+=1
! H% [2 F9 k% L& o* _print(sum)
$ C- J* w# {6 p  @; S% ]8 e- z/ g; V) j0 t) r" K5 Z
count=16 W3 V: H* R3 m
sum=0* d& N( _( l7 m1 ]
while count<=100 :/ u2 o1 @' z$ b% x- p
sum+=count7 }- Q: p9 q  H& {; \
count+=1# m5 X' Y6 `) P
print(sum)29、元素分类
7 J* D; _( S! j有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，" R# h0 T5 k; B+ W' S
将小于 66 的值保存至第二个 key 的值中。+ u4 D% H# k! a2 j9 v. B7 l) r
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
( I$ G% D' g6 b. t$ x' i) bli=[11,22,33,44,55,66,77,88,99,90]
% _5 Q) [2 Z% r; ~# t& qdic1={
$ _0 ^2 b: n8 e 'max':[],
) o4 ]5 V7 j" R5 s5 n 'min':[]' k4 J0 }9 s& g
}) _/ y( d) c7 `& @
for i in li :
if i <66 :
6 y. P% p; C# v0 h4 `  E6 k       dic1['min'].append(i)- q8 J' O9 D; o
else:1 [2 z+ e; z3 u6 B
      dic1['max'].append(i)( C0 d0 z- t( r" `9 x, K
print(dic1)
" A& e1 b% R. L
: x) t1 r* _! J2 V---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
. }5 @  v1 J  a; N

Python基础知识汇总

主题推荐