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、写代码
  z5 p7 O. W9 b# t" f; Q2 j. z- ba.实现用户输入用户名和密码，当用户名为 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 d3 x  e& }( ]0 W$ C
name = input('name:').strip()
. K& s3 g+ _/ H. m& G) R pwd = input('pwd：').strip()- O5 R% W$ O, V: K' S0 G

" G  x4 E7 P9 [2 {+ i/ s if name=='seven' and pwd=='123' :
+ p. N' F! j5 v, F4 X. w       print('ok'): ]7 o% y9 R- E. r& @
else:1 E6 W$ `" C/ T+ @. c# b3 h
      print('error')6 s8 e  @- T/ p, \2 g# s5 c
      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)  :5 F. b" W6 f" R6 u; Q! }
name = input('name: ')
4 r$ P2 |' V! K& @% J: D' h$ q pwd = input('pwd: ')
/ D! n; p! A0 C8 [' Y if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
* I. H1 n) I3 e0 o6 O  B/ J       print('ok')  s3 v( D  |! J' h2 J+ R4 H
else :, l8 x: l' f3 `9 v. g
      print('error')
5 e  {0 P4 C6 n: p( {8 F       count+=111、写代码
% x! f5 j: |7 B' Y( B) ua. 使用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) :' _3 W' d, r1 w7 [8 r8 X
if i %2 != 0 :' t( ]7 r1 b. S( 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) :
/ q% L! M% l2 a  |+ r6 O' ^) z if i %2 == 0:
9 M7 N* A# |. 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"
7 r; S* p: I. s$ i. ^) Y. L$ S/ _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)
- {" b) v$ G9 O0 @for i in name:0 t+ s7 N1 f& e
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain3 y0 x6 m; N$ o' {9 S7 x' O
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']% @8 \  X! y$ K' x6 i" }$ X: Q  k
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    " q, T  J! \7 P4 T9 X
print(li)
) e8 I6 K# r+ f1 W8 _ ['alex', 'eric', 'rain', 'seven']
& }2 ^, Y* w8 [8 V9 l+ s* x2 sc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')" d, \2 k1 Q4 ]0 w$ F
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')( _0 l' u6 U$ M* e" }# z  y
print(li)
" N# s" E3 L6 A0 me. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
2 y1 G8 M- B& ]  Zli.pop(1)
0 F; L' F; H8 F9 e. sprint(li) ['alex', 'rain']
8 f! F: L* r# g指名道姓的删除li = ['alex', 'eric', 'rain']; Y! A4 v- m. v8 ~1 q
li.remove('alex')
( n& |; c1 I  u0 D0 rprint(li)/ {1 v+ R. o% q- l
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
6 i) S  y/ I7 I! w- O2 Iprint(li.pop(1))/ y; H# D* @/ E6 ]# ]+ A* X; _
print(li)
" @+ d2 t0 r" ?) \! C" U7 [5 T' x& M! d' j& d1 {8 S0 i* t; n, }
eric
) N* w5 `' K  X! S% d. m. ^3 b( w['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']/ C. \4 }8 R; b# b2 q0 ]
del li[1:]
* ~( q+ X6 }8 J# }) ^, dprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始). K% K: y3 }/ l7 @1 M. G2 t
li = ['alex', 'eric', 'rain']% i1 L1 t3 A" k! k
for k,v in enumerate(li,1):* V4 I- }# k, C6 v" W3 P9 L
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 y' O/ E, u9 s5 B- y4 Fa. 请输出 “Kelly”# h8 u- _* `* |1 G  ^
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
: Q; J% r7 a. Z3 i; }print(li[2][1][1])! Y; e# ?' f9 @& k' z5 S
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
0 o% n1 I- d+ j  R9 hli[2][2]='ALL'* O. b# l4 p* x6 p! y
print(li)8 T0 M2 \4 s0 P5 C- Z) ^: L0 @9 a
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
2 O* _9 A. a" [8 f0 a1 Y9 Wa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')4 s$ B( Z4 V3 Y
print(len(tu))
/ @+ v% z3 I' W' M6 q* v+ I& Vb. 获取元组的第 2 个元素，并输出
4 O9 z2 Q0 R  K- H5 \print(tu[1])
& Q+ r2 D+ a- V* M. se. 请使用 for、len、range 输出元组的索引
/ M% k+ N2 _: R# ~9 h3 M' ofor i in range(len(tu)) :6 I! b' Q& R3 \$ t8 e- F; k; {
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)  j* _; _2 _4 y  p
for k,v in enumerate(tu,10) :0 `  c- t5 \1 N- R
print(k,v)
2 t* Y8 w$ \1 h10 alex  P6 O! Y+ m+ r/ E
11 eric* \8 ]. H3 ?' [. G5 W) M  ^$ i
12 rain
4 V$ o" P. }2 _
, f& Q' _/ p1 E. ?' v1 j9 M9 A  yfor k in enumerate(tu,10) :- _% o) l$ |$ C& Z! g: L: v4 J
print(k)& O: B; a' {/ p% c# x
(10, 'alex')
# B8 C1 s0 r$ j9 G% z: I2 h% G(11, 'eric')
7 a1 C- ^$ h3 s4 ~' \7 L+ U(12, 'rain')
4 w# K* C' A  ]+ G* U- r
. N2 e" c% x* P& t1 @: Z
' @# E' W* [  V& r5 Q2 j25、有如下变量，请实现要求的功能
, a, E* ~2 }/ {; j/ _tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
  b& F% T+ i8 n
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以/ q9 S8 ^) v. F' ~
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])6 U% z* r1 i6 q9 K+ |8 v4 B  p
res=tu[1][2]['k2'].append('seven')
! h8 v5 P0 C/ `# W. w( h( B3 _# \, Z$ p
print(tu)
" b# S# Y: e  g% f1 c% a5 u) x* ]26、字典! t5 b: Z. t! u7 z
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:- F/ \8 Q8 _' V) ^+ U' l: |  m
print(i)b. 请循环输出所有的 value+ N/ B8 C0 k/ g- \- y) u
for i in dic:- t) m+ v) o- u. c  p% H
print(dic)
% i, _% _3 Z6 ?0 o9 C& lc. 请循环输出所有的 key 和 valuefor i in dic:. ~, f. e. x0 {4 K# ?+ n7 y
print(i,dic)+ V. D0 y  j: ^- D& k2 S9 U3 P1 n; `: |
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
1 a$ }9 }! |7 C( x% O& Pdic['k4']='v4'
# I0 ]4 g+ K# `  wprint(dic)" ?1 P/ y, D3 c6 l
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典4 N( {( F$ r6 _/ K: h7 K* a2 Z
dic['k1']='alex'
# L, q1 o$ [8 m% c1 Sprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
! Z; b5 C: R, O8 R2 z/ W5 sdic['k3'].append(44)
4 C( N- s$ v5 p9 i0 J8 ^4 T# aprint(dic). C% G  _6 Y' {$ l

8 `3 k2 o0 F/ l2 Y; A" `4 Y  sg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典& B/ L$ z9 q' \8 i* G; w
dic['k3'].insert(0,44)5 T% R1 o" x' W! m; V2 |7 i
print(dic)
$ f! Q' Z' T, R27、转换: p& ]! r6 a$ e
a. 将字符串 s = "alex" 转换成列表  s = "alex"
- T: m$ k% B" S7 {3 Z. v
) `7 ]* d' }6 nprint(list(s))b. 将字符串 s = "alex" 转换成元祖
* c0 s4 v& I/ a* `2 J% E  Ks = "alex"6 m9 Z6 Q' n  P9 {) Y) p/ E0 p
print(tuple(s))
- s* F7 F$ ?, j$ r) C' e; D; O# s: v4 A: `! S
b. 将列表 li = ["alex", "seven"] 转换成元组1 \; K' W3 T/ A: R/ u5 e* N1 ?; ]
li = ["alex", "seven"]
/ m; m, a5 K# gprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
$ ~0 h  T1 W  t  `( w, Utu = ('Alex', "seven")
( w" ]6 ]# x* J6 w% D1 e4 i  ]0 Lli=list(tu)$ |8 d* Y% {/ T" c; D8 Q
print(li)
- v$ `/ E/ z. Q3 n8 e6 _# }6 U) ?7 |. X1 Q( `8 k. R
; Y7 x' Q9 w7 z1 W) A4 j
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增- ~. V) g# W9 N" F9 F
; c. ^' g- u" H7 r
dic={}
0 p& t5 `( H* ]$ u: Z  Hfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
, W7 A# z3 }! C6 y* { dic[k]=v) b0 i0 e; X. h& M" t- U
print(dic)27、转码n = "老男孩"
7 [* D( X. ?4 Za. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
$ M! _+ Z9 O, @, H' \a=n.encode('utf-8') . }4 c3 e) x  C& O* o  Q  P
print(a)5 k1 y/ Y- O' |. n8 {5 {
b=a.decode('utf-8')- }4 T' B( {: W& M) H( k- l
print(b)
# W3 {1 T4 O1 y& u4 nb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
+ |& [3 M. I( J/ a+ e* [print(a)& g: k' R4 d, [9 H: g
b=a.decode('gbk')
8 h% F9 ^' \/ s( j1 \print(b)28、求 1-100 内的所有数的和) O/ e. l  k7 Y* F
count=1
- S4 j+ b1 |* q4 B5 Hsum=0% n6 n. S4 B# g* r6 b
for i in range(100) :" \1 a6 g% G3 N, n$ j4 e
sum=sum+count
8 C! h8 {; t, u count+=1
) a8 e# M2 K4 a) k7 Jprint(sum)- S9 y/ A; K& [5 \  N; D
4 T/ @, d/ p* k& D
count=18 r- O# H4 O7 ^% [* C4 {9 |
sum=0, X* P6 g" N; {0 j) a0 Q& t
while count<=100 :+ L/ e6 m4 n- A6 V2 U1 Z
sum+=count* G. t6 P; e* u- }  c
count+=1
0 U' J" E8 R; Z- M9 g5 k) yprint(sum)29、元素分类6 Z8 ]( f( Z4 g' S( D' ~
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，  n/ B  e- n8 y  [. |( `, e5 O
将小于 66 的值保存至第二个 key 的值中。
7 \1 x/ |# [3 \即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}1 W8 c1 U$ _  O* s+ r; P2 g8 v, c: N
li=[11,22,33,44,55,66,77,88,99,90], T/ L$ V  M# `8 l$ _0 L1 z
dic1={# D# x2 O- \( O0 C- w# o- u" v3 `
'max':[],
' V$ h; N5 P! {$ ^; ~ 'min':[]
7 v4 ?& Q6 t$ i}3 `* v# \+ W- e$ y( k: D
for i in li :
# a* t3 n2 }% G1 d0 _ if i <66 :
. }1 V- J3 h: B: Q6 R       dic1['min'].append(i)/ d1 s, Q! H  C; y; `8 V
else:2 l# f+ y/ @" \0 E! K
      dic1['max'].append(i)' C. c' I' D& r% ~
print(dic1)
1 N$ R9 o  L$ s+ M. X! J; G
0 Z2 D; h2 H* \+ R# P---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
5 Q, d' ]' X/ z  x% ?7 D

Python基础知识汇总

主题推荐