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、写代码! k' \0 }5 i% e" A9 @' T
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) :
/ Q5 W& I3 n( ?. H/ S name = input('name:').strip()+ ^  O% |# x  O0 K+ E+ L( o
pwd = input('pwd：').strip()
) j8 v4 v7 X: l: U. H9 f( v/ o! w/ \' N- ]' M% @. E
if name=='seven' and pwd=='123' :3 F! E- t' O6 Z6 @: }( G8 E
      print('ok')8 d6 I# i: M/ w1 c7 r& h" v  H
else:4 g% x- b0 Y+ ?, y& y% E( o0 X
      print('error')% |6 j' i4 x( z% u: H. [0 ^0 h
      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)  :; i4 t0 w, Y$ {3 U( M5 z2 o: F
name = input('name: ')
3 X# W5 F$ [% `6 m) A7 a pwd = input('pwd: ')
4 h$ F9 I" k6 a8 k& s) N% R& g9 O if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':6 Q$ P; U4 u, J/ m$ N" \' @; u
      print('ok')7 X0 F, Q# q7 L+ y# T. j, G: e- `5 i
else :
' t4 }, ]6 ]* F       print('error')
0 t$ l% z: w% G0 G& e. W! k' N       count+=111、写代码3 ?- Z- U. u0 O* q+ T$ I
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) :
. }4 `: }( I1 {) r2 } if i %2 != 0 :
4 o. L6 h5 Q9 F2 \       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 B! n/ p1 d2 C& S& r* U6 i if i %2 == 0:6 E. A/ m' b  l6 O* u  v! 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"
/ h$ G9 |6 z% e+ Ta. 移除 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)# ?; H: W, r, h7 Y5 h9 }
for i in name:
5 d4 m( s: L, | print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
& K1 \. q4 [8 B. I* K) z  f! l/ ^22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']  w' \( U/ F$ h' }5 i
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    9 F5 r  f5 t+ c, P! P$ n* G
print(li)
& s; V9 C& G0 m9 o- d7 l! E, G ['alex', 'eric', 'rain', 'seven']" E/ b1 \5 z" j" ?
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')8 M/ Y* M& \; U- @7 T
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')$ l6 [9 e% H. {
print(li)
& j* C: H) g! `  J8 Pe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
8 F) |, u5 I$ H. x! Z, Ali.pop(1)
  ]- Z7 ^4 m1 g& ]* j; F" c" Zprint(li) ['alex', 'rain']
3 r+ u* L' I- ?  w' F& |指名道姓的删除li = ['alex', 'eric', 'rain'], n5 Y, ?- N; k6 h) X1 L* E4 F
li.remove('alex'), y$ i1 S. e6 P% C" d6 A
print(li)2 E& v1 n$ I/ t6 d5 d
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
8 ~" o3 ~$ y- J+ a1 [8 _2 Q1 Pprint(li.pop(1))
# }' R$ j4 Y7 E6 eprint(li)
9 Y7 V" H* Y/ Q( U5 Z. s7 n" ~2 A" ~9 q: C' x% _
eric
* \6 c# e/ [- R['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
1 @1 G0 O7 u2 x3 [9 k1 s! A$ \del li[1:]2 S( u# n# j$ }' h4 l
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
9 H. ~/ \- m) y1 J) T7 vli = ['alex', 'eric', 'rain']
, S* Q6 r3 t  t9 [- p: \/ W% T2 }for k,v in enumerate(li,1):1 ]. |1 j( f. n6 F' A# R# b$ C4 L
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]: t4 I3 P6 {/ L4 z* \
a. 请输出 “Kelly”( h0 B1 _+ ~2 c2 |+ {' Y  u
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]9 A" m4 S8 Y! p; q( o5 r! W" ^
print(li[2][1][1])9 j. K; B" H# B% Z4 p
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”9 A8 p: f, M$ Z
li[2][2]='ALL'
: s; `( |. h, A4 ^. W6 v5 j# p! hprint(li)0 M  l/ L2 {$ D
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')  T1 ^9 N5 M- l# ?) D  _
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
& _* `/ c2 k0 }8 Bprint(len(tu))9 Y4 H: F2 e  u
b. 获取元组的第 2 个元素，并输出
, c' r  d/ Z5 \, d  t2 gprint(tu[1])% `1 X0 v) W! e) U
e. 请使用 for、len、range 输出元组的索引
+ }5 e  f% X5 z: B$ Tfor i in range(len(tu)) :
- i% x/ g; D0 f0 O1 p2 R4 O1 o print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
  o! y, F2 W% ~( E) vfor k,v in enumerate(tu,10) :# _! R9 i1 H$ ]" Y' _
print(k,v)" A& P  g1 W  U$ Y
10 alex) D- U" `, J4 P3 Z  o2 M
11 eric' O5 z( F" }: {  ?7 m9 ]) {" ?
12 rain
# C+ D2 i1 [$ B
  i8 O9 t$ C. e# [8 u6 Mfor k in enumerate(tu,10) :
' c$ |) h; @- q' u print(k)" T, {" D. _; Q; y6 a8 A/ P  n6 [; f: t
(10, 'alex')4 y( B3 x8 A2 O3 E& W3 s3 [! `
(11, 'eric')8 P2 o& }3 h8 P/ j5 F1 u  E
(12, 'rain')4 K/ q* K5 Z2 u2 v, z
9 A. a+ {5 Q' `; K6 E& ~7 d
8 x: Y/ x* [9 ^" F# R5 L
25、有如下变量，请实现要求的功能
2 p6 C( I" t, z# O! B1 J  Ktu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
, }: {/ K  K0 u' ?7 m# q4 `, \
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以# n  h2 T; j6 ?% s# C5 Y3 d3 o& ~
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
/ v: E* u$ d" Z5 }. U' G9 ~3 Mres=tu[1][2]['k2'].append('seven')& f7 L+ G: c! z! T

- x2 m3 @  `2 ^print(tu)
1 G" T; a2 R% B3 H  o26、字典: Z0 a2 ^" c3 T
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:* G6 n) S0 o' P! D
print(i)b. 请循环输出所有的 value
5 Z7 k, M, ^; k: |for i in dic:
6 R# O. S! I0 i  l, g print(dic)% C& L0 h' l$ ^3 Y! I! S6 @* b7 [& ?
c. 请循环输出所有的 key 和 valuefor i in dic:
. H7 U  g. F' H1 U- P* M. Cprint(i,dic)( {7 v  C# p  B/ {7 Z
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
& ?) ], L, R, D8 e( E/ U# C& Mdic['k4']='v4'
+ R; a1 ^9 j  C9 ^  v8 D0 \" R. Lprint(dic)+ Q( n! o3 N3 K- b& @" D
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
8 [) A! V1 x$ C: {dic['k1']='alex'; ?; t& e0 O$ a6 z! s
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典& o6 F0 t, w& u' M# q' F
dic['k3'].append(44)
* r$ N) Z5 Y7 s. _8 f: |% Wprint(dic)6 T( f" e# W: M5 h+ W. A/ B7 `4 w

' w  ?% I0 `$ v9 d, ng. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典& X  }, ~7 d! f. j
dic['k3'].insert(0,44)8 `( N+ q* R. z: p& P7 H: k% d, a" d# g
print(dic)
# o! y1 v, G* U7 `9 A# X' k27、转换! a2 ~0 }* \" N9 Y. u- S
a. 将字符串 s = "alex" 转换成列表  s = "alex"
" e% s: R+ X  f( V; u* @6 Q7 R7 |  x/ y
print(list(s))b. 将字符串 s = "alex" 转换成元祖
& D6 x- W8 {0 U0 U6 Q- u2 rs = "alex"7 L' M+ Q; l+ F( \! q% @
print(tuple(s))2 q9 h2 g+ A" k- q4 N
3 w# |, A: `' M$ M; A
b. 将列表 li = ["alex", "seven"] 转换成元组) n1 l( A& {$ M# W# k1 V# K, K: k
li = ["alex", "seven"]
. G. O+ b3 h) \- a! q( ^$ E% hprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表( V" T* |0 B; V. A: b
tu = ('Alex', "seven")
! \' j( B  t+ {2 u- Y# [# Gli=list(tu)
$ e$ B3 F. x; W/ ?) {print(li)( e- B  r1 C/ F# S" V3 k6 P0 R0 s9 n$ Q

7 S4 G0 I9 o) R1 Y6 o, O2 F9 P+ F# t) q' x& s1 ?& e
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增2 T/ y! B! A4 a' M# d

: n1 Q' L! K8 o% C7 u+ _+ @/ Fdic={}. {! \# L" q  `; v0 s
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
! l7 X- N8 a8 A% u dic[k]=v/ g  }0 s+ X0 N& t( q
print(dic)27、转码n = "老男孩": z; r0 v, Z5 G' r& h! {
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
8 `4 n. f/ Z3 w4 Q* ya=n.encode('utf-8')
+ V! s" f) L: [9 a" Tprint(a)
, {9 a6 {3 E$ e: G/ Q5 V  \4 J* Ub=a.decode('utf-8')
( T" ]+ f/ M& l( U: Jprint(b)
+ ]7 x) R$ D2 @# g% _; X8 Mb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
. ^2 i" K7 b/ ?) o) lprint(a): q8 H, C6 r0 o3 V, S, }
b=a.decode('gbk')$ |0 z  Y8 \& ]6 h
print(b)28、求 1-100 内的所有数的和
$ _" V. P, S3 \count=1
* M+ h8 U6 }0 |sum=09 e1 g$ j! [" t+ ?  t$ X
for i in range(100) :
: Q3 X  n$ @) g6 O* s sum=sum+count1 [0 x2 }& g- C' k7 V0 l, m
count+=1. ]0 J1 v! @; {, z2 W: x# C; C
print(sum)$ q& [; X5 y4 N' r" X2 ?/ W

% I4 q2 P+ _5 I0 q& s: c/ q/ dcount=14 g; _# d7 l6 f& [
sum=0
/ e5 u: a7 D  R4 P* Owhile count<=100 :
9 l- X6 z6 T; c sum+=count' t9 K9 L" z/ _" o. K3 H
count+=10 [$ U7 c! ]& i) ^1 M* d! y; z
print(sum)29、元素分类
$ \4 T  o, M9 B* {4 [有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
8 S- j% S2 x& @9 W将小于 66 的值保存至第二个 key 的值中。  S. t  j/ g8 ?+ O
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
7 I% b1 N. z) ?* D+ Vli=[11,22,33,44,55,66,77,88,99,90]( U. N( B& S2 `; o1 |; ]5 r2 i
dic1={
# l2 d; t( O& \$ ^0 G/ d 'max':[],' T8 S: I$ M7 l) Q0 H# I; A
'min':[]
5 D8 Y# W% A5 T$ H8 ~}) |- y. P( f3 w5 [- _( W  B. d
for i in li :
/ l( D$ l: _# s% y if i <66 :
+ B$ L- U. E& f- _/ }+ s! F9 `       dic1['min'].append(i)+ K# ]; ~- s" \1 L
else:7 U/ W$ `) T9 K  M
      dic1['max'].append(i)
: R. n/ T! C3 vprint(dic1)
' F' @$ @* d! g! t# _
6 L/ S* {/ B4 m. u: P2 B: S: h---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
* m. h- U& I! d9 n

Python基础知识汇总

主题推荐