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: Y8 u; Q3 W4 a9 n* n3 e2 c4 R
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) :
' T* V9 G: a, {; ]0 f name = input('name:').strip()
$ T7 t2 l0 Z+ Q& ]! c5 E6 Y pwd = input('pwd：').strip()
, }8 c2 i+ [* |
2 b" U7 B# T) J if name=='seven' and pwd=='123' :0 \) g0 u8 }, r
      print('ok')
' c% M, r: A+ Q0 @/ r' ]$ L# e' u else:. V; Y5 m9 w$ k4 _
      print('error')5 }6 m4 C+ O3 D( w
      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)  :" d' Z$ Z! N! ~, ?
name = input('name: ')5 w8 f1 ?1 b$ D+ V1 u4 ]! l
pwd = input('pwd: ')9 S1 e4 ^- d( }/ E- C+ x/ ~: ]8 e5 z
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':2 E, t5 S( {8 [: f% s. c
      print('ok')8 i7 W8 J" c4 U/ N7 N) g
else :, f! D! r( S6 g- z! q/ r
      print('error')
0 \6 |. @1 w- U$ h3 A) q8 o' ]       count+=111、写代码3 K" _, A: l) `6 \) c
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) :
/ Z6 Y9 M3 P3 h( v; a- w) d if i %2 != 0 :2 |* E2 E' ]; I4 o  i3 \. }
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :1 k% f9 L% ?( J0 `8 N) e6 G2 }
if i %2 == 0:* k7 u7 o6 s7 w. j) N3 _) E
      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"
4 g. G7 u! m9 N7 K! i5 ma. 移除 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)
9 l- N6 s( x1 N/ o% g" ?& x, B5 Efor i in name:
4 t4 d' X& O5 |3 _4 p print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain" L7 i6 c7 N9 P  I# V5 e- L: W
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']- h% A: U5 F3 C( N" z* q4 x
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    . u* @8 [2 h% G- O; }: Q$ J! n
print(li)* e- f$ x, K2 {* T
['alex', 'eric', 'rain', 'seven']
( n( f2 r$ L6 a/ dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
, q% \  p* h* \% ~print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
8 R- T' p  `1 z, hprint(li)
+ C' }  F0 Q( R2 N) z4 D+ G: {e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']9 R2 G. ~- {! X
li.pop(1)
. V& e  p, ~( @8 h0 Z6 c  qprint(li) ['alex', 'rain']
; p. k9 l( S( l) v2 I9 z8 F指名道姓的删除li = ['alex', 'eric', 'rain']8 Q8 }& q  ?/ s, @
li.remove('alex'); z* S' C5 U$ Z: {5 I% X- b
print(li)
0 U' `* Q7 C" c$ u/ y- h1 W5 Pf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
) s8 g6 K4 u6 O% Q# X. B8 e9 i5 Z9 rprint(li.pop(1))
, X/ Y- j: Z; T9 d4 _print(li)
7 ~( k+ b. N2 r6 f  |  e9 s* d* X" }" v( f
eric* {2 |$ G( M. |* v" [7 s" L6 t) u
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']. i: \# Y$ B6 i* T6 I1 g6 P
del li[1:]
. f$ i* Y( F, x5 q0 \  g& sprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
0 P& e# S& {8 u# ?: n/ d- V+ T) G' Uli = ['alex', 'eric', 'rain']
$ f- |: D* x4 Y3 v( i- o" Z, Ofor k,v in enumerate(li,1):
/ E  q, o7 o! A, F- b4 m) K+ Q print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- S! [# L: N/ C& }4 Za. 请输出 “Kelly”' {' k) r$ x* \  _$ `0 h
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# C& m  N9 ]- xprint(li[2][1][1])& C- W4 Z+ l9 P8 M
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
7 Y: S% m4 e4 L+ z3 I* i# x$ W" ili[2][2]='ALL'
4 L* S+ C4 I/ W; [6 zprint(li)/ C5 n  M& S! {0 f
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')# T! [, l) \. W* d6 o
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')3 b: U6 p3 H8 p+ C; W
print(len(tu))# y; y( a- L" @( @" }
b. 获取元组的第 2 个元素，并输出7 c1 ?3 R. z  q1 [% R9 l
print(tu[1])3 U% R& X6 q, j: h
e. 请使用 for、len、range 输出元组的索引0 l7 c5 |2 Q! P
for i in range(len(tu)) :( A3 }0 z$ A4 x) Q2 z
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)# v  R& m. m( w6 T
for k,v in enumerate(tu,10) :
: ^# W+ Y: C& d7 O print(k,v)3 o1 o+ A$ F" Y& R9 M
10 alex; k" g+ J- ^* Y
11 eric+ |! W0 G6 I7 Z& a; v! b' {: T
12 rain
, H5 o9 r& F; O; L6 [+ F/ O6 I, i1 y9 @7 ^
for k in enumerate(tu,10) :
( c% u+ s: V0 _1 ^5 G3 ^3 @( ` print(k)7 f1 e3 d/ H6 J5 O$ w
(10, 'alex')) v8 M% {/ e! W+ F/ L0 O
(11, 'eric')
8 Y6 i) Q! ]" g  [! h  K2 E4 b(12, 'rain')
4 ]) N& \3 K( I
  A- n! \+ M" b: _+ f5 b
; D& w% m- A: d25、有如下变量，请实现要求的功能2 P/ `/ m/ W6 P( b# G/ q& _
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

0 k; n$ U3 V% x" W" D1 d5 [2 {d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
5 r; J& B) w% P1 q6 R; mtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])7 M" ^, G6 e6 z% C: i/ e
res=tu[1][2]['k2'].append('seven')7 N# k. i. v9 A$ H* T+ Q

) O/ G# M/ E5 uprint(tu)
$ V' o3 G1 o( V, M26、字典$ s9 d# k7 c3 B7 q; ]& d5 i
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:* v$ I# V# r- d& ~/ n' X# J7 l
print(i)b. 请循环输出所有的 value4 t8 |4 M% e( Z5 r( e
for i in dic:
, K+ G  g% {% Y% d- T print(dic)' }* S* j! I8 {- ~7 V% a( u
c. 请循环输出所有的 key 和 valuefor i in dic:7 q( J2 Q. c! Z, U9 ~& b2 M* w8 `# |
print(i,dic)
$ Z% B( C$ R4 L+ X, o+ Pd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
6 W2 @" b$ ~3 Xdic['k4']='v4'
( @- e2 d- J: q/ k( jprint(dic)
! i; e5 l& d* C; a- Ue. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
: c8 ]% _; L" g# o. j6 d1 Cdic['k1']='alex'
0 D7 E" O! ]* Fprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典9 X2 e* }/ r: O& m! w* C
dic['k3'].append(44)
# q! g- F: R; ~2 Mprint(dic)
/ Z3 j: L, P# w- r' Z& T$ o) w' q) a
, t9 O; D2 B) f6 G" _. Kg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
( e) f# N' M, w) M& d7 vdic['k3'].insert(0,44)" w' F  T) p& ?6 }, s. p( {. `
print(dic)* O2 f3 d- M) y, G6 Y
27、转换
% W8 X" ~# Z2 H9 {. Xa. 将字符串 s = "alex" 转换成列表  s = "alex"8 e/ d" }% F& P1 e  x5 X5 t
6 P: V9 M! j, S( H. ~, d' [% d# z
print(list(s))b. 将字符串 s = "alex" 转换成元祖) L( m! L; b0 @8 S$ a4 {8 n: i
s = "alex"
! Y, T& f1 i7 ?print(tuple(s))
5 ~/ `1 D! c0 c, v8 A% L4 {: k
4 I6 @( X; ?3 J6 }6 i7 e- ^b. 将列表 li = ["alex", "seven"] 转换成元组2 d% T% c8 W7 J6 N( d% t& p; {
li = ["alex", "seven"]6 ^8 p' b: a8 y2 W% o) {
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表" `: q  A! N* A/ o0 J
tu = ('Alex', "seven")4 H5 ?0 d3 K& V; Z: r
li=list(tu)
4 C4 u. Q" A* p0 u1 y) g; kprint(li): n; y3 p2 P. N/ D# q5 Y( n
( S- g7 T& Q6 {$ h! _

8 }! u: o- E( z" w8 O( @d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
5 {8 g- L8 {8 A* n1 o5 @
: g, L0 Q( @4 e& X9 A9 ddic={}3 o( ~3 R) R. V9 T
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面# D+ j) H# U6 e$ Z& M  G
dic[k]=v
  A- G9 e% F" [/ R print(dic)27、转码n = "老男孩"
8 U9 i! t2 ^  ]' V1 F4 O7 Ba. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"  j! F! _: p  n% a/ [& j6 a9 ?5 z2 ], d
a=n.encode('utf-8') & Y& \* _& _, O+ Y; a$ {) w
print(a)
, k1 @. a7 e$ J( Bb=a.decode('utf-8')
$ v: U2 q' ?1 dprint(b). B) S0 J9 a, Z! m, S
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')! B4 c- E3 I. u: o+ b/ L$ D
print(a)
+ b, `5 a! Q! V& h+ z4 p5 Z; S- L. Sb=a.decode('gbk')
" \& I! a: j! A# s9 S8 Q! pprint(b)28、求 1-100 内的所有数的和
# z% C) a7 V2 V5 u' ecount=1) Z& q' D$ D9 Y* @5 [% e! m5 Z+ }& n
sum=0
) U6 s* K# n0 W3 C1 L) e" Kfor i in range(100) :7 l# u( ?  ^0 f0 G4 [6 s% ^7 p% n8 K
sum=sum+count
! F2 [7 A) P" p" \5 b count+=1
  }3 L7 P& v9 S+ ~) j" @print(sum)8 |# e; ?" }2 q2 o
) \+ \1 e: n' d$ B( {! [0 _
count=10 }* t* w6 t* ]- X4 I, B- B! O
sum=0
8 K& t2 d' k: Q. ]5 g$ nwhile count<=100 :
) S- {+ X4 r' x( Z sum+=count8 `: Q* c; a) ^9 K8 W
count+=1
; S" d) R7 a7 H' C' p: yprint(sum)29、元素分类
) k' \0 J' L+ l* r有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，  f6 n3 _2 j+ Y
将小于 66 的值保存至第二个 key 的值中。
5 M* p+ w& `6 W. u6 m# T5 D! D即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
9 D! n8 u2 D# x* T; xli=[11,22,33,44,55,66,77,88,99,90]2 @0 n* @! R" w. J* L2 q
dic1={
2 T4 ]* F3 T7 w 'max':[],
8 x; I5 f' B5 }( f: e2 C 'min':[]+ m5 t, Z+ `" [' {- R5 x0 a( H5 n1 m
}2 W) Z5 g, d$ O5 c7 x2 k3 P
for i in li :
# k4 q/ Z5 y0 q  Q: U if i <66 :) g7 v3 ^) ?3 Q- o+ o
      dic1['min'].append(i)
' \' a# C' V( i0 `( N else:: n* w% y* i3 @5 |6 P
      dic1['max'].append(i)
4 N8 |0 X0 a& j$ y- nprint(dic1). ^6 a+ u! u* k+ W" A8 F) ]" x
. v6 g* b5 {& l: [1 f" T
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
0 C# }( u' a, p1 [: b; ~& q) O

Python基础知识汇总

主题推荐

浏览过的版块