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、写代码
- p. F- R/ z, J* w# _3 ma.实现用户输入用户名和密码，当用户名为 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) :
& L5 ~" d8 P3 C  O name = input('name:').strip()6 v% P3 K' W2 L3 {' A" P
pwd = input('pwd：').strip()
7 }- r/ n! J) `  H! x* O( M# S9 e9 V) e: f8 O
if name=='seven' and pwd=='123' :6 g' v* w8 @2 h$ t. `' _7 W
      print('ok')3 k/ `* }/ ^3 I. A. _# P% q
else:
+ O# W* @8 q: s7 @. A( t       print('error')! S8 y" z  s' z! v2 ~7 F# N; W+ C
      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)  :- j5 {" k9 B6 U5 B* e7 b/ I: L. y, A
name = input('name: ')
; ~) Q) p$ p) A4 a! s+ F pwd = input('pwd: ')
2 U9 V9 M+ O! @7 g/ C' x3 E' i5 Q if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
- G# P  o0 m3 @       print('ok')
' |! Z! n8 ^( Y$ e, h& X% G else :
3 {" a4 m+ i! J) t& [: A" }       print('error')0 S" |. U& N) y! ]2 i: y: `: _
      count+=111、写代码
/ j" O) k' ^& m+ h& |# ~1 A1 t" z- }/ ka. 使用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) :
! j6 l  A5 j$ Q) A9 b if i %2 != 0 :$ l1 o$ E+ O7 H5 ]( M
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
, g3 h- x; H. Y% B7 T if i %2 == 0:
. n* H8 d" Y* e# n! r- e6 K) X9 J       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"
; i4 O! y+ I* U+ U8 na. 移除 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)
% V" o- X+ Y, N( L( L: q# b' q, `for i in name:
9 U& x: ^: V' ? print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
+ y; d8 z1 Q9 v  }4 e+ p22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
" _. U8 `+ V2 Z, sprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')       s& Q( R, ^6 D4 ~
print(li). K% J7 {% H0 r  a; y
['alex', 'eric', 'rain', 'seven']# ~5 t9 v/ g3 `, B. i7 r
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')$ U& ~; P" Z2 K0 u
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
" ?. U3 O9 \, t. @# `. Xprint(li)
& \# j! @6 i; l; h& p1 [: z# u% U3 n) ?e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
# t; K: n1 P( D$ y9 ali.pop(1)
! B' W: P6 D; `! m- t# f6 {6 tprint(li) ['alex', 'rain']5 e/ j# B% s# r  K: V3 u6 R
指名道姓的删除li = ['alex', 'eric', 'rain']3 \! B, k4 }' e1 b8 v8 P
li.remove('alex')) P2 {& l' j9 }9 d& q
print(li)7 |' c. f. J+ ~5 u
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']6 R) M+ I9 l4 l
print(li.pop(1)); B0 l, t+ e8 y" o! e" H$ \
print(li)
. }& D  {+ Z+ g% B
eric' s/ N8 u3 y* i, Q: o" E7 u: s
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
* ^# t7 O% l, m' R# ]9 M4 Y& Tdel li[1:]* U& z' I: i% j+ Z, M3 n
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
6 `. ^/ c2 S: P. I5 `( c4 wli = ['alex', 'eric', 'rain']' `" ^+ [# ?( q: n7 t4 p$ i
for k,v in enumerate(li,1):2 P  w) e9 g) v
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
, m; p2 t: U9 o9 o: i8 `a. 请输出 “Kelly”  y0 u5 ]; N4 e- w+ C5 |5 k7 `6 e  d
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ i0 [; r9 {/ O  @- Fprint(li[2][1][1]): N  J! W* n; w( ?! ~7 X: o
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
' z3 {4 r9 z. [li[2][2]='ALL'
% t9 B" V1 @6 P+ S/ R. s9 Aprint(li)
4 i& ?  K5 p) z5 W8 ^24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
& N" K7 Z8 f) p8 ka. 计算元组长度并输出tu = ('alex', 'eric', 'rain')1 M5 i* P; E5 q- T5 b" q
print(len(tu))
0 c% v" B1 S6 {+ Kb. 获取元组的第 2 个元素，并输出8 r/ ?  w1 N8 @
print(tu[1]). r, d  U5 o: e* x$ O( T8 ]
e. 请使用 for、len、range 输出元组的索引, u( O! |1 o. P
for i in range(len(tu)) :
- |! w8 Y: D2 f) v8 ] print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
" I7 m, j! B) Mfor k,v in enumerate(tu,10) :$ R: V0 I( r) Z) B
print(k,v)
- `5 ?- b" O& o6 _# q  T10 alex$ W  i7 a/ H3 h9 b7 [
11 eric
0 L9 p# J/ O6 a6 r0 ?4 y7 w7 q12 rain
( k2 {  `3 ?- `! B, F6 f: l- @4 {; v
for k in enumerate(tu,10) :+ A2 c# @$ G" x1 a- d& {
print(k)
! K9 ]5 k& J; H) c(10, 'alex')9 @8 s1 e& J* D/ `3 s% q/ t' ]% M1 @  ~
(11, 'eric')3 T0 t: F. Q/ N' e9 ?
(12, 'rain')$ X5 z6 H  p, P2 b# H1 |5 s! m
$ G) K1 ]2 K# k

* u; s- c( X; i$ A% r2 f/ z25、有如下变量，请实现要求的功能) |7 C' p4 h, c7 d7 c8 P
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
2 Z! T5 |% Y' F
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
, `; ?3 M- V& p# e' m9 O1 vtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])$ B8 t% Z% a. u9 I
res=tu[1][2]['k2'].append('seven')
- o7 ?5 m; Q5 t1 g  y4 W9 A# w7 o8 s( B* ?. R: e$ P+ _" W7 a
print(tu)
  R  G% r4 M! G* @0 p2 d" y4 Y26、字典
4 `' Q; h# X' Xdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
6 H' @2 O( R: R, ?4 {0 o1 Z print(i)b. 请循环输出所有的 value
$ w9 L- V: p2 |& {1 Lfor i in dic:
: z9 T/ B, e$ `. ~: b$ Y print(dic)
- e8 @  k9 e& [6 U) h( dc. 请循环输出所有的 key 和 valuefor i in dic:1 D( o; l0 d' _/ ]
print(i,dic)
% `6 U6 `4 g4 M2 Od. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典- S  L3 B& a+ G# K# W6 i( \
dic['k4']='v4'
) {) u& f" d: `. |0 P* Wprint(dic)
6 U- o" M1 `! a4 s" P8 qe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典5 Y* L" |; C. }1 u
dic['k1']='alex'
4 H. J: c9 b* x8 z1 ~0 c5 k6 ]print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典+ K3 ?: R* p0 q" S( W+ ^( U
dic['k3'].append(44), k. l/ V  R( O  m3 [3 b
print(dic)# H) e& w1 L3 V9 ~

; A0 C% C$ ]7 ?. t( x2 G" N3 h& Sg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
2 g) F! |1 l* Edic['k3'].insert(0,44)7 U* U, w7 f+ R' B$ J' Z
print(dic); [4 ^( l, J7 }8 m
27、转换+ F+ T8 c5 F: v8 l9 q1 ^# e
a. 将字符串 s = "alex" 转换成列表  s = "alex"
. @. }( l. \( `" h6 j% l# a
% v8 n3 p+ Z" A( |$ @print(list(s))b. 将字符串 s = "alex" 转换成元祖- {# i3 I1 a1 @7 w
s = "alex"- R! a" V  a" S5 l, H5 y8 L
print(tuple(s))+ K" C" g' A9 F$ l  ~! i. N; `

5 t* f% V7 K4 K( @' w/ |b. 将列表 li = ["alex", "seven"] 转换成元组
# J) [* w& z$ `* r( @3 I' }8 Sli = ["alex", "seven"]4 I- @, M8 S9 \
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
% O9 g% N6 n& O  l: _' itu = ('Alex', "seven")
, a2 Z6 h5 j4 Y& P/ ~5 t8 J* Wli=list(tu)
9 D( M5 K$ g, ?; q9 Kprint(li)
) v0 W# ?; V) J/ n$ b
! {, p6 C; X: i; w( b: z7 V/ Z) p0 s( V9 f1 D+ t
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
) ^+ [0 A: h) P3 ]% r1 V- Z% N( y/ B* j* H
dic={}4 N2 t& i1 y' l1 L- G
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
1 x" R6 C, ^3 x. ]( ?' [5 d  Z dic[k]=v: t# ]  T2 F; \
print(dic)27、转码n = "老男孩"
2 P& V8 i0 c9 S0 c. B. ja. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
* R( y& s+ y6 Ua=n.encode('utf-8') 7 m* ?, p; H* T5 B
print(a)* }8 g& P8 P6 i9 Z9 F% T
b=a.decode('utf-8')0 N6 @5 s4 O# t# [6 s& s
print(b)- y, e: t* ~/ c  q. W1 Q; z
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
8 k: ~9 h# f  D. tprint(a)
( X  p' ^* C4 mb=a.decode('gbk')
2 k) v! p6 `$ A+ a' m0 s0 {print(b)28、求 1-100 内的所有数的和$ D) p4 [3 c/ _% z" d
count=1
+ C. Q( g6 j" H5 T1 A" O+ g. }sum=06 \, t, @, V' e) R
for i in range(100) :  d; h0 r2 T7 D, E! [( I2 I
sum=sum+count: o: P9 i- a  o+ c) d
count+=1
* o9 i: k& w7 o* P" l+ Hprint(sum)
6 s2 E7 P& S( X# c) n3 y
& k8 c* W2 E1 k: m. acount=1
5 r- u) e* z. `3 Fsum=0
5 g/ [, }# D( }, Bwhile count<=100 :- z! W! m$ T7 @0 ?; O* X4 L
sum+=count0 M& B# H9 N# E. W: T3 f- x1 y
count+=1
& V2 L7 Q& t; x' Z2 H) {9 H0 jprint(sum)29、元素分类
) A) c- N& L% q' Z$ c8 I4 R有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，- G# E% S. o) i8 o7 x9 w
将小于 66 的值保存至第二个 key 的值中。
9 K! H! |* h' q8 ^# j即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
7 C6 o: z; I5 F. V. \li=[11,22,33,44,55,66,77,88,99,90]
: k: j+ Q# i+ f9 z* [5 Kdic1={1 U) G' ~/ v' M2 O) E
'max':[],
6 W$ d( ?0 m! Y1 X7 d2 \! z2 ^; z 'min':[]7 W' c4 a+ c3 a( _6 {- b" X- b9 K( z4 V
}' l$ E# w! F1 b5 J2 `
for i in li :
% B# H# K" x; q4 Y) E( U' u if i <66 :" y2 y! d% i4 ]; P2 W8 S. [) ]0 Q
      dic1['min'].append(i)
% q% S0 n! O4 K6 ` else:' @6 y# L0 t% a! i/ Y# ~
      dic1['max'].append(i)/ g' m# X7 o. B: Z
print(dic1)
. T8 _$ i$ \  j( _$ P" `! _/ E0 J0 L# F* O9 Z: T6 f+ R& @+ ?
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}3 }: v' V! {0 L! u$ r

Python基础知识汇总

主题推荐