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、写代码& ]7 c% |0 P! f2 B
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) :
, Z+ n, C9 [5 Y* g name = input('name:').strip()3 u: ?. h) ?9 Q- j
pwd = input('pwd：').strip()
; K7 p* E# \# v% H* ~3 u- J% O0 T. q# ^1 E; C. h5 A3 ]/ L4 `& ^4 e8 Z+ @
if name=='seven' and pwd=='123' :
8 j, ?& u; z% o       print('ok')( e5 P* F% B9 U' X6 Q1 k3 V  i. m
else:
+ C' N! ~6 u1 a/ E       print('error')6 W/ P, }0 r4 o, q4 ~- p6 F
      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)  :
, y6 {% h$ r8 k, z1 v name = input('name: ')
( e. ?. O) I3 ~4 f- F- K% Q$ E8 u+ ^ pwd = input('pwd: ')4 a3 @! l2 U2 `( e0 G8 r
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
( f' ]9 P' D! o+ f: H  n9 U- A       print('ok')
: w: S4 a5 r3 A- e/ R5 A7 r else :
6 H& }% O1 T- M; _- }; m       print('error')
% g& ]) H4 {) ]+ F; Y% g       count+=111、写代码
$ S( Q. \* B/ M1 k  p% ~. G2 Fa. 使用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) :
  I, D' T% Q% w: [) y/ T if i %2 != 0 :
- W! |( @" N# \) }. W* 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) :) [9 U1 O/ A* R! |6 {
if i %2 == 0:& u, D  D- O# B9 [- p3 b( A
      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"
9 V/ n/ u% }3 Wa. 移除 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)
6 \- }+ Y: m  q. o) @( U3 efor i in name:
$ u4 N7 O2 i2 y. N2 k print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
! r: R: Y; T7 T22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
* S! a9 l/ x0 e2 `) f* Pprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
9 T% L7 k! Q* F9 Uprint(li)
4 Z. i% A* [4 ]9 X2 h( q7 f" z0 c ['alex', 'eric', 'rain', 'seven']: i: t3 k. @! {# S3 h2 \
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
* O5 |( \3 L  H! `( vprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
' J# p* w2 W+ R8 T. A) P- p6 k: o* Gprint(li)
% h7 \: [! `+ q% I9 z* ee. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
6 D/ t$ E2 b* oli.pop(1)
9 b6 E# t- ]7 x. w7 uprint(li) ['alex', 'rain']1 ~0 {! \9 N% h( ?9 K
指名道姓的删除li = ['alex', 'eric', 'rain']% l- D7 t4 v5 s9 N' _
li.remove('alex')) ^/ I# T5 f# K6 D; u- a9 D: s
print(li)
8 B$ B5 W1 \6 C3 d% tf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
. F% f0 n. J5 ^1 J2 q" d- l' Mprint(li.pop(1))! J# k% Q" {3 j! h2 v4 m& K. e
print(li)
; J' K& W% `; j5 _; [" A; \9 y$ t% |6 H0 o- ^. {9 K
eric: h8 G4 C* E. s$ V! Y2 X' p
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
! S* _  |. w9 `9 O/ Adel li[1:]
% h+ |- p5 s; O4 ~& G7 }print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)$ q6 Q. n4 s" T6 j8 m1 |( S
li = ['alex', 'eric', 'rain']
9 y6 `7 i/ k0 Q. }7 Xfor k,v in enumerate(li,1):" g* b7 F* w- }2 U7 k& B' q. W
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
2 M! }; r, A; Q( Wa. 请输出 “Kelly”
* U. c1 z- g0 h2 k% @; ^0 bli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]3 ~; j# a( K+ ]3 q$ Q( B% }
print(li[2][1][1])
: A4 w. F4 N' S& ~/ ?4 V4 a& ], sb. 请使用索引找到 'all' 元素并将其修改为 “ALL”  q" B5 q- c; X. \7 ]4 I! u7 \
li[2][2]='ALL'& n- d4 K$ h* S# L, c4 r
print(li)
% Y; }* ^- X- f3 N24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')2 a7 R  |3 ~4 ^9 T0 Y" m) ]4 l1 z1 c
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')/ L- _, C+ Z8 o- M5 `: ]) |( O
print(len(tu)). |9 S& O5 }. f& B6 J# Z
b. 获取元组的第 2 个元素，并输出
- {0 [+ k$ @; N8 P8 Y8 W$ i5 qprint(tu[1])  G: {/ U4 a# u/ k& ]+ ]2 b
e. 请使用 for、len、range 输出元组的索引
) }' V5 O- $ S( O# ?  M' f0 Lfor i in range(len(tu)) :( K' c2 $ c0 j
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
6 E( Y9 Y# V, E3 D* Tfor k,v in enumerate(tu,10) :0 _& S  g' V% y$ U+ t+ y" I0 E8 ?5 ~
print(k,v)
% Q: \, U# P: U1 F9 t10 alex0 i, d4 Z) R) |  @  ~, z
11 eric$ F: Z  p; Z, |
12 rain& {$ o0 h5 h1 s9 S9 ~% u

+ N  g, {2 d$ Y' e1 Cfor k in enumerate(tu,10) :
" \- r6 }7 t7 _ print(k)& M7 @$ y4 H. }# b  D9 S
(10, 'alex')
! ?- e# e5 @6 l0 V2 X(11, 'eric')4 [" O' G7 @7 }2 h% \/ \
(12, 'rain')
2 W2 ^" s) E1 o  w
3 S% k" c$ Z0 k* D% }4 z& D8 z# k# K2 F5 g
25、有如下变量，请实现要求的功能
: d$ |1 Q3 F% b% |. D% z' i* o8 Otu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
% P9 ^% w5 A9 P! E
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以, e3 m% @2 e2 ?
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])/ z+ U( W* T, U
res=tu[1][2]['k2'].append('seven')2 P' N* K8 I3 o. t; w! i
: B4 P. c% X" z) w( P
print(tu)& C; g1 ^: C% [0 |5 B  c* _
26、字典' n- S8 u$ k5 p% a, e0 u$ d
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
* @8 O. f' Q& x. x5 _ print(i)b. 请循环输出所有的 value4 T* n& b& A% ~% y- _& J7 Z1 Z
for i in dic:
6 D# H( U3 U! p0 E print(dic)3 j' S2 V2 {. i1 W5 [1 k2 d
c. 请循环输出所有的 key 和 valuefor i in dic:
9 e/ M; U' k5 {; Z* B1 fprint(i,dic)/ }( T8 W; [" {- A9 m
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
  S$ n" M7 @) J8 zdic['k4']='v4'! R# v, S) O- o  N' g
print(dic)4 \' D3 ~* x* L8 Z
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
# V! z  L* _  ^5 sdic['k1']='alex'
- K) F6 o  K. L. Q: V- _* zprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
; U6 H* G3 B0 D* x) v, d& U. Udic['k3'].append(44)
* y4 m7 j9 U9 u& N" `; pprint(dic)0 V" N  r6 \2 C$ m
( d( t- M: v% D- x, V- s+ R
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
% R9 K( O& n$ R' j: cdic['k3'].insert(0,44)8 H, J: O$ m1 W. E. W
print(dic)4 z' e3 R6 D. B0 |+ A
27、转换3 X4 X0 U. o3 @" }# H0 t! ~
a. 将字符串 s = "alex" 转换成列表  s = "alex"
8 Y/ x  A" _) D9 Z- \2 W; `( E4 m2 J
print(list(s))b. 将字符串 s = "alex" 转换成元祖
2 p0 K$ `+ h8 L' ks = "alex"
/ `% y" t8 }! N2 Eprint(tuple(s))
0 ^' P- o# ^, g8 U+ ~" ]/ L( h& w3 F( u) g3 M9 A$ ]9 s# Y' H
b. 将列表 li = ["alex", "seven"] 转换成元组1 t8 t; z% y" X0 t( a2 N
li = ["alex", "seven"]
+ G; f" N( M3 }$ Vprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
2 q- S, i1 q0 A; ?tu = ('Alex', "seven")5 V1 }- h9 B: y! Y: P4 }% W
li=list(tu)
- J: m9 S0 n+ l3 pprint(li)
+ y( \3 |. }( S) M& u* C" i: ^3 I% ]' J# M6 L
! h/ v8 D* G* q/ }
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增$ ?* C" V7 @6 e4 G$ R. v! K

/ n. x# ^& V0 l* [4 s3 Pdic={}
8 M3 O" ~0 W; j' G( B! [$ d8 ^0 L+ k* yfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
  ~7 u* h; K, s0 }- J& A6 B dic[k]=v
. N% r9 j1 |7 e1 |* k+ `! E# q print(dic)27、转码n = "老男孩"
$ h% O) s7 N& f( z, S! |, g2 Ta. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩". J3 x! }; U4 C$ K. _
a=n.encode('utf-8')
) K# Y% e( j0 Xprint(a)
/ J" L; e) Z: j/ s% r& X& [b=a.decode('utf-8')" {$ D8 b- T2 O, e, {6 G  M! o
print(b)
) F( r$ X6 b2 |0 _7 d* G, mb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
4 R  l# J, ]1 pprint(a)
4 f9 {1 p' Z2 ~2 L3 o( kb=a.decode('gbk')
: J0 b9 k+ k& F2 o' }  R! Kprint(b)28、求 1-100 内的所有数的和* R: g* m$ B; ]. m
count=1: N& g2 ~5 ?6 n& m8 f
sum=0
8 o3 g6 P0 O5 q, I9 Cfor i in range(100) :( R" _+ p6 {% L. \1 i0 b% a
sum=sum+count  \# ^  e' b4 ~: n0 I) _; q$ U
count+=1! R3 q2 |2 K% j- b+ p
print(sum)# h$ Z, O" T! h) g
8 F8 Z$ E* P  f% z% o
count=1
4 ~/ S7 i( |* u6 `$ }) Isum=0
2 }+ n# j1 B& |while count<=100 :
6 `$ T5 X( R, t6 ~4 |$ B sum+=count
) d7 Y. p* T2 X7 m: g- M count+=1" L) V$ S; F( s; F9 Q0 {6 ]; A: G0 h
print(sum)29、元素分类
) y+ v" B( n& V: i4 P. i有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
. v- f/ Y8 K/ ]1 Q& W将小于 66 的值保存至第二个 key 的值中。
4 b  k& `# F- ]& i即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
2 q7 |1 K9 ^/ c( a* Lli=[11,22,33,44,55,66,77,88,99,90]5 g# j! K5 u4 u
dic1={7 p9 K9 }/ K/ s' P9 t, E  d5 M
'max':[],
1 L- O3 G% W4 e6 F% _6 F 'min':[]
1 |* m9 b1 x2 @0 G1 P}  Y9 i8 N$ c5 |1 R6 g
for i in li :
$ E3 ^- T" n8 ~0 N* u$ I  G& g if i <66 :3 C; y- {3 a( y/ V: i# z
      dic1['min'].append(i)
" P# ~4 N; K5 e( Z% j else:" `0 z: V% }+ S" y& g  {
      dic1['max'].append(i)
5 ^9 Z9 t7 u/ x3 P! A, Aprint(dic1)* M6 m, i4 `- }( @; R' P( \$ P

( Y. r7 }1 l+ H- N$ D6 F---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}! M0 @! u/ \1 \( `$ M4 F

Python基础知识汇总

主题推荐