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、写代码
0 y; b9 l- V$ U8 @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) :5 J. Q9 P: c5 A+ {- e2 B/ W
name = input('name:').strip()
# i2 m' m0 H3 T; `* K0 E; O3 k pwd = input('pwd：').strip()
- A# [9 O) X$ C4 m" `( g. Y0 O& j( e- u! V. B: C
if name=='seven' and pwd=='123' :! V& _& \9 B! s( \6 }: C! P
      print('ok')7 R8 Y8 t1 B# m! o7 U! T
else:
; t8 O/ J+ x* v! h  s7 i       print('error')* F8 F. k0 x$ D& [! r
      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)  :
/ e# u& n/ E8 z0 | name = input('name: ')3 ]9 K+ d- @; F; ~6 N
pwd = input('pwd: ')
5 W1 ?: ?2 g" Z( q if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
8 z5 W* j( S7 K3 A$ Q5 u! }5 S       print('ok')
9 O+ v0 Y! }  ]& L) S6 R" ~0 v else :; V  d7 G* V6 A6 a
      print('error')! g1 E4 v2 u3 Z6 W# \% C
      count+=111、写代码6 U& {7 s8 `% D6 S/ ]) \1 M& p' H6 V
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) :1 s$ F# ^5 s4 v
if i %2 != 0 :2 D5 ]& ^% a$ ^# m
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
* i+ U5 g& [6 W# n  n if i %2 == 0:
2 f- u+ [# \% X+ M+ |0 D       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 r6 h( l0 h7 b8 w6 g) pa. 移除 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 d) u9 w* D+ Q6 z- V: n7 U4 c
for i in name:% C* i* k. _. D) `# B# ?
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain! i# V+ u; f  Z( {0 U+ B) E
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']: p" C3 b$ f7 h9 V( ?
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    5 p' ]  ~6 U) O2 ~7 J
print(li)& ~# }+ I8 I$ z/ e  C
['alex', 'eric', 'rain', 'seven']
; K7 m7 G& y7 Fc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
3 J) f3 F2 p+ J% Fprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')4 G  a( v4 X7 D8 \  l
print(li), f- {& z( {3 I8 q+ ?/ _! i  ]
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']) s6 _' F) U5 c# U* r7 r0 U
li.pop(1), c' h7 r) r9 ~- r0 [2 o) e9 U1 w
print(li) ['alex', 'rain']
9 g% U3 v: |8 Y- R指名道姓的删除li = ['alex', 'eric', 'rain']
( x' v$ Z5 C$ Kli.remove('alex')5 n) D, m4 ~  [8 m; u
print(li)% W7 r9 W6 N' Y, l# ~, Y+ g! k
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
! v) _: u* `& R  j; p2 a/ wprint(li.pop(1))
9 r$ |7 q4 Q+ l! S% X+ Vprint(li), B, M  x0 u9 a: z, M; U7 J5 x
0 w' Y6 ~% a6 U$ S0 A6 y2 }
eric
5 Z; q" B* ]) t) w- ?['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
8 q* L; Y8 a: s* v( \: j( b; h* I  ~del li[1:]7 N. g+ q0 |# w# Z7 w
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
" A" w) d) }2 j- ^& f7 Q, ~$ u2 fli = ['alex', 'eric', 'rain']
7 H1 l4 F: x% ^4 m/ @7 F; a: Pfor k,v in enumerate(li,1):
5 W& K7 a* Y; I& G- d+ C print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]2 K4 C) Z9 {# A) M6 I/ @
a. 请输出 “Kelly”; v1 N4 H- B. }
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]$ n9 D7 W* v$ p/ M
print(li[2][1][1])
4 V4 |$ I4 ~# ]! m, M  Sb. 请使用索引找到 'all' 元素并将其修改为 “ALL”6 V' k8 v8 ], q# a3 t& {8 A5 A
li[2][2]='ALL'
- ?! |; G5 x7 h0 \" Q1 G' P  Tprint(li)- a6 a4 Z0 T0 v
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
, O5 h, B9 p- M* L. ya. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
) B6 W! i- Z5 @% q5 u: qprint(len(tu))
3 `( M( Y5 c6 j" A# `2 j7 M  Zb. 获取元组的第 2 个元素，并输出
6 N4 d6 G- o# q& A  _# jprint(tu[1])
' E! I1 m3 j- s: pe. 请使用 for、len、range 输出元组的索引
5 R) g. L7 I4 n6 G* ?for i in range(len(tu)) :# E5 L3 ]9 i. P/ A
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
, M" c- L+ W4 [for k,v in enumerate(tu,10) :
# W3 k3 }3 Z4 B print(k,v)
8 n* c* P' d7 n- Z: |10 alex' `6 {  @  C: c$ n6 M
11 eric
& C6 q+ f# \+ @2 x- j$ X  {  r12 rain
* i4 j% c7 k3 V; f5 R! c* m
0 `2 [* J9 q9 L' w- r/ Bfor k in enumerate(tu,10) :3 ~: }9 z. w' P! e7 l
print(k)
4 a# O4 i! o5 s8 r4 ?& G9 n7 E2 z/ C4 h(10, 'alex')
1 h& D7 L. h5 C5 X(11, 'eric')
( {7 l/ T) ]" p) f* Q(12, 'rain')! ]5 s  M7 |! {- ^
1 C: D) L  b- d
# j, k) ~' n; _1 c
25、有如下变量，请实现要求的功能
; {1 v5 n- H3 v' C9 }tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

, u$ L  D& @& p7 ^d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以" F# E, P' ^; @7 q4 i' Q8 M, }' u
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])% E% K  J% \/ w2 C0 X
res=tu[1][2]['k2'].append('seven')
+ y+ N2 j6 V. Y" B7 Z% J
) ]" {" F+ h( Y9 c2 K8 r+ Y1 }print(tu)
- M& }: N# V; X26、字典& f% b/ Z$ j( L. i
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
4 f& `7 \) K% d4 T print(i)b. 请循环输出所有的 value9 I6 Z4 Z4 A! M( a7 U( s$ Q" W
for i in dic:' R6 M$ h9 ?! c3 @% V/ A# p( V  M
print(dic). `0 t2 I" o7 M2 Y, Z' |
c. 请循环输出所有的 key 和 valuefor i in dic:0 }7 T/ D* x8 v% g
print(i,dic)5 V' z/ W+ N! @5 Y8 T+ {
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
" U. z: U4 b6 ~: b3 z7 Idic['k4']='v4'
5 f$ q/ m1 I5 U; t+ v  lprint(dic)
: j5 a6 B7 a& f1 Q6 C0 ?! p. g/ e, qe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典/ v7 a% L$ F  V. \
dic['k1']='alex'( V8 e* U) M, p, H
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典+ y. t$ b: Z% J. S6 [) n5 V2 O; b
dic['k3'].append(44)
. E8 u4 G; O/ [6 i9 aprint(dic)
% t% F5 o& P) Y+ W! U. B9 [6 l2 ~
$ i4 R8 N; O4 x3 n) jg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典- N8 ~4 b1 Q% \1 T3 j2 S
dic['k3'].insert(0,44)  C' F3 l' `7 Q% ~7 r" C
print(dic)0 F; O* I9 p6 s6 t
27、转换, C8 G2 b4 Q. ]" }4 t9 N
a. 将字符串 s = "alex" 转换成列表  s = "alex"
2 Y& \* L: ?- N: @& b- s. U
8 ^0 S* h' R2 u& C# N- Lprint(list(s))b. 将字符串 s = "alex" 转换成元祖
$ a$ ~  I% [3 y$ R; e) Es = "alex"# j0 V- P, i2 t  p
print(tuple(s))7 Q2 M- ^5 K, K  z# e& r
. z9 a1 @% h  }) }# T
b. 将列表 li = ["alex", "seven"] 转换成元组: O- @  {2 V& ~
li = ["alex", "seven"]- b0 R* B' _9 I$ {, x3 J3 @/ a
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表; ~; M+ \, Q8 w* l
tu = ('Alex', "seven")
7 Z% K0 D' U2 G) Z& [, s% ]2 x! Dli=list(tu)
( _  A/ }+ {( m! O+ p7 `! J0 Qprint(li)$ \$ O' ]# |" M1 I' C
; _6 d; ^2 ^% H$ p! F3 h
/ s: T) ~4 H' i( D' d
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增2 n6 O" [4 }$ i. j$ R% d
7 L2 q; Y4 G, T; e
dic={}! K1 j0 Q: V1 Y
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面! \8 Z3 G4 }: X, |" I; g
dic[k]=v
+ E! g; K' [; B& {9 ]8 b print(dic)27、转码n = "老男孩"0 z+ I7 y$ c9 F! C
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
" E% k! T! S9 da=n.encode('utf-8') 5 [2 A/ n* x( Q8 a1 k4 m. J" ^8 Y$ `' F* E
print(a)0 T) a- v7 E8 @# i) G
b=a.decode('utf-8')
% J0 I8 g, q5 |1 mprint(b)/ J0 J5 Y+ m5 J" @* a  r" x6 ^; s# P
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')8 `7 w! x/ D9 Q5 ^" u% S* G
print(a)! Y$ H. J8 y4 W* Z9 U8 U: z! J0 _
b=a.decode('gbk')* p- K+ {$ k9 A% N8 p, D3 f
print(b)28、求 1-100 内的所有数的和2 R* f" l9 W) f: O
count=1
: a! H6 x, c+ V7 Gsum=0
9 E, h- x" E$ n& x1 L4 Y0 zfor i in range(100) :) I4 H+ o( X9 _/ Z& O! b
sum=sum+count  ^! v8 O, g/ ?% ]8 l* G8 k" z
count+=1
4 M% w) ~# l" i7 d6 J+ p) ?print(sum)
* `* U  M1 x9 O- I- q( Y# P- [! R4 }* r! d' }1 A. J1 p
count=1
; _0 b* P0 k: {0 p( h- Dsum=0! j' s1 B+ _) t8 ^& t2 P" i
while count<=100 :
. i9 s+ @9 D; [ sum+=count9 f/ E. V( d+ q: `
count+=1
. G$ g7 r5 c2 f- `  `8 p; w) E! {print(sum)29、元素分类
- M' E% Q: Y' ?/ c0 o有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，2 a4 Y8 H. ?+ b4 ?& C7 E
将小于 66 的值保存至第二个 key 的值中。% x. I- ^- v4 w5 \5 u! [( I. |9 u
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}! A5 ]# g0 N, M4 R) G; h
li=[11,22,33,44,55,66,77,88,99,90]
8 ^: U# L0 ?2 H/ |+ ndic1={
& `! c1 z& A: n 'max':[],
+ [. S% t9 \7 P# |/ F 'min':[]+ ~1 u2 V% v) _% s7 K9 @
}' j+ l6 I$ w0 S! R, q' f4 r
for i in li :  \2 o6 W1 v+ r+ C2 t; C5 A
if i <66 :: ]; w7 Z4 k; Z3 Y& r) I
      dic1['min'].append(i)
2 v. n% W+ l- } else:0 E( s, w0 M: P  Y. w
      dic1['max'].append(i)* H1 c8 D- x2 p- h3 z9 ?
print(dic1); m* _0 l$ ?! ]5 e: [

, r$ U& U$ V5 [" p5 Z" n---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}$ r9 B6 P: p: H& S$ I

Python基础知识汇总

主题推荐