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、写代码
4 A, j! y' K$ w# Ia.实现用户输入用户名和密码，当用户名为 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) :$ g1 C! r' r! l( Y' Z
name = input('name:').strip()
! A& k- T8 B2 ^/ o! J& Y0 c pwd = input('pwd：').strip()
- n4 K$ C; S: x! j# a- D+ G
3 Z1 o6 T: F. n9 q# l( A$ n$ r if name=='seven' and pwd=='123' :
9 `5 T$ c0 }2 n) Q6 p7 F2 [. Q       print('ok')+ ^" z: {# K3 h$ i( m, |( c) W0 V
else:. |2 E. S) ^% f  }& |5 k
      print('error')2 @" e2 d6 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)  :. A& z2 x' d+ a, o9 G
name = input('name: ')
3 }7 K9 J+ R3 `! h; G' I9 V+ b pwd = input('pwd: ')
* u% T6 ^& @. ~& {3 |  d( U if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
. W/ }* i1 z6 {0 ~( _" W       print('ok')
) F! f! U5 Q4 J: C% D$ y2 j else :
7 {, Y; Y6 N. @& V5 K$ J       print('error')8 D- H2 R3 `4 }; C! |$ Z
      count+=111、写代码* ~0 s9 ~" W% c; f
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) :
8 ~7 v, ^2 R: v4 B3 R. W6 h if i %2 != 0 :3 u/ k; y* g( F
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :$ M* Q2 Q7 w% Q% H$ d
if i %2 == 0:5 W+ R) q4 {( }+ U6 n! K! R9 _
      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"
6 i6 k8 h1 V6 ua. 移除 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)1 l$ ~3 K( K. ?- s8 E3 Q# a1 V
for i in name:
) F. U4 i  G* ]2 ?0 V- ~& b print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain: @1 X6 N) a6 u( M0 P
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
3 f% J/ G" H9 Q6 @print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    2 E# Y, s# U, Y. _: u& _
print(li)0 y# [* Z+ w$ U
['alex', 'eric', 'rain', 'seven']
6 j/ s! G4 g7 C. A9 ]' I: ?9 Ic. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')' R% J0 J8 `! w+ U% ^2 p
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'). _; f- G1 D' v# P) L) z' t
print(li)1 U$ i4 z+ s$ [6 z- Z- Z, y
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']3 D" }: {4 a& K# _( o/ P
li.pop(1)
" T# ?- O! O. @# x; z. n1 Wprint(li) ['alex', 'rain']
/ a- U# E% h5 Q$ y6 D/ u" @& _指名道姓的删除li = ['alex', 'eric', 'rain']/ K% A2 s9 G: h, y' T# q# U
li.remove('alex')1 m: a$ H( J! [8 z- ^
print(li)
% r" H4 B5 a0 w& V$ [, z$ z* h- gf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
2 ^5 }( r3 Q; B& M# fprint(li.pop(1))! y4 g0 ?; \9 p1 Y) s- l9 B
print(li)
& z  U9 ~. n0 D: ~/ ~+ J7 X5 P% W
eric2 [8 l7 U8 k! C8 X: B/ ]+ j& y
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
+ H% {0 J8 h: O& U/ Gdel li[1:]$ U1 y- z4 F! u! `( i
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)( }# ~; [' d5 i8 a  Q" L, u
li = ['alex', 'eric', 'rain']
' S: T) @6 f8 e3 L4 C7 bfor k,v in enumerate(li,1):0 e- ^0 {6 T4 G& s
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) c6 N' k* I3 z  r( }4 m8 c7 Xa. 请输出 “Kelly”7 q7 T; Y2 I( E( b6 c
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]" }! @9 z* f0 y. I
print(li[2][1][1])0 R/ j0 e3 z5 a+ f
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”* o! H  v" T* S+ X( T) K
li[2][2]='ALL') Y" R3 d2 p6 n# X
print(li)1 h/ d1 p, v% H) S
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
# P. h7 ~7 V, l1 za. 计算元组长度并输出tu = ('alex', 'eric', 'rain')4 n# h/ P8 N7 [) @! R- m0 V6 r
print(len(tu))! K  q4 r! t4 N- S# t7 e
b. 获取元组的第 2 个元素，并输出$ E' K2 v7 ?' A7 r1 Q
print(tu[1])
& |+ K) ]$ B5 c0 [* je. 请使用 for、len、range 输出元组的索引" q6 d7 x# B& ?$ a0 ]. a
for i in range(len(tu)) :
* i/ N1 D& b6 z# \8 | print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
; N, ~' i$ R0 g2 \* Zfor k,v in enumerate(tu,10) :; d, I' w' h  P3 t' R. S
print(k,v)6 Y0 ]+ x3 |& h; U8 _+ S( K
10 alex- W8 c' e9 {* j- r
11 eric
( {. }' r' Y! G7 q8 H* A8 _12 rain
5 |4 Q* ^9 {; I) Z- F! m" W% M' u8 w5 o7 o6 G) Y
for k in enumerate(tu,10) :6 q; R7 I  c+ a+ C1 B
print(k)
4 G' d" N8 j  @6 a* {: e/ a(10, 'alex')( W6 U0 P+ a* t# x5 V2 o! H; G
(11, 'eric'); K  E& r. r6 g, D. w( }
(12, 'rain')
0 z: G. x: b2 V  p* j. M5 `: g& X1 ~2 w" u, V9 m( ~# a

25、有如下变量，请实现要求的功能
1 `! }; J$ Y1 |8 Dtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
+ Y" R2 l+ J9 F2 I
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以' ?7 c: u  g/ k! [8 `8 C" {5 m
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])" s- j$ O% J" j3 C. [
res=tu[1][2]['k2'].append('seven')
) B! E. ~9 Q* o
+ z: k, N: L1 f4 l' E' dprint(tu)- l, r1 ~! L; `: n  ~; C
26、字典/ x) C6 }- D" o! V0 H. J
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
6 I2 K% L; X0 H' a6 T print(i)b. 请循环输出所有的 value
) g) Q- t; v. xfor i in dic:. o: m4 M4 E, P8 O
print(dic)
/ `+ s- D, J( m( A; U9 {: @c. 请循环输出所有的 key 和 valuefor i in dic:
! i; R( a: o$ `$ y' n, M5 Q9 F; xprint(i,dic)
( r0 r) [- _7 L( U4 G, g* zd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
0 v" c. r8 {9 {dic['k4']='v4'
8 E/ h8 Z# o+ H0 g8 jprint(dic)  D* W# M2 `5 b; c5 ~
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
* d9 w- g9 U/ Z9 m" [dic['k1']='alex'
) I& v- u& u; \print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典  L9 C* {: M' p6 x
dic['k3'].append(44)! t( h8 x; E& O# D$ v
print(dic)1 o& a8 o) o7 K9 K7 O

, y& V  ~- ]( o5 g: {3 ag. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
, {" f$ t) D5 n# l+ X2 K+ j, ^dic['k3'].insert(0,44): |6 L: G, F+ J
print(dic)
# v1 y# c8 @1 ]& k, h27、转换
1 S& q; a: R; n/ p8 s9 aa. 将字符串 s = "alex" 转换成列表  s = "alex"# D2 c0 d2 P) `

0 A( b8 ~6 ~/ M3 o' S6 D6 \print(list(s))b. 将字符串 s = "alex" 转换成元祖0 B  U% M* x) C6 b+ @4 ?+ I. t# S$ r
s = "alex"; W. U, U1 d& v8 S/ A3 a3 A
print(tuple(s))
6 S0 r! L) W" r2 c6 |. R
; x" V/ ^: V8 O! e! rb. 将列表 li = ["alex", "seven"] 转换成元组7 l1 Q, W8 H% b0 O
li = ["alex", "seven"]
  D% o. {) K4 a* M! T1 Pprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
7 S6 }, M. e" ~* G* ?tu = ('Alex', "seven")
6 Y% F5 O" E: _" d: uli=list(tu)
5 s- Q1 ?1 T7 n. L7 l2 dprint(li)
* i. |; g. n" }
. h' v; @3 b1 v/ z7 x
" g7 D0 Z4 x! Sd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
. W1 C8 A- P. q! R7 J# r- {" s6 ?9 V, O! [& v5 ?
dic={}
0 r2 l* S, J5 ?4 |6 cfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面5 z( @$ M, l! i0 o# ^" l/ F
dic[k]=v
1 z- l/ S/ C. l# X( J8 h print(dic)27、转码n = "老男孩"5 |+ ]: w- w) ^- X) D$ A; T5 ]& l/ d
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"- t& I1 d* h2 X: }! @! E
a=n.encode('utf-8') - j  g9 }/ `9 E6 t' T+ e3 G
print(a)
9 V7 J: H% b& `0 x6 Wb=a.decode('utf-8')
" J0 R! s/ s$ I; @print(b); ^7 b. L4 ^+ O3 \1 P8 d* J, ~: F8 Z
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
& _2 X, f# x( b3 ?) }+ }print(a)& Q9 ^& X# z# I: T2 M3 Z8 P
b=a.decode('gbk')
$ m4 R7 a8 V9 n4 iprint(b)28、求 1-100 内的所有数的和  s, d  m2 m  \( N4 T- |
count=1
2 Z; I4 f) e1 I4 B' s* Hsum=0
1 s( E2 ~- E% ^( W. {+ ~& i) {for i in range(100) :
; P- @2 l- E! d4 U  F( A sum=sum+count2 u1 _, E4 h+ o" T
count+=1
& ]& n3 h+ K+ Y+ Y) E3 X6 d' D' Rprint(sum)
7 q& M- c- x2 p5 {0 u
# R9 x4 @* z/ H# \count=10 f( ~; F& j1 Y8 Q
sum=0  D0 h2 c7 M/ P2 L) U) ^# [6 b6 i9 v
while count<=100 :
# `9 n0 k( Z- ~ sum+=count; d- U9 X8 @8 y! \- ^
count+=1' g3 }! P3 w: Z) [
print(sum)29、元素分类: o' u2 a: X0 r' B9 p
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
% d0 O3 Q+ H1 |, M! y将小于 66 的值保存至第二个 key 的值中。
- Z8 o6 w2 \/ F6 {即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
0 j: t  `7 U/ A+ a" j6 Z' l/ yli=[11,22,33,44,55,66,77,88,99,90]. V' t& ]; t" g: J+ k+ E
dic1={, o( H1 ]$ g; k
'max':[],
0 W! `& _9 W, U. Y0 { 'min':[]
; A* ?8 u6 R' Z, a$ F2 ]}: V. d' ^0 \$ d! a
for i in li :' e4 a0 C6 H$ g/ o
if i <66 :
/ y  c/ z; w1 B7 h. w/ {       dic1['min'].append(i)0 |$ z( C) R& o5 [" F
else:4 f# f  v" b. g" ]" ~: F" f* t
      dic1['max'].append(i)4 l" L( k& b# {; X( r2 f# g
print(dic1)
) @. m/ ?# R) q6 K1 k# y6 e4 a
0 p9 z& x: X$ Q# s---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}1 Q' c7 a# F6 b4 ?, W% e5 ?

Python基础知识汇总

主题推荐