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、写代码) Z: L& H9 ?; @0 N" T9 n! s
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) :) y+ \3 d% ~, j( E  @
name = input('name:').strip()2 f; O2 I5 J' x. b7 |! J7 w' u
pwd = input('pwd：').strip()2 Z9 n4 s* g' j, }
1 n" c* E% l/ y  X) }1 I# C7 u
if name=='seven' and pwd=='123' :1 Y: l+ l( ~2 _/ B
      print('ok')2 \$ t( t4 }  m" ?, q* ], S0 {
else:
6 Q2 I, M9 c/ n4 I, K/ T       print('error')2 B2 C* c- O; c2 d: r
      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)  :# c- k# G6 f" Q9 ^* x# S  n) [1 A; N2 f
name = input('name: ')9 n0 E6 G: a( K& |2 m0 t
pwd = input('pwd: ')6 O3 M9 ?" l: Q6 G* L
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':5 b, ]& r* q1 g$ l
      print('ok')/ }  f: P. ^5 L2 a  h- T+ T
else :" o: j! n& j$ d' K$ ^2 C( C( K. K
      print('error')
2 \& d5 g  e+ I" f3 ?       count+=111、写代码
$ u" ]9 h6 F2 A( e1 Aa. 使用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) :
& v5 A  f" u5 _: }+ v9 E if i %2 != 0 :  C4 G5 W1 a% J+ X" 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) :
6 Y) `% r+ `" L$ [: w# F) L# o" G; Q if i %2 == 0:
$ I. i& X' G" B6 c0 G9 z- s       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". ^5 p" L, _8 B9 @/ }
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)
! y, g6 H2 ]2 b* d# Wfor i in name:
* \8 |. l5 ]7 P- |+ Z3 R; ^9 B3 N print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain7 ?" I9 i% r& z+ y5 `
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
2 h/ o& ~2 h0 _9 E1 ?- Y+ xprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    7 E' ?) C- a3 w" @! J
print(li)' X* |" Y0 E! q: V
['alex', 'eric', 'rain', 'seven']% N) x$ [2 t" z4 S" ]. Q7 }7 c. R
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
3 a) p% Y! `! V3 ]7 p! F& i3 Dprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
' v7 b8 `# V3 @: L) Q/ r8 sprint(li)* ^$ }, ?. ]% l$ v
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']- v8 K; E" F' [- d  q& h  R
li.pop(1)
6 ^! {, e% u& ]print(li) ['alex', 'rain']
7 Y; p/ N) q  u1 o- r4 b& @4 \5 r2 A指名道姓的删除li = ['alex', 'eric', 'rain']
# |1 b6 q! w+ @li.remove('alex')
" M8 f  ?4 B/ z4 B1 e/ h6 C# ]* @print(li)' P$ _8 R! G: \  n0 k# r: o5 M0 C
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']/ N6 F3 }0 a4 Q' K" E
print(li.pop(1)), t6 J/ _$ R  W" s( N
print(li)- h2 @" m& x6 q8 Y

, `1 h5 V: ]! @. b7 h6 k" n  eeric
5 h; E% E6 y0 u+ m['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']( j8 U! Z- Q8 a( u% x
del li[1:]
) u4 m# p* r( e$ mprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)$ {" }7 J' n# ^; R; M
li = ['alex', 'eric', 'rain']: z9 J7 d5 ~0 Q
for k,v in enumerate(li,1):! g8 t2 |, e$ L
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]! j4 X0 n5 e, V# W
a. 请输出 “Kelly”, Y* ~6 {7 b+ j" D- {% B
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]0 v: y* H5 `' Y5 T5 W
print(li[2][1][1])) f  L0 Y7 |# L  D# p% ?
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”! c0 U1 h) v0 l) M  k' e% z
li[2][2]='ALL'8 T) r' t  @4 v  L
print(li)
! k& g' \  v7 m% `5 `0 z( Y1 T24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'): R$ q; S3 V: m
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')3 j$ s9 ?$ d* {  a" m
print(len(tu))
: G* r7 a5 d. Y) ub. 获取元组的第 2 个元素，并输出
& c, u7 `  F/ M# x9 I" [+ D% i1 [print(tu[1])2 Y8 S, z3 z! g) j" r2 D4 e
e. 请使用 for、len、range 输出元组的索引
/ ~+ h$ K* ]" Kfor i in range(len(tu)) :
+ E5 J9 U: l0 }& i& I print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
, }  w1 p* j$ d" z& P. f! Wfor k,v in enumerate(tu,10) :
' z2 Z1 N4 o: t$ h2 g* ? print(k,v)& O) X9 X# b( x/ ~6 Q3 p
10 alex) O+ ~9 J3 c1 b; a& h2 ~
11 eric% l0 G6 X4 k) ]
12 rain: N: A) i$ K5 Y: `& d

7 m' v! E- k+ j" \) S6 p% I+ \for k in enumerate(tu,10) :( l/ W# n5 y6 q4 P( b
print(k)
" V/ ^" \$ {9 J* t" c(10, 'alex')0 A' f' ?4 K( b) y; {9 _
(11, 'eric')% w. `3 b* h4 Z
(12, 'rain')
& D  o" O) q% f" J+ z' i+ M" j
! r+ q% K$ K! X. R/ W- r
25、有如下变量，请实现要求的功能. f* Y  O8 i1 `, E5 L- v* z
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
6 t% E. K/ F# R/ t
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以3 v! J$ X' j. h2 `( C% A
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])  e( U- D* F( q! ^2 y+ ^9 `
res=tu[1][2]['k2'].append('seven')
5 {. J: V( E6 m( D7 M( C" R9 e
- x5 X; _+ G- v  H$ gprint(tu)
% |$ s) x3 U+ Y26、字典! K8 l7 m: D! T
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
2 N- k) p; j7 [2 u0 R( S- H* }# A+ w print(i)b. 请循环输出所有的 value: Y& O$ G6 X$ |$ E, k9 r8 F
for i in dic:+ t' v) P6 @$ u4 ?' R
print(dic)
+ w+ E+ O8 A, Oc. 请循环输出所有的 key 和 valuefor i in dic:# P. _$ R6 c1 z: R
print(i,dic)/ b: O, c9 L% M9 [; _
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
1 j7 V% q3 w% Z, T0 zdic['k4']='v4'& o7 Q, j; y* c
print(dic)
: @, o# {! ]& a7 v  _$ L, me. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
1 W7 G$ w/ z& Z1 [dic['k1']='alex'7 ]' q. a" G4 K9 A
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
* N, \, K7 V# Kdic['k3'].append(44)
8 @! D( O& r3 U4 i* E* C8 w8 jprint(dic)
0 U6 N# `- Z3 W- k( `) T7 p' I
' F9 u. f8 x7 z, U( |& Wg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
; L# {) n* D0 \3 `0 C! pdic['k3'].insert(0,44)7 L. x" h+ x) W) {" G) r7 g
print(dic)% T9 G) @7 k3 C1 n( \5 W( G* J0 V" D
27、转换% Y/ G- ?$ E0 Z9 `8 Q4 k& K6 X
a. 将字符串 s = "alex" 转换成列表  s = "alex"$ z9 \, Y# l- Q( V
0 j  f8 f6 e1 y. `- Q. \
print(list(s))b. 将字符串 s = "alex" 转换成元祖4 n7 o- W  n1 h- n2 [
s = "alex"
8 ^, z& T6 D7 h: _# i" Uprint(tuple(s)), P9 N6 t9 l, H. G: c! }' ]2 [8 {* P
5 q8 B% m) d: x# G! H) ^# V: L9 n
b. 将列表 li = ["alex", "seven"] 转换成元组
' W+ v8 N( p' s6 |! X5 \8 O0 gli = ["alex", "seven"]
8 p6 Z+ F, v5 wprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表) v* J- z/ S# I" Z! \1 ~- U
tu = ('Alex', "seven")
! p- F6 n4 V& A; Q3 r: Ali=list(tu)* G) z; [6 Q0 ]* d' W( o, F
print(li)
9 s  H& V4 Y, J* T5 j  o9 X7 p- O4 y; Y" R9 _+ J) U  p

( x0 o* O$ X/ B- y5 Rd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增6 K; i7 Q) u( q0 s
8 j- t8 O3 A- l& Y9 R2 e: y! ]# ~% L
dic={}8 c/ j$ Y( [& h  r) t
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面+ T* Q, o" ?8 s' p
dic[k]=v* v) ^/ f' Z; y: e
print(dic)27、转码n = "老男孩"
+ Q* C/ T- f7 e( Na. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"6 a7 R2 d" f8 w# `$ K7 K' |# N
a=n.encode('utf-8') , M: W, _: j& K% P
print(a)' R1 V! |1 [+ s# K) X  Y
b=a.decode('utf-8')0 G: ]1 Q  m3 {; J$ s; W
print(b)
  H: R0 y0 X; \" n" ]" D$ ]b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
6 W( R! u4 n/ |: H% D' cprint(a)
% g5 U3 p) E& D; Qb=a.decode('gbk')
2 \6 _$ `$ R% |; s* iprint(b)28、求 1-100 内的所有数的和
: H- H, H) B( P1 ^count=1
5 h0 G' ]7 N; o% _8 p# b8 Gsum=07 i4 }- y* n# T  i0 ]/ p- M
for i in range(100) :
8 C9 t( e  q0 C3 D5 d5 E% ~4 q1 C6 C sum=sum+count0 W$ g* c) h6 Z" L' l
count+=12 N1 O7 V: o' g, i4 H9 c; x
print(sum); r2 O+ p; v0 q- v" [5 [0 \
1 y# [5 P, {$ ~4 ]
count=1
5 w: o; k0 N# C; ^1 r. b& l" ysum=0
. ?# C$ X3 G( x+ [while count<=100 :/ L8 q; L; e* |! X, X; X
sum+=count, d5 b. n3 {% k7 K/ u
count+=1$ K* \5 p* e( J$ I
print(sum)29、元素分类
/ l5 A) O4 l2 v6 Q9 R+ C3 b有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，  p. I; o& X1 I1 `# l8 K# Y
将小于 66 的值保存至第二个 key 的值中。4 D7 u7 T/ Y! u$ I: w6 C  h) H, [
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}7 h( _$ o4 y" B& F6 b
li=[11,22,33,44,55,66,77,88,99,90]
. f& b$ R% N" f( }dic1={: O5 w( O5 l( l( o
'max':[],
; ^2 ~! v# `2 q1 ^* ] 'min':[]
" D( \) L5 h. l( Q" N, S}
  `6 \1 b/ w" {$ R+ i2 _6 `for i in li :
$ c+ \8 _/ [, {9 p+ a if i <66 :, v  p! x0 S: c4 ]4 {( H" o
      dic1['min'].append(i)' I9 ?6 U! [# B! s; @4 g# m
else:
' H; u& o2 |/ {9 a7 K       dic1['max'].append(i)
1 y7 B: o- y4 }' J5 Xprint(dic1)+ L. {3 E% C0 `9 x

2 a2 Z( _* P. X5 Q4 O- j: ~( ?---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
$ l, H( _4 L. S

Python基础知识汇总

主题推荐