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、写代码
6 s% I1 T+ |, s- Aa.实现用户输入用户名和密码，当用户名为 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) :
1 U3 H' A7 W& f  l' H* Z name = input('name:').strip()
. d$ Q' p7 e" h, M% s pwd = input('pwd：').strip()
5 Q  t* _3 m4 s! X+ n/ ?1 u$ a8 o: w3 E, X4 O
if name=='seven' and pwd=='123' :
" T9 [. C8 M% n3 L0 e0 {. `7 V       print('ok')3 p8 k: ^9 `4 X" a( j/ s+ W. q
else:3 i9 p4 v3 N$ C6 G
      print('error')3 ^" A( p# z, C0 ?% A
      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)  :2 k  T/ G/ S' T) l; D
name = input('name: ')# e6 B6 d/ A2 @9 q8 |' a8 ~
pwd = input('pwd: ')
1 c5 e& p) C9 K1 M6 j0 ~ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
# h! X' K8 {: G& n- E- X       print('ok')* B0 Y7 t) r& U; e8 @
else :
+ A/ H9 V6 ]% K  u7 A, f+ y* b       print('error')
$ I. ^" l7 H: ], V0 Y7 b0 {3 |       count+=111、写代码
7 C5 {; S2 y- 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) :
& W) F, f1 |- W" U( I! q) f if i %2 != 0 :$ I8 k( ~; i1 F+ j1 X
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :, {7 I8 ?' x: i+ f: C
if i %2 == 0:6 n2 y* H# C" z, D! f9 v! g
      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"
& z* n5 f- M2 F+ `6 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)
2 j2 t; L* Z& x7 S/ r4 }6 mfor i in name:8 ^# Y* ^; y; m& C- L
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain$ v$ U8 T8 `$ J5 _) W! [, z; m
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
# s% l3 n; s; C+ ]8 E5 u  K: tprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    # _: k6 }- F4 ]% @" }3 u: F9 c
print(li)) w( r) Q' q2 f7 W
['alex', 'eric', 'rain', 'seven']+ f" e3 W+ d4 a3 O9 I- H
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')4 J9 y$ s( V; |$ m: [) H
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')8 [  S2 ?2 P9 E; r
print(li)
; _1 p" Q( Q) Q' v3 he. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
6 h* h& ?* R# oli.pop(1)) }! {: ~4 t7 [( D9 y. x8 M! e- b
print(li) ['alex', 'rain']: o- v6 T* p" l8 i
指名道姓的删除li = ['alex', 'eric', 'rain']' `, a; ~0 A, h
li.remove('alex')- @( X/ d7 n. d  D1 w
print(li)% B6 B  ^* w# B8 X4 t- l8 ~& D
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
% }: B7 Y4 h) L# C9 ?print(li.pop(1))
. r- C5 U! S$ c4 B2 jprint(li)
; K6 f7 v! P7 w/ G" Z% b% _' V! C/ n: h" `0 d  O- D& p
eric2 q4 f0 r9 S' j. K- c( J
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
6 S! f) k/ ]% Ddel li[1:]
% T  u+ U1 `6 o, v* m( W* A$ cprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
( G3 S6 N4 f: K1 M' rli = ['alex', 'eric', 'rain']
; Z# |7 w# Z. Q  }: Lfor k,v in enumerate(li,1):
: T/ m) }; g1 O+ R print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
; }/ W& R1 ~5 u! Ka. 请输出 “Kelly”
5 ?1 \$ ~: g: Sli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]5 W, b; o5 h% n* o& U2 G: n
print(li[2][1][1])9 A# l% l" f+ i5 r
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
# C; E! J0 O& nli[2][2]='ALL'. Q$ l8 n7 M) V# a! w; O2 s3 O6 I2 M
print(li)$ l, O; X& Z5 [; n6 c' D
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
5 s& ~3 Y! T$ E1 X0 ?7 da. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
6 M2 B3 M2 y( Y7 l3 n2 [print(len(tu))0 O9 B& d, i( Z
b. 获取元组的第 2 个元素，并输出4 j) C  P2 @7 e0 P1 J4 `1 g; A
print(tu[1])
$ y% E' r" q3 y' X/ Q2 W) Je. 请使用 for、len、range 输出元组的索引: M# q9 d3 t$ J) N
for i in range(len(tu)) :7 t* Q" s* ~# w% K5 o# [
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
9 y! k# U6 ^8 \% w$ S& r7 xfor k,v in enumerate(tu,10) :
! S3 F' `; ~" s% C+ `9 B print(k,v)/ p3 Q3 p/ c$ b
10 alex
; p1 C$ N, \$ u, Y' T2 C11 eric) i& e1 M, B8 l2 @# M* Q
12 rain0 b; ]# ~6 N: y8 G

0 G+ n% \: K' o0 }1 C- h- i; tfor k in enumerate(tu,10) :9 ~" }5 ?) B# N0 \% v6 N
print(k)# S1 f4 H. h- K, Q
(10, 'alex')
* |; t# u+ y0 T2 p(11, 'eric')
1 j2 u# P. P( _8 J# v1 s6 u(12, 'rain')
/ g; m* O% q' P8 {  x& l' H7 n9 V1 ^: d' w) j/ Q
' x; u8 X4 M( d# _) @7 G& A
25、有如下变量，请实现要求的功能* }/ E+ S$ }7 k' l. }
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
3 l0 e' u0 M" h* n
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
' i1 A" ^( I1 Z5 etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
/ V. v; ^7 {. o- pres=tu[1][2]['k2'].append('seven')
- W% @3 h2 I: h" T# K6 B
1 S  J. u- D' }; g$ W0 f1 M( d$ jprint(tu): d7 p" O* q8 |: \1 j
26、字典
1 @5 d  C' o1 P. N% Udic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
9 m! t# k! w8 a1 M0 Z8 K" M print(i)b. 请循环输出所有的 value* {- B2 l' s- }# U; n. c% n# P1 D
for i in dic:
/ {, R# [6 ^- X! D7 R print(dic)
$ P% p$ j) n% H1 o2 Cc. 请循环输出所有的 key 和 valuefor i in dic:
$ J, S- Z9 P/ j1 l! qprint(i,dic)
- s6 r5 o& C, {9 Od. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典3 V5 Z  k5 I5 q' u1 J: }
dic['k4']='v4'
2 w7 ?' N- c# _6 d2 Gprint(dic); Z8 J/ `' c) m  i. }8 J! ~
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典5 i' Q4 ~7 E. B, d
dic['k1']='alex'! ^& W9 V' {  F7 P
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典" o0 m; n4 k" Z  _4 q! G3 q  X; V, u
dic['k3'].append(44)
  T0 k6 p5 v$ g2 b8 F/ a  Oprint(dic)% x, g' N- r; k2 V' X  E

2 x3 J4 s8 T/ `: F6 Y+ ig. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
- _+ k7 L* ?' N3 qdic['k3'].insert(0,44)
3 M: l: K+ ~4 M* c8 s# Oprint(dic)
: c) V/ }5 R' |6 t# Z/ w27、转换, A1 p' b! o- d: G" g( Y
a. 将字符串 s = "alex" 转换成列表  s = "alex"
% B* S& y% @. j8 j) I/ [) [' l: g) N  K1 A* L! {
print(list(s))b. 将字符串 s = "alex" 转换成元祖
" D1 U2 j' {) v+ J' t8 Us = "alex". @. H) k; C( \7 D
print(tuple(s))0 U# j1 k" `" C% ?' k6 x! [) T

% o; j- ?/ Q% b) J, Q( R% H- [b. 将列表 li = ["alex", "seven"] 转换成元组8 d2 o: l3 b& \/ R' R9 Z( Q) J4 q
li = ["alex", "seven"]
: @" [  a$ r8 i2 kprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表5 R; m, O+ m" X6 p0 ?1 O4 z
tu = ('Alex', "seven")% n/ y3 R: C  o; X1 M5 F
li=list(tu)
) ?- J1 Z" ]* F# V1 ]2 s& x0 O) bprint(li), @3 g! C' h' X: r1 E

- E! ?7 L4 m/ Y5 P& M$ _( }3 ]. h' d% g* N3 Z
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增1 D3 T+ v0 }: b+ n1 o
- k4 P" j+ g! v' y1 F# ~
dic={}
- k0 [* `# e. I9 J4 A4 W" ?2 hfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面  D5 X6 p) V: o1 |; u: X
dic[k]=v" F; @- k' ~- `) d+ ?/ ^
print(dic)27、转码n = "老男孩"" o* A  l6 r3 k7 I- x# L( w
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"( C, E4 V6 B( L( i! U
a=n.encode('utf-8') % W1 c- S4 u) X6 Q8 P9 a
print(a)& f/ X+ [& a* }' T
b=a.decode('utf-8')
7 A- D# }' ?7 u) Wprint(b)1 o8 C( H* r- v6 ~( O0 _9 y
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')6 `! |5 H9 R% S/ s" S" j( g
print(a)* Y! ]" }1 G6 r: Q- j/ f
b=a.decode('gbk')
( D4 i+ R# ?8 [3 g5 qprint(b)28、求 1-100 内的所有数的和$ m+ I8 q/ h- c
count=1
2 H* S2 y% \. S! {2 ]' T! Isum=0
" P0 P4 Y1 b  h; w% q# rfor i in range(100) :$ ~1 ~4 M$ t# J& q, J% C
sum=sum+count
# P  ?6 p4 q2 M- g( n) e3 N, ?! U count+=1
$ h, e: W: g+ q3 v; J/ cprint(sum)9 n: p' o8 R5 d# d6 H
/ \* ^& c3 K8 p/ i7 f
count=19 w/ |( y* s0 A; n" F
sum=0$ \+ ^" y9 }$ ]! G& D
while count<=100 :3 u; [: v% B  m8 w$ s; [# X- J! r
sum+=count8 R8 ?$ k6 x5 _  S5 X$ S9 \; q+ }& V
count+=1
- m% C3 n, h# Q- O( p) r- K2 r* y. dprint(sum)29、元素分类. b0 o* h' `2 w6 {6 j( o
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，- S! d( M, d; `2 F# n2 C
将小于 66 的值保存至第二个 key 的值中。( t: }% D; l& [! G1 c9 }
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
9 E: X- \, G+ y$ {: {3 e3 B9 d( Q! vli=[11,22,33,44,55,66,77,88,99,90]
, c8 q. h, g$ Qdic1={
' T! @  s: X: }* E3 Q 'max':[],
0 T9 d3 v, o. C" L0 q 'min':[]5 H4 u: @  i$ T
}
: t& d0 U# }8 ofor i in li :% E( N3 K5 o3 k& [& a7 J
if i <66 :5 y; G% R- n; B7 Y
      dic1['min'].append(i)
1 R/ h) F$ _: s/ ?& _' w9 m else:. k* v" F+ o& [3 a+ n
      dic1['max'].append(i)
. F6 L2 G& C# f5 [$ Y' }print(dic1)
' d8 v" A: j% ?) ~
8 T/ {( j# e4 U3 ]- l( ?6 x5 W+ v---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}8 z6 n/ ?2 }% o$ Z6 X; d( W

Python基础知识汇总

主题推荐