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、写代码
7 a8 C$ [9 J* f( T' za.实现用户输入用户名和密码，当用户名为 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) :
8 c" P8 ^# G  u6 b- T' ] name = input('name:').strip()/ ?! ^' ]- p5 B
pwd = input('pwd：').strip()
: g: V/ n( `- Y  j, o# O' y8 f6 n/ [# S: ]
if name=='seven' and pwd=='123' :; n* a1 I  k+ [3 n
      print('ok')% G4 l/ J- m. T: C1 J7 b
else:
: J* R( g0 j& n  D       print('error')
# Z7 l6 j7 K8 G; E( M6 r7 \5 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)  :
. X" m% ^( a+ P) j2 m, w name = input('name: ')5 B  g+ {- n$ u: \0 @
pwd = input('pwd: ')
2 _: K" o! I  o if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':0 \# G( d/ y; g% P* b8 r3 Y5 Z6 Y' r
      print('ok'): M% S, K# }5 k/ M, \% D
else :
; @' V2 `1 }" q+ L3 G6 p       print('error')
2 C5 ^1 e) A  \       count+=111、写代码
4 |# }5 p; s; v$ u1 U( N# Pa. 使用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& J9 t7 d  l& `5 ?
if i %2 != 0 :5 }' B, X* T7 [3 I( C4 ?9 m- V
      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 o0 Z, |$ U. I" I' a if i %2 == 0:
- q# y# ?9 `- L- U9 ?; o/ q5 c$ |5 P       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"1 E1 \% b) v" A$ U
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)
3 L, r. S7 @) x7 `' k* Bfor i in name:. o$ C& D7 R2 A* C
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
) W0 Y; w$ b9 v0 v0 D- E22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']6 s2 q3 k) f. ~! ~- z* T, B
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    ' k9 p2 U; ^' [% a( O5 D
print(li): r/ ^/ w7 X  t+ A& r) w+ M% h
['alex', 'eric', 'rain', 'seven']
# f  y. h- P$ x5 `: Sc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')7 {& v, q3 o5 y* x& m* p! a
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
% q: \* P( k8 a6 h! R3 i& j, E" wprint(li); e2 G3 J  |# {0 B" i: _
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']$ l% O- E( ~# h
li.pop(1)
, J. n* x6 h5 D8 {) U* Y. `print(li) ['alex', 'rain']+ i7 {' l5 w3 y& Q; L& x: S
指名道姓的删除li = ['alex', 'eric', 'rain']- j+ L# Q# k8 }1 O" Q3 H
li.remove('alex')
1 ~: ]8 g% v% uprint(li)
6 B  t- G& f( e$ @f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
) h( L- M% C* C2 {8 X* `; d' L6 ~* }print(li.pop(1)): x! Z: y6 \# s7 ]8 m1 v
print(li)% y$ I. P+ t- R. |
1 K; y" Z3 O9 Q, j3 _. B" L
eric6 O& h1 F( h2 u9 B
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']4 R7 i* X' \6 _' }$ Z1 p3 ?
del li[1:]; q# \, `- }2 E0 t
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)1 Z. x/ O/ T; ?7 L
li = ['alex', 'eric', 'rain']
# g6 d3 \4 L  T6 a4 Jfor k,v in enumerate(li,1):6 U& A; {, I+ k5 p& S/ S0 R. k6 C0 M
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
( b+ z& R4 O: m, `: _5 ha. 请输出 “Kelly”1 Z2 _1 ?' r) x# \# L  v% X, A, \
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
( f: v6 T* \8 O7 g0 N6 P: P1 Qprint(li[2][1][1])
- h; h9 }2 W! N; W6 Fb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
6 G6 s. s- y* \1 B5 ~" R+ gli[2][2]='ALL'
, g7 q& \  u: r$ ]print(li)
: @. |  X& x' ?3 Y0 q, m24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')0 Q. T6 w2 y  p! r( k; X
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
* q2 i  Y9 l, S. C, Dprint(len(tu))
3 g0 F$ k( j  L7 y. s/ Z" Cb. 获取元组的第 2 个元素，并输出. E3 r# I+ r/ p
print(tu[1])
& V) O' ?! O  ?" O! ze. 请使用 for、len、range 输出元组的索引
: q+ Q+ N/ E6 b0 n' X+ Rfor i in range(len(tu)) :1 p+ N# s$ x1 ~- V
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)8 b- w2 A0 r) C0 x6 C1 `7 d6 a( [
for k,v in enumerate(tu,10) :
8 x1 }: k: c# ]3 U0 V4 W print(k,v)
% O. f3 k, ^; D  m" y0 a; @, s10 alex% ^  Z0 O+ t: ~; }8 Z0 \% h
11 eric
) w; Z$ l  H0 E3 t12 rain) v& N# S0 _* s0 _  Z( y3 l
! t9 W6 T2 l4 ~' \7 O
for k in enumerate(tu,10) :$ Y" d0 P( U0 H/ t: ]
print(k)3 w( B2 x. J% s9 W
(10, 'alex')/ H" \- s8 j  R1 R
(11, 'eric')5 ]+ l1 @* Y. r$ Q/ ?" n+ s
(12, 'rain')
2 Y7 L. x; c/ m6 G) N4 h4 @& U: E- u' }5 t3 X$ _, X
# A9 G. z  I, e$ u4 t  {! z7 |, E
25、有如下变量，请实现要求的功能! E( \4 Q. x" W: f$ d/ N& W( K
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

3 S3 w  b; h; C/ Id. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
  C' o" h1 _& M/ L* J8 rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])9 N3 |: p5 @. s" X  |$ Y- o3 K& c
res=tu[1][2]['k2'].append('seven')
3 q, R' {1 o! J# J9 e  L% M, l6 r' |
print(tu)
3 w6 P: \2 v4 ^3 Q6 c& p26、字典* g3 T! |' ]" E% ]
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:9 K( A& M2 q/ D" w' B6 v3 q1 v4 u
print(i)b. 请循环输出所有的 value" p% E! Z9 u6 K8 B0 S4 v1 B) h
for i in dic:
7 q2 M$ v5 _6 r0 B& D' i print(dic)
* R! ^7 |. p/ V* v. cc. 请循环输出所有的 key 和 valuefor i in dic:
0 Y# A+ c0 N& Z$ W7 o# D& qprint(i,dic)
) D  a% R# \8 Qd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典2 \* G3 y% ?/ s6 ^
dic['k4']='v4'& s0 D. R# l4 B& O& O" N# Y7 V
print(dic)7 _6 R* z' L1 J/ o
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
( W+ s  K* _+ }: k" }' }2 bdic['k1']='alex'" b% x7 s1 r* z* ^( ]
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典4 K4 }1 e" D  C" l7 G% q
dic['k3'].append(44)
$ R) o; _5 o+ ]4 l8 m8 ^print(dic)
4 [' c% f6 l2 x8 Z5 p) E( H' ~3 }0 D2 }
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典3 E5 G8 ?2 M/ N, L0 b- w0 B) A
dic['k3'].insert(0,44)
! a1 _: Y; |. P" T* zprint(dic)& `9 Y5 s* K% ?. C& o7 H
27、转换* c6 f( U, a# k& J
a. 将字符串 s = "alex" 转换成列表  s = "alex"
  |  U1 q, G/ q/ }0 @
, F0 E4 p& O) ?print(list(s))b. 将字符串 s = "alex" 转换成元祖+ N4 l! m  N3 e0 `" y1 Q# \
s = "alex"
7 k# K0 F6 f2 i" w1 ]* uprint(tuple(s))
2 U; ]/ m: W; a; `% ?; Z5 i, Q. y; M5 Y( B
b. 将列表 li = ["alex", "seven"] 转换成元组! S& D6 C8 f3 S, k0 d5 \
li = ["alex", "seven"]
3 I0 X+ ]( ~$ o3 V6 mprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
6 h) e9 D$ ^: \/ S# N8 \' |+ rtu = ('Alex', "seven")
3 G6 @$ _: S9 ?/ x' `8 |) g1 T- \li=list(tu)
1 g: h5 p/ P2 Iprint(li)! E4 W3 _& C7 r6 w8 O
/ k" s) T) q' [' D$ M
1 V" r6 B9 z! ?- N
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
, e. |& Z/ b/ E4 K: m5 `' G" R  e: s+ C9 g! L9 I- I
dic={}
: L: r1 B* l8 P: `# n7 Bfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
$ N9 K9 T, T! q3 ]5 i) z dic[k]=v
, I( n  n1 S) X# W print(dic)27、转码n = "老男孩"
% _% E) Z5 X- d  {1 n3 ya. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"1 v; l2 S# B) t* D9 ^# Q
a=n.encode('utf-8')
% k( E, D1 s# r6 T) K" Rprint(a)
8 \1 T& H( A4 _3 K9 Z5 o  }0 kb=a.decode('utf-8')
& s4 z/ g1 W8 y  Hprint(b)+ a6 D. T" [, q2 |& _! s" J2 [/ C
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'). D3 H6 e6 x  S  H  R7 j) U+ `
print(a), O: X! Q/ \- H9 C# a& `1 c& }
b=a.decode('gbk')
. X* ^: n9 c+ X1 f0 R, nprint(b)28、求 1-100 内的所有数的和
# j1 b; o1 M5 B: A. I& m/ tcount=14 d" [' ?$ M2 H  O, M8 u
sum=0
6 A, y, \2 s' z3 ofor i in range(100) :, Q( C! K, K, {
sum=sum+count" H2 d% g' b$ u8 n7 U1 _
count+=1
/ ]8 Y2 |7 s. [: A: ?, |- J2 Cprint(sum): o$ C7 m  W5 \

  W  a& D1 m# F/ [$ h+ ~7 I5 [count=1' T) I+ c5 r0 i
sum=0
# O" b: l3 q7 y# R  \while count<=100 :
: x& C2 Q* z* U/ j/ B6 B# ]. S sum+=count0 W6 n6 E4 Z8 @) [( a* s) t% a
count+=1
" R/ u$ y, e; R2 Y# i2 d5 `7 zprint(sum)29、元素分类) p4 _6 l/ P/ F' X3 O
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，# Q! g1 ?. H) y- h5 l; k# R( ]
将小于 66 的值保存至第二个 key 的值中。! M+ x4 ]* r8 M$ I9 U
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}! K& O* I4 y' K* c; R2 w5 w
li=[11,22,33,44,55,66,77,88,99,90]# ]& p, h+ N# Q) }
dic1={
& x0 T) Q; m/ h3 a9 C 'max':[],
/ G! w! ^% k# `) G 'min':[]% J' [8 R5 U8 l1 A
}
& {$ p$ Y7 a! V; U1 p$ l( ifor i in li :! |# v- Z! {; g& C! d
if i <66 :$ q) ^' L4 L4 L2 g3 b
      dic1['min'].append(i)
* u2 v) O- J9 s5 A* c) a else:
0 x+ \) G2 l# B7 q- H, \5 ?+ z       dic1['max'].append(i)9 S/ R3 A" Y& w! s2 B
print(dic1)
  [0 ?+ t% l8 Z) y0 G  p% ?8 ]7 O% Y1 N. @, G
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}/ j; f) n3 E  w& A. `: a

Python基础知识汇总

主题推荐