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 {  E, h7 w" V" ?) d9 a5 O& ]
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) :. U1 A  s2 q: t" d& ?
name = input('name:').strip(), O  i8 r: ^2 D: G3 i0 i: s6 J0 j
pwd = input('pwd：').strip(): ]& f1 q- `1 V& I2 @
+ {5 M1 f3 V1 `1 }8 i& {( L# k
if name=='seven' and pwd=='123' :" S* W8 N$ ?$ L. P& H
      print('ok')' b: r) }8 `$ e( N% H- E1 L2 f
else:
8 Y0 G# {, ^  C) c% h- y       print('error')
) E) Y% j( ]0 \8 u" S. L3 E       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)  :' a8 N$ i5 |2 U
name = input('name: ')+ s+ `& d( b- w, h/ K, [4 ?& V  C9 f1 b
pwd = input('pwd: ')
7 L+ N9 v/ g4 m if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
3 D- m2 j; F5 l! m  J% Y; h       print('ok')
7 u5 y# R' Z* v- H else :
$ }- a0 D" c' i3 l, n! m       print('error')
0 z6 }+ o' d/ w4 C       count+=111、写代码. }; j5 m% g1 Z: D5 C0 v
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) :: F6 S  [, h- Y/ U
if i %2 != 0 :
4 O1 |! M: E/ M: E. k3 I       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :& {. D( Q  ?6 m( j+ f& W. m
if i %2 == 0:
' N: v3 P0 m: B9 {0 R  u7 ]       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"
; C. w  F% {1 ~" J. p2 Ya. 移除 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)
% U# |6 L8 f3 c) ^( ffor i in name:& d% t0 S0 N" m" z  @( ~
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
! O7 [, w+ D$ P' Y: l0 u22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']! P8 w3 O; U$ ]$ D2 q5 z
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    " n+ G' U( q8 m4 v
print(li)9 {) L/ ]1 y, d
['alex', 'eric', 'rain', 'seven']3 D1 ?9 t7 b( g9 B  {
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'); W! P$ d) p' W% m
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')1 `- I" M5 v% }5 `
print(li)
2 J# N3 J( H0 f1 ~+ f. ye. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']2 M! N' K& `6 r
li.pop(1)
& J) o! U& A- E& H1 n$ w/ Uprint(li) ['alex', 'rain']* U6 K2 g3 d& I
指名道姓的删除li = ['alex', 'eric', 'rain']
. }2 E  t8 M2 D/ K" i9 _- R1 u/ ^li.remove('alex')3 C; R7 P' b# r1 n8 z8 W: }+ c8 X
print(li)4 C- I% ^& \3 f- z; C
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']$ t- c' M  y4 S5 u" ~
print(li.pop(1))5 n6 K- y! T0 G3 i0 O4 p
print(li)
8 d& ]+ `/ Z! P1 c+ m+ X* x0 O! ?8 E) w% e( \4 J
eric: u. z" _' M; L* o8 l
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
" q& R, v7 [8 C  [: P: wdel li[1:]
7 V, M; E1 Y1 K! N1 V& |+ iprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)7 w7 w% j) c% w- ~
li = ['alex', 'eric', 'rain']1 U; z- i" E( P) a
for k,v in enumerate(li,1):) S3 N( @/ j8 P: I* ^* c6 ]
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% ^! K+ S# ^0 U# Y/ @' Z4 t0 Ya. 请输出 “Kelly”: T* @/ S: ?; O/ G7 h9 t' h
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  D1 q7 s, I! @2 J4 Q& U4 zprint(li[2][1][1])) W& v0 O% r" W1 S7 v( C8 d  G
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”# S8 G7 a; m3 x# S- I
li[2][2]='ALL'
; t& ~8 C" m: ?- Hprint(li)
, ~+ i' w( N5 U! {5 F" q! ]# p24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
9 E5 F" F' L: l9 r! N; ga. 计算元组长度并输出tu = ('alex', 'eric', 'rain')& U! U: H0 c0 @* a6 k
print(len(tu))  q& V; B) t4 R1 ?& f8 i6 c$ }
b. 获取元组的第 2 个元素，并输出
& G/ H1 Y0 l) ?% J7 h6 x) sprint(tu[1])
/ c, b# S2 t1 ~0 P- E2 b8 je. 请使用 for、len、range 输出元组的索引$ R! J+ |& T/ z; C1 z; B# `* G% w
for i in range(len(tu)) :7 Y: H  R8 I" {
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始); L& r  f; W0 t' X3 J2 _, Y
for k,v in enumerate(tu,10) :
5 [/ N( [( l# |7 s print(k,v)+ n3 r& l8 |9 W& v9 B( _) s" f) H6 M; D, O
10 alex. }* Y/ s& u& z1 w$ X, U
11 eric
3 A  {- }9 }( U/ V& I. k; z12 rain
8 n" D6 n3 V) M* S7 R" p; q! Z
6 p1 E/ N" Y% u7 a! }for k in enumerate(tu,10) :
7 P* N4 h5 p6 b2 i! a print(k)
+ |1 y$ G! [& q+ e7 ?(10, 'alex')- }* S  B2 D, H1 a! U
(11, 'eric')
% `5 D8 G( m& {: e, _3 C(12, 'rain')
5 c! m9 M# J- B5 c/ [. ?5 A  w9 t4 ?! g8 ]: J

4 j" u* `2 S' C6 |# i25、有如下变量，请实现要求的功能3 R  J1 s$ @* s$ |2 n6 t
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
9 B0 K3 c+ n8 X: ?" e
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以8 S% d7 r: t# D. {4 g+ O! T
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
/ h+ k8 p$ f( C9 rres=tu[1][2]['k2'].append('seven')
/ M. B, T' z+ v4 |1 M1 w: m, a- d% T* \
print(tu)
5 N2 o3 x) _) j9 S26、字典
8 t, j9 m3 U; Y% T4 [dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
print(i)b. 请循环输出所有的 value
7 o. C: l# `6 h0 Y* u$ E) g* Cfor i in dic:
" D3 q* n% K0 `. A# n print(dic)$ H3 s+ E& _6 {$ ?5 A
c. 请循环输出所有的 key 和 valuefor i in dic:# U. Y9 e* T+ N4 h- D* i1 h$ y. E
print(i,dic)
; v" T( A: j5 Q5 C2 n* cd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
$ Q$ e4 v- m! }7 l; }& odic['k4']='v4'
# D: s6 G, e, ^8 U! h# Eprint(dic)8 z1 [4 ~5 c. X$ }0 z+ w4 w
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
" S0 m1 Y" G- Y+ G- U7 r' i* B% Gdic['k1']='alex'; v$ K) f' g4 P# C+ o& X$ r
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典2 U8 f3 _! T# f- G% p+ k
dic['k3'].append(44)
! Z. j+ h7 A# _  M* O- M8 w6 Pprint(dic)
7 P0 a9 @# X) g# o0 ~  S7 {) V3 ^" ]
' O8 `) Y# z' P" q0 q& ~- @g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典) U7 F7 B( H9 z6 W& g) e$ t8 ~8 K+ _
dic['k3'].insert(0,44)
! A; L5 z$ Q* r. Pprint(dic)
% g9 p# h# ^0 o! k/ W8 q& e27、转换$ c0 y5 V! D  ^% ?
a. 将字符串 s = "alex" 转换成列表  s = "alex"2 A+ C/ X7 N: I) V  }2 X, M
) n  O, _( u$ T% Z4 n( V: H+ F6 O
print(list(s))b. 将字符串 s = "alex" 转换成元祖5 |# q  w1 w4 M. s8 d% q3 G7 o
s = "alex"
+ r6 U6 c, f4 {5 Zprint(tuple(s))* g: r" t7 C4 B: i# E( X/ O
7 ]7 i8 Y6 |/ ]1 E* }* D
b. 将列表 li = ["alex", "seven"] 转换成元组) X1 E4 c8 F- x) B
li = ["alex", "seven"]
" j. S3 X) k$ r( a! yprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
* J' r. W; k- e9 Vtu = ('Alex', "seven")
5 @+ o% x% [  m7 h$ dli=list(tu)
. O1 W# B- x2 A( Z1 Pprint(li)2 I) L' q7 W  A6 R& k
! N% G7 ^- U* n$ d
* {  t3 Y2 d6 {; ?3 o) z2 G
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增" I. F9 T) D5 A& G3 X8 v9 R

/ P' y; D; S3 ]) v! mdic={}
. `  [5 W2 N5 `, hfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面2 I; W4 E" {9 Q' n( d
dic[k]=v
/ O% k6 P6 S! N5 Z, K! N print(dic)27、转码n = "老男孩"; \* o9 ^% ~, w+ |- R/ }
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"' N8 n+ R) i8 g+ z
a=n.encode('utf-8')
4 D+ E! r4 S8 O: I1 }print(a)
! i3 m2 W  |0 n) O! f6 K8 L3 Bb=a.decode('utf-8')
& F6 |- H/ j/ z$ E9 y. i" pprint(b)
+ t: a' @# |1 k( [5 f6 H8 W* qb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')/ N2 E- w, H+ \( S
print(a)+ b5 G% z, b; \" \# y  j. N- b
b=a.decode('gbk')/ E2 G9 J7 I- k
print(b)28、求 1-100 内的所有数的和
/ L' O* u2 L2 t/ V, U! A/ A4 Dcount=13 ^$ u- G# r0 U8 H0 t+ P/ W, j
sum=0
# {" n9 ~+ K+ W3 Z- cfor i in range(100) :9 a) ~: s- N6 R+ E" R( u5 m! r, r. {) L
sum=sum+count
; h" Z8 ^: _0 u0 ~! J  l; Q' C count+=1/ ~6 W; P, l( `3 Z, y$ x
print(sum)! v' t& ~2 j7 S3 E4 s' y

! s5 J& ?2 `- q+ V/ [, Gcount=1
; h4 |. z5 d1 x. u& N/ xsum=07 P+ d# q0 p" W$ {+ b
while count<=100 :
. l6 Z6 C4 `: W+ ~. @ sum+=count
" k) O. K' N9 T% I7 q/ o count+=1
6 Q! T* m! m. L+ T( pprint(sum)29、元素分类- e* |4 U) }2 x& o
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，2 O$ ~8 V+ w) i: _
将小于 66 的值保存至第二个 key 的值中。
+ {/ x/ Y, o$ _: H即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}) g! c+ C% ]2 t9 f3 S, |; d/ H5 N$ L
li=[11,22,33,44,55,66,77,88,99,90]
1 Q- q1 T6 c. w+ ddic1={# H* u- O& n7 c1 ?$ V# R  O
'max':[],7 X8 e5 s. H& s, b. z
'min':[]# G6 L1 P$ C$ x0 E6 y, \- L
}
' d" @& Q# l' d. pfor i in li :
! G, B( O' I1 U! V if i <66 :
& q, C2 |( ]! P6 r! G$ w+ r- f. u       dic1['min'].append(i)
2 a' ^* U5 Q: ?9 r' g else:
# ~: g- O5 b( B       dic1['max'].append(i)
0 |4 B6 @, |' M/ W: d: a/ \( Xprint(dic1)
' \- z# [- R) d6 h9 ?/ y
- w. ^+ V. R1 n7 g& y' O; i---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
7 e7 T! i7 N; L% L

Python基础知识汇总

主题推荐