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、写代码
  }- ]8 ~7 I! [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) :7 U3 Z) C8 X9 I1 q" H
name = input('name:').strip()
7 I  }9 K8 `/ M1 \) r pwd = input('pwd：').strip(); T! ?/ h' X; b6 m2 {1 E

6 D! @7 K1 l2 h7 ~) q1 i$ a6 T8 L if name=='seven' and pwd=='123' :7 X# }- `6 @) C7 u3 M. b
      print('ok')# J2 L( b! K. Z9 R( y% [* g& F, w
else:
" s6 ^  n# G( R3 R4 z0 `; P5 m       print('error')8 u' Z' t, r8 E6 c0 g
      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)  :
% T- Z0 Q5 b  \& z name = input('name: ')8 ]* E) E5 B5 G: I3 T
pwd = input('pwd: ')
+ L5 {, d& I3 J1 ~: m  j, _ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':4 y. U7 R- j8 [' y; U2 x/ H
      print('ok')
! s% F) F  L/ w! n else :7 `5 M4 }) }. P' u* ^8 m$ r
      print('error')1 G9 k" f! G" s$ G
      count+=111、写代码/ H+ e& r$ L. X" T9 k3 M5 D% T
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) :
+ D/ y& s# F9 O; V2 j+ w! K if i %2 != 0 :% J& @& q) Z* L
      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 X* r- X. J8 u! ?+ Q% _: ~
if i %2 == 0:
7 l( y7 G* [2 M% _; P( f2 j3 Q       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"0 D: N% X4 o1 p: L5 F  V8 R- Y
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)
: ^& `! D/ ?) n) ~for i in name:# j" B6 Z6 v" S  _
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain& ?7 v0 z' r0 Y7 W& h/ A
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']( V9 g1 n$ P2 f7 ?/ u, K& {
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
5 Q$ m, j" c8 U; n2 Y) Xprint(li)
" b3 I! z( D$ j$ L7 u! U ['alex', 'eric', 'rain', 'seven']% X/ ^- m. T( |/ g% R9 [
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
, |4 B' C$ ~+ iprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
3 D: r% R- h+ ]8 L9 U8 h1 A# mprint(li)
7 |6 X7 l- e( f+ m9 e1 O' ?; Ze. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
* O9 d. a  p/ d/ E; B& K0 n' d& Oli.pop(1), K/ _! |' a" O& \
print(li) ['alex', 'rain']3 e; V; K9 b6 t1 @; y' x
指名道姓的删除li = ['alex', 'eric', 'rain']$ u- S4 o, p2 ~( z2 u; H( n
li.remove('alex')
- L5 V2 I- T( ~7 i4 g; P1 |print(li)2 e; Q! K6 O6 ^
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']3 p. v* C$ p! G/ l
print(li.pop(1)): Q: S! A5 S1 d9 z
print(li)' q7 o7 D' \+ @, w% ]
* d$ y& a. k9 q5 z" J; j
eric& N) \# @8 |! q7 _+ i
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']: Z2 e; j/ a# R8 V  }
del li[1:]
6 n  w9 d; x4 ^, }- jprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
) ^9 `# {5 Z/ s8 P) Zli = ['alex', 'eric', 'rain']* p6 \, m4 e5 V( t9 U# m) U7 U/ x
for k,v in enumerate(li,1):. N; x% g2 {9 Z$ H  ?/ Y6 @4 H
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]1 G- A- i# w& @1 Y
a. 请输出 “Kelly”
% A) a3 J& P# N+ I, b" a4 P0 E& Lli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
' V" d% N% G. L7 hprint(li[2][1][1])/ Q: u' N$ [* l& E
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
3 J0 {/ _, e% R) c  x0 Tli[2][2]='ALL'; Q& p. x' Z) [
print(li)
" k0 m. @/ ?& R' z/ {' X; `9 j24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')* S  m6 F( o! \
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 |  \; e& k+ b, {* Tprint(len(tu))& g) ^3 y2 Q* x. g; a  J6 B
b. 获取元组的第 2 个元素，并输出
9 W0 h/ q5 h" _" l6 g4 O0 S) Qprint(tu[1])
9 [; e# \& b8 \. F8 re. 请使用 for、len、range 输出元组的索引' W& v* Z/ D7 B% g) W) c1 e. J4 W  }
for i in range(len(tu)) :. N# \6 X+ R, p5 M
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
$ P8 \; e& R, L0 k+ }2 O" Q. tfor k,v in enumerate(tu,10) :. _! x# X6 K7 R
print(k,v)+ j& _2 ^4 v# @0 P) C7 O7 G, b
10 alex
$ ?* R7 J/ S$ X( ]11 eric
; P( L( [% D1 z. A" a12 rain+ x/ M6 }' R( d( {9 v9 U7 L' Q9 n. s1 G
" {# v% k  ~7 d" O
for k in enumerate(tu,10) :
$ N2 N+ ?" z9 l; Y/ S print(k)2 S) k+ r' d6 ~% g& y9 F; d
(10, 'alex')" A( T4 Q2 y1 X6 ~9 c2 D
(11, 'eric')
; R8 {& P. V' ~* K! L" `: l1 H(12, 'rain')3 ~4 w8 t  M( w
4 O% `  V1 k3 Y7 t
' f6 D. m, i7 L9 |+ ^: T$ _
25、有如下变量，请实现要求的功能
* ?5 w! ~8 `& _# d& Btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

: i, G* o! j2 m6 `' x9 Sd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
$ e1 `6 w- J- a' `+ y; _6 btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
3 C- E  O9 U3 V  M! qres=tu[1][2]['k2'].append('seven')
9 n  N1 c2 U( D1 `2 u. N, L' O- L% ^- |: b0 F+ j
print(tu)+ u& ]% P0 w! o2 D# w) ~! K% f# O
26、字典
7 A( ^# W6 V0 odic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
5 f0 E. O& s" D9 p# y print(i)b. 请循环输出所有的 value
: X  F, I1 N9 w0 N0 Rfor i in dic:
4 D( u  D9 q$ f; h1 B5 A' g9 K# \ print(dic)
7 b* Z' w% h' r, j- dc. 请循环输出所有的 key 和 valuefor i in dic:' G/ r: T  r3 H  L6 F
print(i,dic)
3 ~+ q6 k# I# [& Td. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
( G& V; n1 C3 z/ ^2 _  d- K- w; Mdic['k4']='v4'
) J7 \/ S4 D/ m- T; ~( mprint(dic)
! v! ?# e5 K/ fe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
% L1 m4 |( v7 N3 T$ Q  Pdic['k1']='alex'* s! P5 Q7 d) l& X. |( G9 c
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
. t' T" i! c) P: Bdic['k3'].append(44)
. h; f# l3 W6 v4 x5 ~/ Yprint(dic)
/ w6 d9 h. h) d% n7 y- d- p
- ?3 |: a0 u- n, v* [: lg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典1 b% ?  ?5 g9 S. f8 J9 h( `1 _
dic['k3'].insert(0,44)* n2 [+ ~5 u- a6 l
print(dic)
; a; M% z' t3 f; w; |/ Q27、转换
9 B4 j/ I$ l& Z; p5 y. {9 Ia. 将字符串 s = "alex" 转换成列表  s = "alex"3 o/ _7 I! U, o  ]

8 s/ i6 b& H, e7 gprint(list(s))b. 将字符串 s = "alex" 转换成元祖* f+ ~0 y( j; i3 J# e* H
s = "alex"  S9 R/ I; Y/ j/ `5 i/ r3 V1 q
print(tuple(s))
0 `$ j5 v4 J/ n' L9 U  l7 {
) h1 R6 n  j/ O' E- {b. 将列表 li = ["alex", "seven"] 转换成元组
6 _- u! R2 \; i3 r" t+ e8 I- Sli = ["alex", "seven"]+ V6 u6 Q3 A1 ]* |# Z' ?
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表" b3 C0 o* }. X: T# P* `7 B
tu = ('Alex', "seven")
9 R2 @. s& R. d1 v+ Q  Vli=list(tu)
3 Q3 U5 L/ a4 Nprint(li)
+ C! v: U6 m  u* N$ R3 B3 g; z6 w7 A0 a- |( r: }( [. n

0 m  H# n$ r/ x2 y3 a5 s/ yd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增; ~6 d7 E' {, i$ }7 S" ~2 M
7 \' I! {2 M' p/ Y
dic={}, S' E8 T7 U; v7 p7 v: i/ [- a5 `
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面+ P3 v' i  ]. W8 B( Y8 W
dic[k]=v0 q) C& V* v+ Q
print(dic)27、转码n = "老男孩"1 p4 U% x" W1 r" J) x9 t* z, z
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"! y2 r% U' A- y" @
a=n.encode('utf-8') + {: L3 O5 E; |/ Q
print(a)
; Y9 R- a- R7 @. Sb=a.decode('utf-8')
/ c: _4 y! A) n' oprint(b)
- h6 |& t0 \) A' w/ ]! eb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')- {  y, O( a3 f7 V+ q5 T' l/ E8 H
print(a)
+ N' v0 y; _5 P+ J4 u6 Ub=a.decode('gbk')2 e8 i2 E$ m  H. l7 ]
print(b)28、求 1-100 内的所有数的和+ |5 g& @! f0 I$ f# l9 o+ j, g
count=15 d' N5 m. M2 p4 r8 C' p/ B3 F" s- Y
sum=0
+ D% r4 V9 u" w# f4 O' H& A9 dfor i in range(100) :0 f2 ^/ v7 k. t$ x& T* ^
sum=sum+count; Q! W7 _  K3 \2 C; o7 [8 x
count+=1/ T! M8 @3 A2 u3 v$ D9 ^/ q
print(sum)
3 M/ M9 Q1 c/ ^0 t1 h. U! T" m) u$ L
count=10 \  U' |3 \* b) n7 }
sum=0  G( F6 @. G2 y2 m7 n
while count<=100 :
9 @7 _* i) P- [- s$ c sum+=count
( E& N( X' |+ d- |2 d) h count+=1
& ]- N. e! X1 b; H6 Aprint(sum)29、元素分类" Y, Y/ l5 z8 M0 P: m* d8 K
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，! h/ A0 I, i2 B) F& E7 p4 A+ |5 ]
将小于 66 的值保存至第二个 key 的值中。0 V4 O: I/ z+ J9 z& \% g" [
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
$ l$ L: f3 r0 c2 nli=[11,22,33,44,55,66,77,88,99,90]( T/ ?; ?, Y7 {) a- n, _
dic1={! `6 M4 C) p: H  n  J
'max':[],
0 ]4 p( M5 `( }# q/ } 'min':[]
# s! w6 V/ s8 w  s5 x) s}+ Y3 I$ y4 n" p3 T7 n0 Q0 B3 [
for i in li :
% d7 U- t) C& O9 I if i <66 :
+ V: L/ ]  x; I6 w, Q/ M       dic1['min'].append(i)/ A2 P- I4 n' w0 M! a! I/ R5 X
else:
4 w# I  z2 t8 Z  O4 M/ F       dic1['max'].append(i)
+ N$ Q; X, X, A5 I  j! ^2 N. qprint(dic1)
/ l; n+ j9 d' G% X3 q
. R0 [  e! T/ x9 t---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
2 K  y# M" A' f7 S& k

Python基础知识汇总

主题推荐