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、写代码
# _% I/ D. z0 y/ |! Ma.实现用户输入用户名和密码，当用户名为 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) :2 V% y/ \$ P0 K2 `' g- g% I7 D! T
name = input('name:').strip()3 b" n. p5 `0 C3 g# j7 ]7 x& K* e
pwd = input('pwd：').strip()! {  ^9 G1 {% Q7 b& _

, p0 _9 ?. r/ u5 e if name=='seven' and pwd=='123' :3 r4 A0 o, g1 M. T  M
      print('ok')
6 R+ z, |1 v" |8 I  e8 d else:+ E# D% @2 `! j% |, N$ S
      print('error')' U0 c/ l# b: Z4 X+ Y. M- B4 _0 ]
      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)  :
' F* y* W; L/ Z! R5 q name = input('name: ')# F8 H. i& C0 |5 j; ?% ~
pwd = input('pwd: ')5 ?7 K$ @. ^+ I& a0 f7 }2 n0 I# F
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':+ s! a0 P* x' F& R$ a, m
      print('ok')  E1 h% a3 x5 l. Q, Q; F0 M
else :
( H: Z4 r* E+ b+ D5 _- s       print('error')
) m+ _' y+ ^# S5 ~6 ^2 i! E+ G       count+=111、写代码; T2 @2 }2 o+ d
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) :
; X9 P. s; ~) W; j, j5 A if i %2 != 0 :
2 F4 M$ F2 x! Y+ V. r       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
+ F1 T6 `2 m  e( a, n  E if i %2 == 0:
0 W+ h* M9 X+ }2 X       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"& n1 [/ S1 A. N& D  k( D$ _
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)
5 W" z- B' a' @- B3 a7 C) dfor i in name:( `& Q6 F" |* s) o3 @$ L( ?! P2 W
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain5 u! b0 p# i! M) L5 t
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']) L! R% v/ f, V. P" f
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
$ n% t$ x+ \8 Gprint(li)
* p6 p% w" ?& \. E7 B ['alex', 'eric', 'rain', 'seven']+ _% l' G/ u6 q2 ?
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'): c; P6 m9 F1 x$ c4 N" y
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')0 ]) \8 W" y3 `$ A0 Y, ?! N  H. b
print(li); w0 g( u9 S6 z6 n" O8 m1 g
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
" S9 L- U" T, K0 ?& {8 _" t% nli.pop(1)
7 }) H8 L% ?! [# \: Y9 D. nprint(li) ['alex', 'rain']4 T8 K1 `5 f- c
指名道姓的删除li = ['alex', 'eric', 'rain']4 b9 ?  E$ U5 L  C# y6 `$ T
li.remove('alex')4 ]3 o7 t# q$ [" [5 K* ?6 N
print(li)
: \$ ]3 j1 x" F( mf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
$ M1 a$ k( j% T1 K* e% Yprint(li.pop(1))
# u  V4 R. G/ `: |0 H6 Eprint(li)
9 C# r' I& z, f: \% z5 n3 [
, q' Y( h, y6 S+ x$ f, n- Feric  p, o$ j1 ^* X. E( r
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']  d/ w. W: _1 l; h; G8 [! n/ @
del li[1:]% v7 s& k- G" z) b
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)# W; T  Y) ?+ @
li = ['alex', 'eric', 'rain']
0 F% H  B. \& C, Pfor k,v in enumerate(li,1):9 k' V- C2 v. S6 q
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ c* c( n+ i% C* f" a" c$ Ja. 请输出 “Kelly”+ t. n8 G; @% X4 {2 |
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]/ S1 I' I0 _6 V! m  ?( D, g
print(li[2][1][1])
. g. @5 |8 u+ H5 q6 C& C& N; wb. 请使用索引找到 'all' 元素并将其修改为 “ALL”; A7 p0 z# C7 e/ I" s$ N
li[2][2]='ALL'# c( A) M$ |6 {/ H$ @" U
print(li)
2 z; Z' \/ |- `2 _/ o24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
* p! g( t! b' \8 W% f8 u$ ma. 计算元组长度并输出tu = ('alex', 'eric', 'rain')( a1 L( X; K, M. R0 ]& S- ~+ S
print(len(tu))
( x+ ]& }$ z* R8 b4 ]2 O" l+ ~( nb. 获取元组的第 2 个元素，并输出
8 P7 S# R4 U9 j! Q; cprint(tu[1]); j0 j6 ?! E1 C9 J. u5 a* q
e. 请使用 for、len、range 输出元组的索引* t: w9 |+ e4 O+ G" N6 A
for i in range(len(tu)) :
: I& B' x- R  _, [4 }; K4 J print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)7 u! k2 F6 A& X7 r
for k,v in enumerate(tu,10) :
4 ?  Q0 f4 R& {& W print(k,v)4 d  p$ I" g3 b
10 alex
7 K" x. _! C. Y11 eric
5 `! ^2 X# d+ E3 a12 rain
% j/ H* r/ c; F+ }  Y6 p
! d4 z- @2 P5 q; i! ]$ R5 yfor k in enumerate(tu,10) :2 W: v$ a1 ~, u3 S
print(k)
1 [+ K/ ]2 X. v(10, 'alex')
7 V  a/ c- p( `4 o  O# n) _* |(11, 'eric')  [0 @$ @6 s5 x, N7 D7 A: d+ j
(12, 'rain')$ \( P. e! l8 B5 _3 @5 B& Q& K

$ m" X4 m0 ~9 S) K- ~& m+ H9 A2 \5 b4 e( |# |
25、有如下变量，请实现要求的功能3 `6 r$ k" y2 i
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
) t/ w7 Q* c/ @  m9 N% O2 o& ]
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以6 T. _/ G/ Z$ L* J! E
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])9 o6 b; U1 j  Z  E% c
res=tu[1][2]['k2'].append('seven')" G6 ]4 I; t1 ?: A
8 ^/ X7 m5 v  w8 r
print(tu); P  _9 ^8 T& v; d* ?7 b
26、字典; Q( X, w6 E6 m1 J3 ?
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:$ E9 p7 w7 D0 f4 |+ o$ r) d  \
print(i)b. 请循环输出所有的 value
" ]; X- C- Z4 ffor i in dic:
; I7 k  V. U; C. F* X9 g; N print(dic)% x4 ]7 j) Y* j2 B7 q
c. 请循环输出所有的 key 和 valuefor i in dic:
! y" d0 ~  O+ G1 Q7 n+ W2 Mprint(i,dic)
- m  b0 o- g3 Xd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典4 e( a, N, i  Y' J& ^
dic['k4']='v4'
- ^2 |* i3 v% `2 B, qprint(dic)
0 Q: ]0 ?6 w* Q; {9 k8 {e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
! u6 V! z7 @$ [* ]dic['k1']='alex'
: A3 G( y% q7 }9 W% h4 Z9 e- o% aprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
# ^9 K/ j) _6 i0 Jdic['k3'].append(44)
1 T& n* D+ e% n  l2 R# zprint(dic)
: l! R3 c; E( [! x! L
+ w( A* v1 U* ^0 ?6 s$ l! L8 Cg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
& I1 N% ?3 S# _dic['k3'].insert(0,44)
3 S0 X8 ^. ?5 r% H; q4 q" I+ y, vprint(dic)
$ J2 v9 D% I0 v4 r27、转换
1 R7 Y$ v2 a9 A! b( R7 H* ya. 将字符串 s = "alex" 转换成列表  s = "alex"$ `8 ~, m! J. q- @% s

0 N/ ?5 V) F& O+ V  Tprint(list(s))b. 将字符串 s = "alex" 转换成元祖
3 y0 N% K/ l* w0 X* p& g' Z1 Ms = "alex"' G6 o; I3 E" d! |' J6 k) u
print(tuple(s))
; R" ?/ x# x% z( p2 z
# x" K( c" D7 eb. 将列表 li = ["alex", "seven"] 转换成元组
  Y; g. X  F& @: Gli = ["alex", "seven"]
! A' }- [4 V* x+ Hprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
- `% N- G( \6 t, Atu = ('Alex', "seven")1 p% n; J& n3 V) F6 {" e" S' U2 @
li=list(tu); n2 F  q: D% `+ k: F! I, `: h) w4 g& u
print(li). Z9 i( X+ C  z4 ~; n: |+ O
/ ?, X. i3 x# x& U! ?2 \+ ]4 V

/ v2 o; J3 f. e3 p; [# b( U) @" zd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增* ]& I6 X0 K5 o3 S& C3 _* N9 T* {
$ o. H) }8 ~' a4 d4 Y7 V% Q
dic={}
" G  N/ E1 A/ e# l. p9 \for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
# ?+ Y, A8 d  X- Y! F: D% N dic[k]=v- S5 i" y3 S3 J7 `/ [
print(dic)27、转码n = "老男孩"5 j9 T# M1 R* C3 R6 e$ B% a0 K5 `
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩") i$ J) m4 R: c$ I7 `# O! b" {
a=n.encode('utf-8') ( o  X% v1 e3 T* t$ C5 w: G, b: G
print(a)
7 ]0 s. ^6 P, a' S+ E# ub=a.decode('utf-8')
' M1 s7 T0 h9 p$ b: _print(b)) o7 ]* ?% Y. c& C* }
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')& f, h6 S7 x0 Y( `& E
print(a)/ p2 M! Q' t/ a  |1 H
b=a.decode('gbk')
3 T1 Z  ^( {& m6 B  m1 b0 H. @print(b)28、求 1-100 内的所有数的和; W" b  B/ G4 N  I9 [2 b, n
count=10 `+ W2 p6 O8 B8 E9 K4 a+ K- l2 ?
sum=0" t( K4 F" C) y! X
for i in range(100) :. f: w7 o( U0 T( |: U
sum=sum+count# [, x+ b# z8 Y5 w+ K
count+=1, j' ^  l5 J9 d  C4 C+ C
print(sum); h8 |( u" U# V

# [; h* R' o( |7 N8 d( K4 m1 T* Gcount=1
' ~  s* [4 v9 T! R# g8 F, Jsum=0
) z/ F# J5 k) i$ P* q& Fwhile count<=100 :
) U; M' T2 p& t, ^( h+ I0 g7 E1 }/ T sum+=count
2 U+ h  b: Q; V" c. {6 L9 H1 W- ]& m count+=14 R+ C5 o% p- C. |8 K! S
print(sum)29、元素分类
! B6 A' i2 j) d* c9 ~, K有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，7 C+ A: h/ x! n- p7 q
将小于 66 的值保存至第二个 key 的值中。# F: O/ b( R3 r) [' |3 Y, B
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
; l3 ^4 y/ b. A: b% D( Kli=[11,22,33,44,55,66,77,88,99,90]& m3 [" K, ~6 E+ P
dic1={8 z2 k# I1 t5 ]( L6 P6 i
'max':[]," x& T( E1 P/ h3 E
'min':[]% X9 |: \6 U# {7 `. a5 V5 S: S
}7 b$ Q. u- T8 o$ l& X8 w- k
for i in li :
) z7 M* `8 b, q: r9 ~ if i <66 :' q4 `* a. I, \7 R; t4 M
      dic1['min'].append(i)  k4 \! {- `9 a
else:5 c" P: X( ]4 i$ A
      dic1['max'].append(i)
0 D/ u  R; z" Y# T( O; Z3 h" e, ^: Rprint(dic1). K. k% i4 T( x7 q1 p7 L" V

" [, v8 V( n! m+ C: u---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
' h9 T2 x# |; x- m1 K2 L

Python基础知识汇总

主题推荐