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、写代码  A! R2 t# Y0 [7 Z! z; h
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) :- e' U2 T! R, S! o
name = input('name:').strip()7 E/ G& Y% R1 U, y) L6 Y. j
pwd = input('pwd：').strip()& |- {- ?  r$ a6 _5 j% N3 o

& k5 U6 W, Z' [, F7 B5 n/ P' b. t if name=='seven' and pwd=='123' :
) o$ {; Q9 m6 B0 z, s9 I       print('ok')+ O7 |. A0 v8 t" a
else:. Y: ^! l' n2 a. m9 G  u4 s# s
      print('error'), F: M& m7 T" F" Z0 |/ s% b
      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)  :
/ L! V  g& W' E, G  ] name = input('name: ')" O( b+ U* n& [
pwd = input('pwd: ')
2 E3 q, }* T  ? if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':+ C4 s+ o- t/ m( x! [
      print('ok')
3 J, j- Y8 P1 l+ Q  `( { else :, E' T) P5 E' t# e/ u( T9 e
      print('error')6 }& X& K+ z* z7 s" S
      count+=111、写代码
3 T# t$ c3 c1 P! za. 使用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) :
+ s# T, @- ^( L4 V; |! y if i %2 != 0 :, z# o3 ?5 L9 U) o( 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) :' m, Y( H. E9 b6 a9 A
if i %2 == 0:6 F! ~, R. Z" l. E9 `/ E/ o6 H
      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 m, W0 r9 y! ?$ P: N" q
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)/ ]/ A" j, p. z- ?) j; v# W/ h! n
for i in name:5 y; L. F# ]$ {, Y* K
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
4 F3 P  m6 M2 k; X; t  H" d& s+ u22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']  n& s+ o  r+ [# H1 P0 @+ R& }
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
& E& P% A, w) k" }( ^/ a% Nprint(li)) E7 d$ g; t1 k: y" X# ~
['alex', 'eric', 'rain', 'seven']  k" f$ H; K( j, m8 @6 v6 }+ U3 V
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')$ Z( o6 K; E0 i; M# t& o+ `
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, g! m( r# k) F5 L1 fprint(li)4 @: D+ D0 ?+ Z# B2 l) O0 B9 o: u
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
2 b, B$ X5 i6 u# M8 H' v! Hli.pop(1)
, @1 ]2 i" f, e1 gprint(li) ['alex', 'rain']; ]1 U' [( z3 T' z( `
指名道姓的删除li = ['alex', 'eric', 'rain']
1 [$ F1 z% u. E! S2 {) {4 g( s# yli.remove('alex')
6 [  `" i  B0 ]print(li)
, _  R: D) z, y, Kf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
" U! C& f- h1 xprint(li.pop(1))) Y; i" h& W! ]; u6 L8 O$ B; F
print(li)* i3 W+ v% z1 p8 v0 c1 q% V
, u* W& s0 b; I3 S: Y
eric
. z" [) E$ ^6 L" s; A( _) q['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']8 V. ]1 S- B/ ]( }! O6 k- Z
del li[1:]5 U! Q# I  R" G
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
) I: |5 f2 W) b9 ]# ^* }' X: Q9 a0 rli = ['alex', 'eric', 'rain']
% d  \0 U2 D; a$ a' v6 zfor k,v in enumerate(li,1):# ]! R0 @3 r, A9 A& a8 y
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]$ G  K  ]/ q, y
a. 请输出 “Kelly”
$ r8 [6 m$ B5 E- U! s1 K4 A, Xli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 b- |: y+ ~/ S4 I) ^0 k. Jprint(li[2][1][1]), p7 J$ K/ n' ^
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
; N5 H7 e1 K. }+ I6 G8 x$ h( ?0 oli[2][2]='ALL'6 [( U% [. b$ q/ q" ~3 ^# l( F$ O2 s
print(li)3 Z! e( e+ z% p4 T" g
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')* C1 A) T0 y- O1 C, N( {) L
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
7 W5 H2 \$ @$ mprint(len(tu))5 H" Q0 x* ~& @4 C" g( w& t
b. 获取元组的第 2 个元素，并输出
( R0 c/ G5 L9 y1 B1 Iprint(tu[1])9 t. D- ]* s2 F# F
e. 请使用 for、len、range 输出元组的索引  J$ Z2 Z" g8 h( j6 E
for i in range(len(tu)) :
" J6 x  s$ }$ n- E print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)$ L  S1 ~- P8 P5 O
for k,v in enumerate(tu,10) :0 E# f; H3 h* W" B+ A. g4 J# |
print(k,v)
. j* P* g. x. S$ z5 q10 alex( [6 A2 G: j5 e6 [- ]: R5 g
11 eric
, d! C& x6 v" V5 [) y12 rain
" O3 y: X1 P( p8 A% `; I5 f' A& d8 F9 }- x& v  S+ l; V% K
for k in enumerate(tu,10) :
# C: D4 e: l5 T3 _- L% R1 R* p+ G; y print(k)$ Q/ o/ x) K! ^2 U7 p3 b/ F6 q
(10, 'alex')
' s! N6 J: A& X& q- `/ S, _( j(11, 'eric')
1 u- r" q3 g* Y$ y(12, 'rain')- c3 ?3 P( ^8 {2 r6 S: w# ?8 z

$ \: T0 ~; b4 v3 ~$ o  b$ o  I5 d: t3 V! ?
25、有如下变量，请实现要求的功能: N% k, ^* U! b3 @- X* S" |
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

+ H, w8 i, |: ed. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以7 D% u& G1 }3 u, Q2 ~6 O; x
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]); Q% J2 r( F. b' N, \: T
res=tu[1][2]['k2'].append('seven')) {8 b  m! T8 z, A% v& a

, E8 b/ k( g# U' C7 ~* |* _print(tu). a' O6 D$ C* d# m9 j- J8 ]7 m1 f: I
26、字典
( t$ R3 H9 M2 A# Z4 ydic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
# D, J; P, Z' Q7 }% | print(i)b. 请循环输出所有的 value& z0 u3 W; R& O5 J% n  H
for i in dic:% }% g5 s4 i5 O0 Z$ k0 N& q
print(dic)' m- [) A' O! a( Y  L
c. 请循环输出所有的 key 和 valuefor i in dic:. }* `: y% \/ P. g2 R8 {- l
print(i,dic)
9 {+ Y0 h8 N2 ~4 s- rd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典9 `( V' h9 P5 n
dic['k4']='v4'; ^+ }8 p  q; R. q# \. |3 W5 w# n' O+ k6 X
print(dic)
; H8 K) N2 K8 x% @  Ne. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典- R3 G  j, y9 ^. [& d4 s
dic['k1']='alex'
' ^7 H; d8 Y* C( `6 U8 {# Yprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
7 L( x9 |* E8 i2 W% A( C8 E; Mdic['k3'].append(44)
5 W- E2 \2 S5 L+ wprint(dic)
8 H$ z+ O5 W' T) x" A& a; u; Y1 \. s* R4 v( S: p/ J9 x$ p7 `
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
2 b7 O4 n2 A& A& e- @3 u* Bdic['k3'].insert(0,44)3 U" ?& e( p( E8 {+ k* ]6 N* _$ P
print(dic)3 F6 g( ~+ a$ L% Q
27、转换5 q5 [& g' G7 w7 }& Z8 P
a. 将字符串 s = "alex" 转换成列表  s = "alex"
: N& H1 K. l" @0 `2 N: Y
4 W, W, k$ v6 |2 fprint(list(s))b. 将字符串 s = "alex" 转换成元祖. t, c, s2 G# e! a) A0 j
s = "alex"
- ~; d$ r9 N" H' u/ [9 F+ y& k( [/ ]print(tuple(s))) o/ N4 Z7 E4 t. \# w

3 Y, ?& R1 b: y% B# k: T; S, Jb. 将列表 li = ["alex", "seven"] 转换成元组( Q" H5 ~1 P# H; r
li = ["alex", "seven"]5 i$ V6 f# }; x! J
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表2 M0 m! Q$ s( i* f# \5 U. \/ a
tu = ('Alex', "seven")
( M" D8 f4 b$ b$ [4 x6 Oli=list(tu)
$ I. n, }3 z! E& }( c! f8 Dprint(li)% y" Q2 A5 q9 u- h# n
5 L0 t8 U& R: n! Z  c
5 |, @/ f: ]/ r
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增$ e% `2 P( F- q: B) n
( U7 s- C5 [4 ^$ q0 p
dic={}
. I) s. c: t7 C& ?  H4 Jfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面6 |  {' ^  |; X# T5 V5 k1 X( P/ G
dic[k]=v3 ^7 F2 X- c9 F, K
print(dic)27、转码n = "老男孩"
# g3 |5 O- P1 x& A2 j1 [2 a; k8 Ca. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
! L, h% `. `' l4 N/ Y# q* K! Ra=n.encode('utf-8') $ E/ U( p: L" O9 V
print(a)) P: W$ V9 y7 n+ p1 k
b=a.decode('utf-8'), p0 }. _* e  D6 c& A6 M
print(b)
' o) N$ M2 Q2 k' ^1 ib. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
' ]" J2 }. j3 d/ jprint(a)
) S& L- X5 d0 O6 P) Lb=a.decode('gbk')
  P: n$ s8 e' aprint(b)28、求 1-100 内的所有数的和1 S1 Z' H8 Q. C7 w5 o) F1 u
count=1
* \( m( [" x/ f! r& j& T" V4 `sum=01 Q9 G) f! r9 ~1 ~' \/ F3 U
for i in range(100) :
5 G; |6 P4 ^+ X; F; w% R sum=sum+count; g) e& [! d9 N! |$ z8 q1 p# U' S
count+=1' |* G$ j: H$ A: K
print(sum)
( _; k3 u. p/ |( Q7 X5 s9 n. u5 u3 a3 `& T5 A  `2 G3 X# i* R# W! `
count=1" b. {$ o4 S4 N: R# `: T* T
sum=0% }& V) a' D, s* w6 x' I
while count<=100 :' [+ X+ |5 D+ v* R# M
sum+=count
" ~4 O& |2 P$ e9 h- M count+=1
& [# \- q3 [" X5 [( l) U8 [  p) m' ]print(sum)29、元素分类) G* }1 y& b) g3 T) M2 \! X+ `
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，) {7 c  a/ o) P6 S0 D5 \$ d! Y
将小于 66 的值保存至第二个 key 的值中。. _4 C9 i% X, b- V# J* p+ a
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
4 F4 A7 M% f. Q' ]* E$ [li=[11,22,33,44,55,66,77,88,99,90]+ j" n2 L! b, B9 t) F
dic1={! {  p5 p! ?* S8 N; M; U# M! A
'max':[],
& k* M, k$ t' ^4 K, P* Q1 ?1 d 'min':[]6 t8 Q) @) H. n( }/ x. @
}
/ N4 t8 {& Y+ u/ E: E( hfor i in li :* @/ s" P. l9 |* v( O
if i <66 :
* L! n0 V2 c* I8 b; A       dic1['min'].append(i)
) q  ]! I6 c! S( V+ V4 |4 q else:3 Q  i! H% R% `+ S. X% @2 U
      dic1['max'].append(i)
9 H* M# z7 q7 a4 |8 @! i  k3 ]print(dic1)
0 f' [- z, {% z2 |: U% D) A- Q% M5 a9 [" H
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}4 u' Z7 F  B2 b4 g

Python基础知识汇总

主题推荐