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、写代码, g, S# `% m) w9 D
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) :
2 b# L' O+ w, o4 w' \$ ]$ C name = input('name:').strip()
+ D2 ?, i7 d  X$ ?' |) | pwd = input('pwd：').strip()
+ F* u: Q! D9 g2 p( h6 f5 U9 V! R
2 T- o# M; J* V) \# N5 J5 D' D if name=='seven' and pwd=='123' :
: ?$ q7 Q& h6 E, a       print('ok')
* `/ u% B7 b) B3 N. h2 I else:
. B: l* d, U# h       print('error')% i  |; T3 k; d; m% S+ }# b2 M
      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)  :
1 o, s5 b1 g) ~" x& } name = input('name: '), e. F- s; A( ~% |# U& D
pwd = input('pwd: ')
$ p: @7 r: S% W: Q: g9 i if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':! z$ V4 _3 S6 I
      print('ok')8 s0 `5 N% ~! d# x
else :& \$ u5 c( L1 V0 p1 \
      print('error')
+ ~' q* O6 m/ j       count+=111、写代码
" z: ?8 u9 |& F3 E, }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) :
% L$ o: D1 Q% G# M& I9 [1 b3 D if i %2 != 0 :, {# U/ X" }6 z  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) :
1 L2 N4 [' H! @  k( p, a if i %2 == 0:
0 ]) {4 o: m) n0 l; ^       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"
8 u* B2 J1 L  Y* A9 O: @6 ^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)# ^# t! N7 k. k0 C+ M7 ]% `% z
for i in name:4 y  e9 S; M0 e+ P
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain1 N- W! U6 r( I, w% R' {5 Z. ^
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']4 p3 }& `6 v0 R; b5 d5 v
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    1 r% l( j& g0 k3 }
print(li)
% {. x& x" t5 M1 Q' u- z ['alex', 'eric', 'rain', 'seven']+ J. |, q& E+ a, }. ]
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')8 d" }6 j3 y5 f2 E6 y, {% S
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
% s5 w3 A7 p+ k3 Z8 V* z5 J1 Dprint(li)# i5 C. ]' x! L6 \0 F8 J; Z/ D. {
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']1 d6 B% ^+ s( U+ g* m& b
li.pop(1)  [) J8 M4 R9 L1 e7 Z. U
print(li) ['alex', 'rain']
5 U* p& w( T5 U4 s' S5 u, ?指名道姓的删除li = ['alex', 'eric', 'rain'], K4 z! b" R! h5 F8 C9 Q1 i
li.remove('alex')
: P  S: l8 C- B8 o$ ]2 ?( Rprint(li)
- I# t7 Q  n$ B! w) of. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']& ]7 _) \4 @. v0 a( q. r- ]. k" S/ L* g
print(li.pop(1))
3 o9 {9 r' l/ q3 ~" Uprint(li)) i: `" k8 X, g9 b+ I3 Y. ~5 _
5 B: F+ y! A8 ~( h
eric3 Z# e% ^- n) X+ t) ^" [
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']8 H' r: A, ?7 I
del li[1:]
  d; Q; ?: z- T3 f/ z' c" qprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)- @3 f' c% j6 z1 p/ u! x
li = ['alex', 'eric', 'rain']
* q: |" ?( R' t. {: M, `8 mfor k,v in enumerate(li,1):
% t) M; `' N  R- D print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" z: j! c6 Q. Z1 [3 i9 Pa. 请输出 “Kelly”/ y) U5 u# V0 Y3 T- Y/ F6 H
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]0 Q( H* B$ Q* o) ?' I0 s, A
print(li[2][1][1])
! ^7 X( F) S( H: i# @b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
+ }, |6 d/ y! E' ili[2][2]='ALL'
+ p0 H$ e0 a0 R8 aprint(li)9 B6 L( V6 G$ h: Y
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
5 J9 A: t; r4 c+ `1 C/ W2 ?4 h, ua. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
: Y& j" H% ~, I; Aprint(len(tu))
* t  f) F( J. R" F: ?b. 获取元组的第 2 个元素，并输出
# X9 R2 k+ S( Oprint(tu[1])4 q5 D- C' ~$ f" O" O8 V
e. 请使用 for、len、range 输出元组的索引
: L5 o- i2 u/ |4 [, ]for i in range(len(tu)) :
! ?7 i( ?; F' Y) v. c print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
# @* K  |: R' G- h* kfor k,v in enumerate(tu,10) :
! B# z* Q% S8 `" D5 g, q print(k,v)
+ q2 K( H5 a" i( J10 alex
4 p; r& q3 r/ J  j! u& I% z11 eric) M1 s2 _- `, B: B
12 rain* A6 K1 a6 J2 @4 p

4 G) }# M/ l, J, s$ K" efor k in enumerate(tu,10) :4 u3 h$ h7 @3 q
print(k)( Y4 _, y8 B2 a& T. C
(10, 'alex')
$ c8 F- x, x7 N+ z1 c) Z( X: ]0 h8 v: N(11, 'eric')
. z/ ~/ m$ B' I; Z(12, 'rain')
* R( A6 H5 H  ^& j
  p6 b% o+ w, y8 c- }$ \9 k
2 Z% _7 p. a: [9 U; n25、有如下变量，请实现要求的功能! F1 I0 [. o  d. L; F
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
6 o! `6 K3 X1 g
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
3 M! t1 S" L: B0 j2 ~tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
) z* @" M8 r" n; L' Dres=tu[1][2]['k2'].append('seven')# R) d* J* y% u/ o9 D3 c

2 J8 H! `8 L+ a' ?+ bprint(tu)1 ^; c( @  p* T1 s3 G/ D/ x  y
26、字典! k9 e9 I$ r3 w( B) h2 d+ s* Q' `
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
& b/ `+ T/ n9 Q  m+ M+ z, R% ^7 ? print(i)b. 请循环输出所有的 value2 P. v  Q0 Y0 J) J
for i in dic:0 Y7 q+ ^6 {, ~2 p, O, a2 `' J2 W( c
print(dic)4 U- s1 R8 z; C. Z, a4 z- Q: E0 ~
c. 请循环输出所有的 key 和 valuefor i in dic:
7 _9 L# ]- P8 b  T$ hprint(i,dic)  t, }  w, j) e/ b
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
5 I3 j& A4 Z. b7 ]% z3 ?' Edic['k4']='v4'6 }4 S, f2 G" x5 j: ^
print(dic)
5 w: {! I0 D0 f1 |. g0 H; {# O: Z) _e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典! k& ?4 d9 J# ]* Y# t9 s2 _
dic['k1']='alex') q& x3 k# K1 g$ P# U6 k/ E
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
4 t; n! _7 W- n1 ~5 S+ _" vdic['k3'].append(44)
" d. G8 b2 R$ ~! a+ }. Qprint(dic)5 j; v" r0 y7 ~$ j# J! V

7 Z/ B/ Z, e4 s/ T5 B  ^7 b) f  `g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典  |, v$ r5 }! r- p- m
dic['k3'].insert(0,44)2 I" K8 S! U; t8 R5 u6 c
print(dic)  [" E( V6 \7 s; R2 V# b
27、转换1 q  [4 A3 y8 U% t$ b) ~) r. d# g
a. 将字符串 s = "alex" 转换成列表  s = "alex"( R9 L; Y* I0 F+ D/ t" G8 ~2 v% h
1 n' }# A4 s) R1 b8 A( O
print(list(s))b. 将字符串 s = "alex" 转换成元祖
  u  n3 e! F  c' z0 V  Zs = "alex"
* |% w4 F6 g3 h" f$ Z! m8 uprint(tuple(s))
6 a& V/ W. {- u1 P& z
/ X/ }/ e2 {& J) v5 a5 Tb. 将列表 li = ["alex", "seven"] 转换成元组! ]1 c9 h3 n; e" `4 J
li = ["alex", "seven"]
0 Q; m7 c* R* l: ?/ f' v& T& Hprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表% Z0 h5 O0 K+ }# {, @' e) h
tu = ('Alex', "seven")
. h; N; A' p/ k6 A: I- t+ Q3 qli=list(tu)
4 t1 z/ b$ o6 j4 a; V; Vprint(li), ~, s: ~2 P! `, ~) d3 ?

; Z  a: n% y5 Z# F- v7 t# u8 }3 H; A/ x! z. P% X  L# Z* C) L
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增! x2 T) J0 Y2 g% Q: F& c* d7 B
4 e6 f( g+ C' C3 ]0 V
dic={}" Q& Z" A! ^7 ^' D1 z& p3 m
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. D+ O( t1 [  F dic[k]=v4 l" \0 ~0 L% Z6 x2 T0 J
print(dic)27、转码n = "老男孩"9 n* N# F! b9 J# u, p! R( L
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
( D3 i. ~: R3 E8 h4 S  T, E) \! La=n.encode('utf-8')
) g, P' u/ N$ V" ]print(a); m1 S- t- s( L
b=a.decode('utf-8')+ f) R4 D  _% g, R, N
print(b)
" m3 F( {' I3 c2 N7 c7 Sb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
% Z) B5 g" p6 `  o& i7 U* E# Z- p7 jprint(a)
5 \# u  D+ R5 K$ g' S/ Xb=a.decode('gbk')
5 N- s0 e/ o, ?) a" Eprint(b)28、求 1-100 内的所有数的和6 M& C3 y* H9 F0 |" p- L
count=1# w& l/ C! {2 ?- g, H4 k; `6 |
sum=0. x: L2 F- C: {- R6 v
for i in range(100) :& j  u. N& o! y, E* d
sum=sum+count2 X3 F( a) X9 `( O# H, b( t# K7 @
count+=10 X7 [, I! c+ s) V/ }7 d7 J* q% m) |4 X
print(sum)
. \: m' _' N+ q" z  {* ^, w- l* y$ j: v! n2 J; F% D
count=13 t' j0 m+ {- D6 y
sum=06 e  d$ U* o/ O' y. g: n. o
while count<=100 :$ |8 i2 n1 U: k& O. x8 R
sum+=count
6 n8 f7 |! o" o4 V& ~- p count+=1- Q' ~" E0 D# K" ]* R
print(sum)29、元素分类2 R$ ^0 j# x1 R: A5 O+ A' m$ Q
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，8 j" d' z; {5 `4 C8 }% Y1 }: m
将小于 66 的值保存至第二个 key 的值中。1 H" u( Q( g- f( P% ?) S2 H
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}- w: Y! s  c% a  s9 ?
li=[11,22,33,44,55,66,77,88,99,90]& Y% f" A4 ^- J8 w: y3 ^$ m
dic1={$ }0 L/ Y, m& d5 e: }* z6 A) r2 d
'max':[],
! H8 \7 m# c) u! G) T2 R0 h1 _6 n5 A 'min':[]
: {. J" n9 p" d) D}
4 d$ d6 N: \4 z! x+ A- lfor i in li :
+ r+ i+ p) z. B" n3 h* q# F if i <66 :& A2 N+ z2 o5 C( {" z! A
      dic1['min'].append(i)
: L7 V/ |5 \% {. s5 j" O( |: H2 b' C else:
8 N" r  c& P# w, C       dic1['max'].append(i)$ L" t" t, b3 @6 X5 o) {; O" Q. N
print(dic1)  R3 X! G) `) t$ u* u9 v) Z

! S; F- h3 O2 f) O. F- ?---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}+ B! R- u: \1 |

Python基础知识汇总

主题推荐