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、写代码  \; Y# l# k3 n8 Q. ?7 V% 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) :
* \/ a- Y/ Q* Q# ^- ` name = input('name:').strip()8 |& ~: ?$ W7 B  O0 z! W9 ]
pwd = input('pwd：').strip()9 B2 K' {, d! M, {
8 j6 K6 U- [7 B
if name=='seven' and pwd=='123' :$ o& a  h6 L4 l- R2 w) {
      print('ok')
) I6 @5 Y) g1 ?. O else:( Y$ Y: P# R8 w3 S( s
      print('error')# d! r/ X  t. M: D
      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)  :( D- q" K1 B3 X* ^
name = input('name: ')! E- b  M) m8 k  b; Z
pwd = input('pwd: ')  W# y4 D4 Z  L
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
: a2 K0 \1 N" y, N3 J       print('ok'). {( K6 L2 g0 y2 B6 [& r3 ^
else :' f5 |6 c$ k# ^% t3 C0 P
      print('error')" i8 P4 L* l/ K( A7 E; `* o' B
      count+=111、写代码$ }: n4 V2 \' O& q) ], V% D; F& O4 _
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) :" Z2 Q3 c7 D2 B& |3 E$ K! `3 ~
if i %2 != 0 :- q0 U- o# J1 \7 Z/ _1 J+ n) ~1 M/ ]$ 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) :( ^* Y& X5 g, ~" C6 N: F, Q
if i %2 == 0:! p+ k. ]4 W1 P- z
      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"
2 \% S3 n0 z9 a+ T: h; \3 g- y( [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)# I9 {1 d" u8 w; D! z
for i in name:* T1 h, W5 k9 O& f% q
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain( O- e- p; L6 `1 ]0 v
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']2 e; {6 u5 _; q3 f; i$ k7 ~
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    - J" ~+ k* A1 v. ]
print(li)
( @: f0 {1 n$ V- n ['alex', 'eric', 'rain', 'seven']
% }) C+ s4 w% l/ S  Lc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
# o- S1 E; K$ L- ?print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')+ c; }( O  f! T" Y* G- v5 b. G
print(li)4 j, C' `! D$ K0 }, s& P
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
# P; [2 |  \$ z* A$ a* Uli.pop(1)
4 d5 M2 W  N4 H# l9 [6 qprint(li) ['alex', 'rain']
3 L( A' ?5 |1 {' L5 c指名道姓的删除li = ['alex', 'eric', 'rain']$ a* K. p- r7 z' s  l2 \
li.remove('alex')' ?5 J1 P2 I6 }" d5 d& z! k7 w
print(li)
- D) Y; i6 Y3 U$ v& h5 s3 L6 c& Cf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']" D7 G: n) L7 g& _3 X
print(li.pop(1))& H! G' g$ @; r% {
print(li)" e( J% I& a% k( T/ g8 [  r3 K

, c; ~: i, X2 Q2 `6 W8 ~" geric
4 t1 j. a7 ?- P" ~3 D* ~. J['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
* |2 J, b9 E9 T( L5 C- d/ e% ~& Adel li[1:]
1 w  t( `1 w2 x1 R5 nprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)4 z( g( Z9 O+ p- J
li = ['alex', 'eric', 'rain']
0 B: I  }2 c; }0 X5 Bfor k,v in enumerate(li,1):" P( A/ `8 C9 k+ C  G" a
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
6 I# t8 r+ d+ W8 E3 qa. 请输出 “Kelly”% \8 T5 W: g; t4 f) k
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
( n: v; j% C6 {1 d/ h1 Qprint(li[2][1][1])5 H$ f$ \( C! ^$ d
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
2 {% B7 ?/ \/ ^% j5 ^, ]li[2][2]='ALL'
print(li)
1 `& V9 s' t3 \# M24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
3 V( N; F& _& ^# da. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
+ w# F) a/ O$ ^% T! uprint(len(tu))0 L7 k+ [' I0 x8 h9 R- S/ j$ i
b. 获取元组的第 2 个元素，并输出4 j8 w5 A8 Q% i2 @
print(tu[1])( t6 l  `1 Y7 r6 J# t7 g
e. 请使用 for、len、range 输出元组的索引  J6 b9 w% b, |/ `
for i in range(len(tu)) :8 E' y8 E, o) [$ v
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
5 m8 g3 D) y+ D3 l+ Z3 T; Vfor k,v in enumerate(tu,10) :
8 `2 g" c0 o) h+ I+ Z print(k,v)
8 k% J5 m9 E! |4 u; A10 alex0 _( q+ y! i) G
11 eric* t; m' u1 j$ ^4 V6 T* Q" V
12 rain
. G' c5 ~7 M  c! w/ F6 k1 m2 z, C" k( Q$ g0 U4 Z3 X
for k in enumerate(tu,10) :
9 X7 M7 i' i0 { print(k)
4 f% z$ d' E- ^2 \' P( ](10, 'alex')
* I$ x0 j4 L1 ]: ~(11, 'eric')
4 L& }, [; y" h5 ?(12, 'rain')
3 o( G/ r. P4 _; O7 c1 k
. ?8 s0 [6 r! {, X; W& r# y. d
, F9 K" c; t9 C" r$ x0 M5 r$ q25、有如下变量，请实现要求的功能
+ q- A% |9 U; {- |tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

- Z, I$ |8 ^& i/ A0 L$ {) ad. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以8 Q. R& U$ O# ^' v; H6 S- [
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])/ ~; F9 X0 x2 [/ l9 m! B, B. ~' P7 `
res=tu[1][2]['k2'].append('seven')
; w/ I( m, l' m. u7 j
" k. B8 N9 @5 {# E7 k' o. Yprint(tu)& Y# s; I0 [" V, n: U3 S
26、字典
" u" G+ q% C- ?; ndic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:7 o0 ^  L$ P. D! Z; f% `- K. x& W
print(i)b. 请循环输出所有的 value8 m  ]& d. f. _7 M
for i in dic:! p) ]0 @3 G! p! l+ T
print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
8 E, o) F9 I$ g$ Oprint(i,dic)8 A. y4 p2 {7 t
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
* s% h! g( ~& @* c  {dic['k4']='v4'
. V5 ?4 [4 T  L  x1 z; y  @print(dic)
1 O0 R) b- t! be. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
1 H6 E* x9 N  u% N7 Fdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典" z# H. I/ W0 @2 V$ m0 P# q
dic['k3'].append(44)
+ o2 [! A% o' rprint(dic)
; u" H% M$ D) g* N0 d. O, A+ d: z" b, S5 k4 S- X
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典. m& M% r& E- N4 w! q# |0 {1 B
dic['k3'].insert(0,44)
4 e, N% _' {# y3 X+ G" A4 c* G+ mprint(dic); V+ Y8 H& |3 P  X3 `* ?9 J4 j
27、转换. p- y+ n! A& a8 e4 m
a. 将字符串 s = "alex" 转换成列表  s = "alex"
: B! W' L! n% t2 l, u: E$ l/ G, ~3 y2 G% ]9 F
print(list(s))b. 将字符串 s = "alex" 转换成元祖
0 S, Q+ I$ }0 ]5 rs = "alex"
* S) g; A2 x( g, I0 {' {% |print(tuple(s))/ J' \) j0 U- m9 [- \

, q2 j& p) l1 H, p* Mb. 将列表 li = ["alex", "seven"] 转换成元组
3 t5 j  h( v- s) L* [% e* \2 F9 Pli = ["alex", "seven"]! q5 q' S' p* S1 z
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
# n4 H8 q' M$ i# w' utu = ('Alex', "seven")
. d3 Q2 j" k  T) B" Y8 Sli=list(tu)
0 [( O/ b9 D" M: M: Z3 Cprint(li)3 T% G  C" ^/ P2 W

" w2 t- W2 }. j. t
% r) _" y  c' _3 D# ]# c, wd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
' B1 H) I8 e6 B) T5 \1 o% D+ E  }# B% d+ S6 [
dic={}
9 P: b! N# @# E; dfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面' J* I, V- r; G3 U& J: V' z1 D! B
dic[k]=v! q1 H8 u8 G1 s% @
print(dic)27、转码n = "老男孩"
1 d: ^3 K, M! B4 C# ]" fa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
6 L8 e+ \4 {" p9 La=n.encode('utf-8')
+ z3 {% a' [" e$ k8 C: W7 cprint(a), d! x- d  X9 d! j6 ~3 ^0 V; S
b=a.decode('utf-8')
0 G! c. s7 K, W& D. ]print(b)
& I" ^( }7 j( L$ M- t  t$ ]b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'): \9 P! G4 u% k& t% v& W
print(a)
/ u, S+ K. N- o8 Kb=a.decode('gbk')- c; a4 h  [' N3 H1 p
print(b)28、求 1-100 内的所有数的和
- k6 I1 b3 v' [6 l7 T/ Rcount=1
, O& H# L3 u' O4 s1 ]sum=03 e' Y7 @! \; k, j6 ?: F; [
for i in range(100) :
9 R6 B: q/ S+ E4 } sum=sum+count
+ e5 n+ S7 A, Z% f4 r count+=1# X8 B- P/ I: @7 N. K5 g
print(sum): |. O1 H0 x/ a) a4 |

6 x! Y/ {9 A9 K# x: ccount=1
& H' `& w2 ~# Z4 S, G+ X' K* rsum=0* d& A; A. e0 q% G
while count<=100 :
5 M: ?$ T! t( Z" @ sum+=count
6 _4 m+ ^; s+ j- S7 \ count+=1- r$ t: _7 r7 J% j
print(sum)29、元素分类
" ]6 M1 H2 m2 {8 @3 ~( `有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，1 J; `( T' u  W' w7 G2 C
将小于 66 的值保存至第二个 key 的值中。
( @  P- H8 h. I即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}/ H' _7 |' x- d3 v% R
li=[11,22,33,44,55,66,77,88,99,90]
' ^2 _6 I7 T# Y* mdic1={
5 R1 `1 Q6 }* L  t7 Z 'max':[],7 j  L7 {* S' ?6 P' D9 O
'min':[]
/ R9 h7 h5 [* X# c/ _3 m1 K0 [}/ d( E5 x* a2 v2 z: F" R. r
for i in li :; S  p; u, m) a8 [
if i <66 :. D9 ^9 W2 j9 P# W- ^0 x
      dic1['min'].append(i)
" e2 _2 @  y5 O% r$ ^ else:' ~. J6 i8 \- s; c2 C# e0 j" a' F
      dic1['max'].append(i)
1 r, Y# v3 F% b( Y7 x8 N2 U2 P! rprint(dic1)9 @/ X: Y8 O$ ]6 l

! n2 b. x6 c2 `---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}5 R4 u/ Z9 @- Q/ U8 E! ^

Python基础知识汇总

主题推荐