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、写代码
( M  M$ A7 X: |. Va.实现用户输入用户名和密码，当用户名为 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) :) X. {2 r3 E1 `. r  U
name = input('name:').strip()
+ L' A6 d$ f, H pwd = input('pwd：').strip()
! l4 i5 S9 Z' Z' {
& A6 T! Y) w! L. a if name=='seven' and pwd=='123' :
# H0 k# C: {# j% D. o       print('ok')
' s( C. s# V5 h4 S else:
8 k) \$ w# Z' W9 d) D, _       print('error')9 W0 W8 R  W4 O9 k
      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)  :8 }3 l/ Y& X: W, H  n
name = input('name: ')
. r$ O7 N6 I" V" y) u pwd = input('pwd: ')
0 V/ v0 V* M. @% e# Y) u* j) s if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':0 h; a, C7 a3 c! Y* o8 _
      print('ok')& M" G1 S+ {) b9 v; i) G+ B9 D# \
else :/ a3 P& K& S6 F) f& K
      print('error')
3 ]" z4 W$ I. ?6 Q       count+=111、写代码! V1 A6 m0 ~4 \+ j, p- R
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) :$ \# x* V- l4 f
if i %2 != 0 :
1 l* q; j" {# P0 e8 ~3 D! }# ~       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& {# l: K" Q
if i %2 == 0:9 N( l2 ?3 Y9 r; M7 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 \' d1 r# b1 k% X7 n
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)" f5 ^/ Q3 q% @+ v
for i in name:
; f( b' j0 A8 s print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain( q2 t% S( A+ |- [# S" `' K+ q
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']4 F0 F7 {5 T9 q3 ]3 `% a
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
7 r2 u6 p1 [: \* wprint(li)
- z" f- c3 ]7 t0 f' ~3 e& H. A0 s ['alex', 'eric', 'rain', 'seven']. Y8 W0 p7 f5 M6 R8 ^
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
- }6 a. v/ m, U3 S+ m3 ~9 v6 yprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
* q. ]7 P( ]' W* {& n6 W( P: i+ zprint(li)8 h+ s2 V; X% ?' a) y
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']; ]  k3 h& n* ~$ t, u8 V3 L
li.pop(1)
. o0 F6 S) }3 s0 T& k0 hprint(li) ['alex', 'rain']: C5 r1 \( ?' |; O& L! f6 d
指名道姓的删除li = ['alex', 'eric', 'rain']- h- ]- h4 L8 p! c
li.remove('alex')
print(li)
, \: d. Q' X" P, e/ M$ P" Mf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']6 ?' ]  ~: y6 C$ q1 i3 [
print(li.pop(1)), C9 q# f8 i( K$ K
print(li)
9 `! q, @( R# G/ r' K/ _
: i4 {" A( Z+ n8 K( ]( P3 seric
/ J: N# d  S: p/ n+ b' B: K['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
. J* b) y. J2 N. E: [0 Ldel li[1:]
0 l1 g: n5 k, Jprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
" \8 E# p( b3 ili = ['alex', 'eric', 'rain']% W' E9 Q2 \( L% S  O# f% e3 |
for k,v in enumerate(li,1):/ X) G1 O1 b0 x1 W/ C9 J
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  j9 S' g* H7 ]$ g) Q8 X* Wa. 请输出 “Kelly”
7 U  x6 L/ A5 Tli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
9 p" z1 I1 E  z: |3 b) t8 ?print(li[2][1][1])4 d% I6 B1 v( A( A
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
& v; O; w- [# T- h- I6 R! ^li[2][2]='ALL'+ P/ u& R' L& F
print(li)
5 \7 r1 d$ ?% n' O24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')0 P0 \2 i% \0 @9 F2 D
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')8 [' h* M- v3 x3 I( o' x& A+ T: H$ E
print(len(tu))7 T, r' o  Y* ]; p
b. 获取元组的第 2 个元素，并输出
7 M' j' m& a8 C3 D* u: j0 Eprint(tu[1])
$ [8 ~( B3 X& u8 l( re. 请使用 for、len、range 输出元组的索引
; L8 O2 V& Q* N0 s9 ^for i in range(len(tu)) :* H3 e0 m: w0 N  H! D+ X" B. ~
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)( S6 x4 Y3 P8 t' N0 J! y: x
for k,v in enumerate(tu,10) :
; `/ E8 k5 @8 y7 k! z print(k,v)
- m" n! c+ A; c( c5 D; t8 V10 alex# e4 X1 Y8 z1 k
11 eric% A! }2 z  P0 Y; J; i& |. y
12 rain% c8 H. k$ b) z8 d# ]6 E

$ a/ z+ l) t* `for k in enumerate(tu,10) :$ [2 m$ S" G" S
print(k)! o2 T, n. f- @
(10, 'alex')
1 r" g' y* d) r! ~(11, 'eric'), q# B! t8 k. H1 Q. l8 v! [5 _: s  }
(12, 'rain')
8 O& w8 L* m2 o8 n) l' o
5 d" m. ~3 f4 @  \3 @% x( d% _6 ^$ v
25、有如下变量，请实现要求的功能
6 W! e1 j4 F# O8 k% F! w- Ytu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

4 `% J( C( b% z- ?! [& P' [d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
( E( e) e+ ~! y0 [- o9 k6 xtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])5 B% [7 s/ Z+ v' e" a7 F& G- C- Y
res=tu[1][2]['k2'].append('seven')1 \! Z4 B: `! \  {0 Q8 u4 i

print(tu)# M3 H5 |- |' ]0 o; S. J
26、字典
7 s1 f( m7 Z  ]% n5 L& Fdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
4 v: _, Q7 P3 W; Q  y print(i)b. 请循环输出所有的 value
, d( ]  T& P5 @+ }for i in dic:* [3 |- s4 E- e- ~# I
print(dic)+ O% g7 w' P0 ]6 }/ J1 n. b% e8 I
c. 请循环输出所有的 key 和 valuefor i in dic:
. i. Y+ ~8 x  A+ Vprint(i,dic)
( z4 w! {- ?& h6 W% Bd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
9 E8 `% L' Z5 ?. G& W! ^  c( zdic['k4']='v4'; ^5 T# O  H4 P* g7 X
print(dic)
" Q2 n6 Q* }% pe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
9 f: B+ z7 H0 {# ]& d; Xdic['k1']='alex'
7 d5 u, d6 d$ n) U7 s  _print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
2 ~8 m+ P' [+ Z; gdic['k3'].append(44)
: C$ f% s; p; @: e4 _; Zprint(dic)  C% w2 l- R, m2 N0 `
% n# Y+ _& K& `' z1 c9 L6 M
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
4 v3 g: R* Z# g" u3 \" Idic['k3'].insert(0,44)
# [) l. F7 _( |0 v* ~print(dic)  ~/ q, _4 r  z8 `, l
27、转换8 `* {" n  H) ^; l) O' q
a. 将字符串 s = "alex" 转换成列表  s = "alex". T$ S2 w0 D# A- R

- K- J9 {) K' Z# ?print(list(s))b. 将字符串 s = "alex" 转换成元祖; r/ m0 ^2 ^) X, }+ q! {1 p& a
s = "alex"; F: G2 U4 J9 S, D0 x( R
print(tuple(s))
8 o/ |9 C8 Q, D: N6 h
) i/ i+ Y% L* G6 g. F/ s8 O. k. ~3 pb. 将列表 li = ["alex", "seven"] 转换成元组  \7 k  F4 G5 |3 u: w
li = ["alex", "seven"]
. y: B. p/ q3 W2 Sprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
0 G3 |0 s. u! h/ ?. ?9 D3 htu = ('Alex', "seven")" m6 ]9 D+ ?$ `" j$ [/ s; w
li=list(tu)
$ T& C2 F2 A( ?- `' `  l# n& S+ cprint(li)( z( N, |/ J+ s7 d/ M) q2 f) b3 q9 G) H

4 a. s* B) L! }* i3 p! [, V" D5 Z( K7 `) n- M( y
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增+ O. W; z4 Y$ V. K) m

) A- I7 p- }/ r( i6 \7 d! A& t+ ydic={}& y1 \- `. A0 ?% j
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. ]& {9 b2 |# D dic[k]=v
, z1 v0 D7 V. O3 p' v/ _5 I) b print(dic)27、转码n = "老男孩"! `  ]' L8 H/ m8 ^$ l  o
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"$ X+ b2 b  o/ g7 D$ v" S' y$ p
a=n.encode('utf-8')
; p; N- [) A& f( S' s4 M9 R5 m  O7 Fprint(a)3 u7 J. F' q( u7 O9 O
b=a.decode('utf-8')
0 i/ {( T4 [% s- \1 zprint(b)
4 y. u4 ?& f6 @/ E* u8 G9 b5 Y* db. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
& Q) v4 J0 E+ O, Qprint(a)- }$ t4 T8 g, R
b=a.decode('gbk')
, `. ~3 c8 A/ B! rprint(b)28、求 1-100 内的所有数的和
  G2 q0 F1 U$ I; H0 W3 `count=1, r, R9 n' J" T1 A
sum=0' U  p% z5 T8 ]1 A, n% U  Z6 ~' _
for i in range(100) :" D: I7 Z! W2 X# k
sum=sum+count0 H- k( _( ~3 Q7 a" ^- U
count+=1$ \" }$ V/ U4 W8 s8 @! m1 d7 a
print(sum)
1 h( i$ V4 o4 ?7 z1 ?+ r; b; B. x, C  N9 |6 }
count=1- |! K0 i6 [, f" Q
sum=0# R9 O. H" l+ _. V
while count<=100 :
* ~  u! q! E, D) Y+ B2 u sum+=count0 }) i8 V! L6 I6 a1 m
count+=11 u2 D/ I& q4 j: k
print(sum)29、元素分类1 g5 T! O" a' x# R' z  c
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，( N" }; _. A1 h4 u4 p. n& Q1 U
将小于 66 的值保存至第二个 key 的值中。6 g/ M7 P1 d7 ]" `
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
9 W; c8 E/ @7 R% Y5 U  Qli=[11,22,33,44,55,66,77,88,99,90]
7 [! g+ K; l0 F) Z4 q9 mdic1={
8 k# g9 V" H5 @1 R5 t" Q& u+ C 'max':[],
4 x- ^( o! I& ?" R6 T# x 'min':[]
, P8 x) Y; ^% {2 o$ J}
4 N7 E2 F+ B3 n" Mfor i in li :
$ s0 O* t6 @! E: t1 R9 ] if i <66 :1 n# b5 x& ~& M9 e0 e/ `& ]' Y
      dic1['min'].append(i)0 D! b/ i- j. ^
else:1 A4 I/ m2 [4 A% B; e: N. U3 r* W
      dic1['max'].append(i)
/ F. c4 Y6 `: y; h  d' {' E- Cprint(dic1)$ P% y3 Y; a# J7 h

: }  B) E! U( a---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}- F3 M, c9 Z: ?( G/ L2 t! H

Python基础知识汇总

主题推荐