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、写代码
$ U7 j) H  A' e, `( }' A4 Za.实现用户输入用户名和密码，当用户名为 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) :! p. M1 ]" s# e2 A( E% h: J
name = input('name:').strip()
7 P2 N9 z  k2 H6 `. V' a pwd = input('pwd：').strip()* R" H! k/ _1 Z/ j9 ?
6 y2 R! V5 J9 B' A4 O! A
if name=='seven' and pwd=='123' :
# x) f7 }  x" r; `       print('ok')
7 |7 K- Q- [) Z* n6 j6 h5 G' U else:/ x& _$ p) P! C) Y7 }$ u% i
      print('error')
) P% C5 U& ~- h1 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)  :, h1 X( m* [6 w+ `
name = input('name: ')9 R" M3 G  ~! {' o7 N/ N
pwd = input('pwd: ')8 u- v/ w/ A" y! j
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':+ E* M/ o0 y+ ~( i4 x& v
      print('ok')
% B2 s9 Q1 s* c: _( o  `1 C else :
& F4 c! ?9 Y2 c( @' I       print('error')
1 p' e( x6 {- r4 [* Y; w6 F# E  H1 J       count+=111、写代码
4 i& s7 Q2 T% r! j5 S0 va. 使用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) :
- x5 P2 H! C- S2 b if i %2 != 0 :
) Y, E& L8 G; K: E3 W" Y       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
1 n' n2 o; {5 |9 g8 ^2 i: w if i %2 == 0:
: {* G. ^" j7 w2 r& D% ^- o: q2 O       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". q0 R) x! m+ F
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)
9 C0 R4 J& w/ V- p/ |+ D+ Qfor i in name:
: e# b  @% X$ {: V, F print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
0 U6 r' r3 J% l. U# u6 W22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']; M! ^* H0 G1 T% z, z& Z  v
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    2 n7 Y% P% ^1 g1 v' |6 q2 a
print(li)/ O1 @% @; \) S: l1 z2 o: t. Y
['alex', 'eric', 'rain', 'seven']
: p/ k+ I  D$ h- R9 f" W& `7 u3 W6 ]c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
, M" D+ M6 Y9 }- H" Yprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')1 ]2 v) a0 K% U
print(li)
+ W  o7 M; F9 R$ E7 F/ h7 ~" Ze. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
& f2 i9 W, m; t: t7 ili.pop(1)
( R& u/ M" B% I* G5 ]print(li) ['alex', 'rain']
% Q) ~, U0 l' J. e指名道姓的删除li = ['alex', 'eric', 'rain']
( z/ ], K8 G' Gli.remove('alex')5 K2 S+ k3 `! ]$ f& ]
print(li)# ?. p, r' c/ W- `, K% Q
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
/ T: O; Y9 n+ I0 l- O' S+ c4 |2 Dprint(li.pop(1))
8 v: v9 J: M# S* C! yprint(li)& X* _7 f9 K$ V: _, p8 B3 P1 W6 L/ ^

) i1 h) R7 q6 p1 Deric
* M" D: D7 q* j( u6 W8 \['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
  ^7 ?2 V+ t- g7 d6 o* A/ Ldel li[1:]
$ N) I5 h  k! w* M1 h0 |/ @" Kprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)4 G/ o( x" m9 A" F7 A1 F
li = ['alex', 'eric', 'rain']; o7 b6 E' b/ ]0 C. ?: B: Z
for k,v in enumerate(li,1):  X& |6 u; l8 r1 G
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]2 K$ e9 @9 W6 l2 R% [7 C7 t
a. 请输出 “Kelly”
; N8 r8 ?0 S0 d/ K" g  _li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
. E# A' h7 }# M) A5 p2 ]print(li[2][1][1]). _9 z7 a& t* ]- }* V  w% C
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”5 i1 ?: y; a- K
li[2][2]='ALL'
! N( k- t1 T# h8 Uprint(li)
& C+ R3 H1 g% `7 V24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')3 Y7 @4 N) g" ]5 \0 `
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
$ M" ?9 j- n: i% ~# ]; @. U5 E. sprint(len(tu))
, z" [+ @: Y+ }6 u; O; Q, q, Y  ~b. 获取元组的第 2 个元素，并输出' w4 H+ e1 t* v1 O1 s2 g; o( ^
print(tu[1])
4 o  P9 Z: Y1 Pe. 请使用 for、len、range 输出元组的索引; P$ \* C# Q/ L& J: F. o5 m
for i in range(len(tu)) :/ W; E7 Q- n5 Y) [* \1 c; F
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)8 R  E1 i- Y$ i' ~. J
for k,v in enumerate(tu,10) :; L0 y( C) \# i/ A9 T3 y6 f/ E- b
print(k,v)) [3 o3 Z) v) p( {
10 alex* T* h3 e6 @! H! i8 t' _
11 eric
9 J* m/ k3 j, x7 W% b' e2 r7 w12 rain5 F8 h/ j, C! D

) N" L( q. H/ z3 j' l4 Zfor k in enumerate(tu,10) :
$ u9 r" ~% E) D1 E# q print(k)! y* d. G+ J5 Z1 a$ }: b  E$ u
(10, 'alex')
$ w" A5 r7 F6 Q1 h* t% d  x(11, 'eric')) T! h) Q. ~0 E
(12, 'rain')- L0 z( A& T9 d+ p3 x% T
9 k4 ~4 N- ~6 l
. y! O4 b. O! ?5 Q7 x' o$ N- `
25、有如下变量，请实现要求的功能) w# F8 _# x+ m2 f; U4 z
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
9 w7 W# D: p, H6 v$ _/ E
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
* I1 L, N& Z3 ?" j0 @. h) |. w7 Ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
2 V/ j; z5 h" [& z5 Ores=tu[1][2]['k2'].append('seven')
. c4 I" G" ?, c8 J1 i- J5 M+ C% \1 Q0 j$ b6 S- {# t
print(tu)
, A. q+ k( |( K+ {2 P0 J26、字典2 {3 c; ?  E: {5 T
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:' _# [. \1 x. V# m, W
print(i)b. 请循环输出所有的 value* c! {, Y( u/ G" y4 P
for i in dic:9 V. ?' G7 E# S# p4 o. M
print(dic)5 I& }4 P) B. s% G3 c
c. 请循环输出所有的 key 和 valuefor i in dic:3 D( Q8 f' a7 \: i( ^. h- w; ~
print(i,dic): s' B8 R  Y) o* g. w( {
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典) F9 {8 p! c/ ~. C
dic['k4']='v4'
- }- J$ V. u* }& h+ `3 U7 a3 ~% M# Dprint(dic)- v. A8 @6 U  \2 [" ?( ]- {
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典3 o2 y  C7 A6 q0 u& k
dic['k1']='alex'# G  Q- Q; V- K" t
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典# P: C/ ~$ E4 T
dic['k3'].append(44)
/ c/ t$ h' W' U6 Tprint(dic)
# M7 R; o. r' ]+ V
( |. C- N7 M" U! m  [- @g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
6 h3 L! E. f6 w- T! g" r) jdic['k3'].insert(0,44)
1 m& w" y: X+ M* Jprint(dic)
9 n3 u! W( P) O9 @3 D27、转换
+ D$ P3 v$ z' n1 _' ]a. 将字符串 s = "alex" 转换成列表  s = "alex"
8 n7 f/ t; m# M% G
- x% L: |3 @4 q* |6 q$ `$ {print(list(s))b. 将字符串 s = "alex" 转换成元祖5 g" B; V. X' e/ ^
s = "alex"1 k( y) c8 M& _9 O$ X( ^. B% P
print(tuple(s))
) P# X) P' n' t- r0 }
: f, G% r) G6 I" Bb. 将列表 li = ["alex", "seven"] 转换成元组
- C  k% P4 `/ b2 nli = ["alex", "seven"]
2 P5 |6 {5 t7 R. v) G1 i9 wprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表0 @# D7 ]/ s- }& n! ~, Z+ |6 v
tu = ('Alex', "seven")
+ l5 O7 H& j5 y  r) P3 W! uli=list(tu)
  y) y1 |' b0 {, K' |print(li)
- A  v' `2 `  I# H( U+ l) `* M) f
) |8 Y; J3 j- q* D' |. k$ s* h, w7 ]: q- w) g
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增+ U" y) S, d! C+ P  v( m3 f
# ?" N# @9 x* |' w0 t
dic={}) Q: s2 i& z" N2 }' X1 u2 X. r
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
! }) J3 w( R( U# i dic[k]=v
0 ^4 l% m; h$ h0 P2 J8 R% R; T print(dic)27、转码n = "老男孩"
) Z+ y% B7 ^! }7 c9 ^: H5 S; r$ |a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
; L* I  F6 _+ ?" Qa=n.encode('utf-8')
- m( }& R1 P6 y0 ~print(a)
& d: t' ^. T& L, Db=a.decode('utf-8')7 L+ Q3 U8 u) I
print(b)- [  l3 r' d" F0 S9 K! V$ d9 |9 e  h: l
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')- [; }; R* C- Q8 T% U
print(a)
& G2 {: U. a" d8 k5 D9 ib=a.decode('gbk')4 D, G& Z) y% ?; T7 I' y
print(b)28、求 1-100 内的所有数的和
' v5 T7 h0 [( e9 |4 @count=1
. i# W! Y* v4 C( n+ `/ E. Nsum=0
9 j( k3 ~1 c: K( ~1 l! {- v) Sfor i in range(100) :! V$ f; q# q  _* y" t( I
sum=sum+count" L( N( P8 V; n$ S% _, v0 d
count+=1+ v) Q# _5 v$ |( e
print(sum)
+ p) M$ W) H; @& k. j1 \) k' V4 M6 ]. [3 V4 R! n
count=1
. i- q& t& t; J; x. R# bsum=0
. |" Z& [3 c& g4 o; K% }2 Zwhile count<=100 :8 h' f: ~1 M' \/ G0 P8 i) j
sum+=count
2 Q. ^7 N( R8 v' M0 x0 X) w. q count+=1
3 @1 E1 O! a1 Zprint(sum)29、元素分类8 N; v9 j" N# ?* b% G+ Y
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，0 a$ S# n' X9 x" v' p
将小于 66 的值保存至第二个 key 的值中。
. D% V7 s/ D6 u8 C即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}- Q5 j( }0 I5 b
li=[11,22,33,44,55,66,77,88,99,90]# ?+ _$ P5 ^" E. Q
dic1={4 o! z$ ~  r8 u! }$ q- U0 F
'max':[],
! p, L0 A; M% y$ e0 R/ P3 S 'min':[]& O, F# G* m4 u' u
}
7 {$ q" ?% y' X, S1 `for i in li :
* k0 |5 Q! y- z if i <66 :) K+ ^. X0 M  W* c
      dic1['min'].append(i)8 A) l9 A4 n4 c) _* O' O4 M
else:7 _& I- R9 Q+ n  P$ `
      dic1['max'].append(i)
3 F8 U+ l; n9 x5 Z: Sprint(dic1)
9 O5 i9 f' l9 Y% L4 i3 u# }7 e* x# ^& P
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}: g+ g3 _/ Y( r# p2 O

Python基础知识汇总

主题推荐