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、写代码. D& z6 @$ j$ b% ]
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) :
- p% D. P' K$ O% B6 A% C name = input('name:').strip()# T! ^7 w6 r  {) U
pwd = input('pwd：').strip()
7 K6 y. U# A' N; P* ~+ T
9 y2 r/ U6 O$ ^/ N/ ]2 N if name=='seven' and pwd=='123' :
' @1 s; m! u9 J& o  e! A# @& [& t       print('ok')
! q  ?8 ^3 N; u3 R( U3 S4 W else:
& J2 p6 ^: g/ o8 E$ S+ ~* y3 |       print('error')
3 R/ Q, ^2 Q9 A5 L* ?) 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)  :
$ L+ t/ N# X( p8 m/ Y/ b$ J' ~ name = input('name: ')
. u& _0 X: T4 a pwd = input('pwd: ')
5 q: ^: I! _' A. O; ` if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':8 m7 P) k: a8 L# S3 M( U: _2 q
      print('ok')0 L0 o) J+ p9 o% _4 E/ B! E
else :3 d. R3 T! D8 ^* O4 e
      print('error')
! E% L/ G1 C; Q5 R  S       count+=111、写代码
( e5 W5 G* d$ R& U( r5 aa. 使用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) :8 R- ?% s& p" j/ G3 w
if i %2 != 0 :
! h1 t# m5 r5 g) ~  f# X0 R) 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) :9 T) ]% p* \- k! L  L
if i %2 == 0:
5 N3 u6 T$ g5 B3 A  B       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"# }5 U( f$ p* m( J/ R! p
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)
$ P* Q) E2 c7 i8 A: Q  H+ n" hfor i in name:
9 b0 b. ]( q" v( \2 k7 ?) M! G print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain, d5 x; a2 u! K1 Q
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']' P2 H6 V  L! z/ X" A& `9 v" k
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    , ~3 X: h0 M8 x' I/ w* v7 R  X) v4 y' k
print(li)
$ _. Q1 G( P9 A1 a3 r" T ['alex', 'eric', 'rain', 'seven']
# s, H* t8 C0 ?; y2 U7 Mc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')4 o; G0 m" ^) J3 l' L: {# ?: p
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, M( }* F. ]; }% h% _print(li); V# W* A: U) R6 a8 O- Q0 ~; [
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
, ]% k6 v$ H3 ]' i! i5 F1 [li.pop(1)
. Q- C7 R& j5 L" o5 q- Jprint(li) ['alex', 'rain']
6 x* G; k- J" `: [+ h& D( z3 z. \0 ~指名道姓的删除li = ['alex', 'eric', 'rain']
' S" m7 R* e; wli.remove('alex')/ s6 L5 _& J$ S4 J
print(li): h' O5 b" b: ~5 f% @9 g% v
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
; h( T5 T' |5 O* l0 G/ |print(li.pop(1))
: z2 {0 K- f$ x+ Nprint(li)
9 K2 s. d2 z6 ?" O9 C) b
& B, J1 a. y" K3 v0 s" deric
& N- D3 w! ]3 Q; t9 r5 j+ o['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']  d5 |9 r) w  F8 B# J2 `, {
del li[1:]: m/ S( \0 u% Y, {1 e
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)$ i* l$ w! l# J- b% h( S! a
li = ['alex', 'eric', 'rain']
1 o8 [) i) V! ]1 }( o9 |# f2 o3 E3 ifor k,v in enumerate(li,1):0 r5 G9 @5 q( I5 n- |
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]% {) H7 z! a. b
a. 请输出 “Kelly”
  c& Q3 G4 H: v7 a5 ~* @1 S# [li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
/ m1 t; c: W% o  pprint(li[2][1][1])
1 C  O; \; a1 Wb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
+ m$ u: L# l9 ~& Fli[2][2]='ALL'
' X, u% y- p9 K. @  p% c( l" Lprint(li), b) _/ Y, U, C% B- Y
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')2 R# p8 d+ N0 r# T1 `6 h7 A7 L
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
: D: w8 x7 f# L3 R& G: X) ?/ vprint(len(tu)), c- J) D  a! N2 C! j1 I5 a" s3 z
b. 获取元组的第 2 个元素，并输出
3 C. Q0 @! E$ D7 a: _, z( Cprint(tu[1])
+ N! ~; Y1 ]' X2 p% ye. 请使用 for、len、range 输出元组的索引/ @) _7 v, @/ y& ]  k
for i in range(len(tu)) :; T2 W' `4 h# n& O
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
# s4 u2 o6 R* ?" H( |8 }for k,v in enumerate(tu,10) :. y# H# R! j5 B2 K% {5 g4 {
print(k,v)
2 e1 ^/ ?6 o* N10 alex( y( U% _2 F4 ~! ?7 O" |* W. t
11 eric' L+ d) N. i; l! r; W% w
12 rain
  k9 V- [9 v' m3 z  S+ u( v
* t  j4 Q: X0 {8 t  Qfor k in enumerate(tu,10) :. M- k" h" ^2 r: n! k, o$ K
print(k)
6 h6 H) O% r4 i$ Z/ A* O(10, 'alex')
! |# p; x  a# y& \' u(11, 'eric')
1 F6 h8 ~0 b1 o1 [. h(12, 'rain')$ R; \: b7 L# p( ~

" t8 m* F: o. o7 h( C4 ], c; Y6 d3 |4 d
25、有如下变量，请实现要求的功能5 m8 A  g8 w, ^" }4 p
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
3 J1 @! r4 \% y5 ]
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以! ]4 ~% k  M' w3 c
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
. s- K7 \( v2 h5 b- ~res=tu[1][2]['k2'].append('seven')
+ S1 m* c. x0 O. [& Y3 i
4 }. X8 I7 N3 J" Y- v9 }1 _print(tu)
' y9 v/ }( B! ?/ S- P2 S* d26、字典3 p# `3 c5 W! I2 r; F% n" D
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:; K/ g: [: `. O9 e) \! d7 D% A
print(i)b. 请循环输出所有的 value3 m1 n+ ]/ z+ b" [3 O4 b- u
for i in dic:; ]( r2 t4 C" j, k' I0 E3 X
print(dic)
; s1 a! s! r. n9 fc. 请循环输出所有的 key 和 valuefor i in dic:, C2 |. R8 L$ T) a3 ~) w4 o6 ?
print(i,dic)3 F6 e: k, B& @+ u" J" c5 g
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典: T# \$ ?: C9 A- _
dic['k4']='v4'. n5 ^! ]* J* h4 M/ @! f1 e3 R3 g
print(dic)6 k" L1 u" ?4 B8 x' w- p
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典  L# u3 V. G# c4 H
dic['k1']='alex'
4 d8 S' X: _: x0 ?* f3 ]print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典$ _; P0 j/ `6 n
dic['k3'].append(44)/ ^+ r4 Z! B2 }5 {
print(dic)/ z- G' d& i# J3 g  T5 ?

2 T+ D6 q$ B$ J$ b& y; Wg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典% F0 @+ w% o: v' M
dic['k3'].insert(0,44)3 B5 v: m  c' o) v" _! L
print(dic)
$ r# o2 d7 k2 {) b% c  {% x; t27、转换( W( V+ ^* `) r( p1 H0 Q1 k. g% j
a. 将字符串 s = "alex" 转换成列表  s = "alex"6 o  q8 n- n8 F5 G! n+ F/ m; c% N9 t
; D: z+ \+ S# r+ n/ p" U, h9 j2 N# b
print(list(s))b. 将字符串 s = "alex" 转换成元祖
7 X$ O) t5 N4 o+ {2 j+ qs = "alex"6 }7 q5 o  m) b: s& Q6 y. e1 C7 R
print(tuple(s))
1 v, L9 z# G$ N0 R: F% B; R& e+ m. Z7 E9 ?4 i! X1 ^+ f4 `% x* {
b. 将列表 li = ["alex", "seven"] 转换成元组
5 s% U6 l0 N0 n5 tli = ["alex", "seven"]6 I3 R! P- e! _2 \
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
3 X9 z5 m7 o; P+ }6 Z- `tu = ('Alex', "seven")! |+ F+ D7 D/ C# g7 h
li=list(tu)$ m9 l) l8 N1 R* N0 ]9 l  o6 s% y
print(li)2 Y& i( d5 h! k9 b3 g2 z  Q

  K9 \" f, k' f
: G0 z1 ~4 e2 h- k+ fd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增( ^) e# P: a5 [' k3 ~
0 _# q) v5 V3 m8 O6 l. h
dic={}% l& y1 C8 h, S- p
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面- w) y/ L4 [! l  D
dic[k]=v
1 R; z  P, \! z9 d print(dic)27、转码n = "老男孩"
/ c* ?- L3 ]5 l7 _' H; ka. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
6 O7 `$ ^0 R/ i6 Ia=n.encode('utf-8') ( a, O, Y  z6 P$ J" {/ F4 l
print(a)
9 {% _+ U- U8 ?+ o8 {# o) A* G# Hb=a.decode('utf-8')
' B1 p( S& o0 e, Uprint(b)
- V/ g4 l  N/ i3 I3 y5 xb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')7 I  R9 B3 d% g* b9 e
print(a)
+ u8 z# g$ X" N# Rb=a.decode('gbk')
( H" ~8 ]2 l; Q7 }0 m- |print(b)28、求 1-100 内的所有数的和& m9 {; E, ~5 G% t  H
count=1
# }4 A8 i; V7 ?- }+ fsum=0
! h1 {' @3 {+ I! O0 p2 Jfor i in range(100) :
8 \7 e+ e, C1 j  u sum=sum+count
& v5 k6 {* }1 l2 D. z0 j+ w count+=1( O  m/ y& E5 s: _* t
print(sum)
% N: [" g2 K/ U
0 C( V3 x6 u  ]6 Ocount=1  m$ A' r4 @* m, V7 |- S7 D: Y
sum=0
1 e, B0 v( R! j" V$ swhile count<=100 :4 V3 g8 y1 l* X' d0 N  J
sum+=count
% y- ~* `) f/ `, Y: K count+=1
: I. J4 ?+ v! dprint(sum)29、元素分类
3 d3 w$ U- ~/ F% Q4 [有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，+ d1 [9 ~- Q1 M) K' O
将小于 66 的值保存至第二个 key 的值中。
* P# {2 g' ?4 c& w+ p( f即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}# U( C4 I& u' ^5 h; ^2 a% X
li=[11,22,33,44,55,66,77,88,99,90]5 m" x" e. e" a$ k
dic1={
+ p2 k( u5 v, W' Z/ a 'max':[],  {, C- z0 G& M0 b5 f5 M, @. ?
'min':[]# Q1 c3 h+ [) }9 h
}
! T" `; G4 P- }- A% s/ ofor i in li :9 x! l. J+ X9 l9 z2 n6 l; h/ |# A1 X
if i <66 :* A) T, H! x: k& Y8 \
      dic1['min'].append(i)
% [, g% H! J6 r3 ~9 l! W% l else:
3 z: E( {, R* r) U       dic1['max'].append(i)
- f% y; k" r; p$ Z. v2 B& Uprint(dic1)4 _/ n+ {/ {7 u7 Q7 U8 J- A
  }9 e" F$ J& m2 `2 n+ B
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
* V, s& B% G* K' \( R1 @

Python基础知识汇总

主题推荐