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、写代码
; m- l) w0 G+ 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) :
' l4 W0 s6 b3 j( g/ x9 H+ g6 k name = input('name:').strip()3 @: J$ j; |. x6 x- U. r
pwd = input('pwd：').strip()
1 p& i" [7 A6 v+ [8 ]/ S% E6 O- M+ ~5 K* k' s
if name=='seven' and pwd=='123' :
; i2 Q: t3 e. G4 }       print('ok')" e; N& d2 T1 Q) d4 x9 W: @
else:7 O% i: ?- `" Z% B. F
      print('error')# n( R, ^; F# E3 j& Q8 {4 M
      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)  :5 F' a* z8 b; U( [2 h) \6 {7 L
name = input('name: ')
% A! z$ U  K3 ?( D' ?+ C  }. B pwd = input('pwd: ')- `9 Y+ O* J3 N* \" z" g9 v7 b* b4 f
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
) u$ f0 I/ S' z       print('ok')( c' V6 F0 j4 I& l& [! P9 l
else :+ k/ b, v3 |& G) J% G  g& k
      print('error')# M9 @: }  I7 j1 j$ ~
      count+=111、写代码& J- J; K1 M1 L+ B
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) :
/ R% c/ p% i; W+ B+ p if i %2 != 0 :
- j6 ~7 a& ?+ v       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
, z& m6 R, ], Q1 d. l1 ?% ? if i %2 == 0:" T. k* u' R. e! M+ ~( s4 g
      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 i$ H# T7 o, o  \
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)
5 i+ o3 H0 {1 V% S1 Ofor i in name:
+ Y. o0 k" N. J0 e1 p print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain. S8 v& Q! V9 y
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']6 r/ \+ X( M3 F2 E1 F
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
8 J" {+ G6 N5 iprint(li)
6 g# R; s, d! h3 \  S* X ['alex', 'eric', 'rain', 'seven']
* q" f, J4 @( |3 r) p3 dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')) V/ i- o4 K, A/ z% w0 v
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')+ I9 ]" c; }0 i" `
print(li)
( v: F$ a! \2 F. a& X4 Q& ue. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
6 q# ?! i$ ^) S; Y  oli.pop(1). Z' C, y. y6 `+ u- V
print(li) ['alex', 'rain']
8 ?1 Q) A4 E' E( a' t4 H/ I指名道姓的删除li = ['alex', 'eric', 'rain']0 @% q% e7 i( z' Q  r. |5 D2 I
li.remove('alex')! N# `4 b# x7 P& G
print(li)
! ?; b; }" o3 M+ F# rf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
7 y: S8 p8 `# Y* Z' M# Tprint(li.pop(1)): d9 P7 u7 R6 L7 Y+ P
print(li)
( K! d* M: _0 \: t0 h1 U) _: G3 n, Y+ G3 G8 W6 o; K
eric
* I4 S: X4 C) o5 D3 y['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
3 t  x# V% N5 m; a% S- H. ^del li[1:]% R4 D  H( F; O& u9 B% |1 z, W6 T
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)8 f4 g" d: d" m% b
li = ['alex', 'eric', 'rain']' a- y$ N5 y/ ^& o
for k,v in enumerate(li,1):
1 D, }# ~. |# F% p$ L' D print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]- I. a( w- r( ]$ T& [7 ]1 c
a. 请输出 “Kelly”1 o, G7 G6 e7 R" T6 ~) a+ ?
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]: ]# z5 N7 e, _- V, Y# ~$ e
print(li[2][1][1])! o" r+ M$ _7 J2 G; U
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
& i8 E- ?  s8 n; i4 }  |li[2][2]='ALL'" G" p. d$ n: g4 @
print(li)
! g+ b% r# Q7 Y/ |( g4 A2 ~" g24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')( _/ S: _3 ], Q
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')- V1 D9 j, q+ e$ S
print(len(tu))
0 Q1 q4 [9 J) a5 A# ?) s$ \7 nb. 获取元组的第 2 个元素，并输出; G2 b+ Q  E9 F% d6 b
print(tu[1])8 ]; A  X/ w, i
e. 请使用 for、len、range 输出元组的索引, ?, d- N/ M6 k# y" j7 C
for i in range(len(tu)) :
' g- \8 _& t, H$ V print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
1 h- ?, \6 O$ n9 ^* ~! c5 |for k,v in enumerate(tu,10) :5 I3 l5 L3 W' L) \, z' e
print(k,v)2 R$ S: A& A3 g( a
10 alex
  S  a1 M. e3 M% }+ D$ J% R11 eric/ |0 ~5 k' X. H$ k3 Y; Y7 z
12 rain2 i! Q! h' h; M( Q/ t
0 `5 e' B# Z2 v# U/ m' D
for k in enumerate(tu,10) :
% j& ~  u1 `9 I  }+ a: r$ L print(k)* z8 k9 u/ Q, ^/ g: Y5 x5 ^/ H3 X
(10, 'alex')
( ^; }0 }/ S5 D) N! B0 Z7 u(11, 'eric')  ?: I& Q8 p# s+ ?+ w. y* d# K
(12, 'rain')
) P5 [1 }8 C! m  b( [4 J* g# I, R7 d* A* }" w
' T; r9 A& K' D5 R
25、有如下变量，请实现要求的功能3 ~# g5 \' s' z1 d
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

  \4 \7 R# M/ d0 bd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
2 n: a7 X! r+ c" h# {; Itu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])% K. }; K- _# g+ D' H' h
res=tu[1][2]['k2'].append('seven')
' R: c* j) T5 k. p  i) n) n5 \; S
print(tu)
. Y7 x& G6 S4 Y1 U- A26、字典
: |0 V; O1 V# @8 B+ ldic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
1 J& M9 I, s! b print(i)b. 请循环输出所有的 value
, a: |/ }: N' ^& Z& l7 r% Hfor i in dic:
" f) j- o2 A* O: K/ Z print(dic)) M- @% E& {. D! b2 P* n7 j
c. 请循环输出所有的 key 和 valuefor i in dic:' S$ f. h6 A, M+ [9 A2 H
print(i,dic)
6 \1 N0 c- W# E# F. s  w, i- Cd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典4 ?3 W9 o9 l' x1 W2 U
dic['k4']='v4'& _8 L) z/ H- ?* N7 I9 o) c9 J1 l
print(dic)
* r% [" s& |- U6 R+ D) L8 Ve. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典/ D  V4 L  c  w& p
dic['k1']='alex'
) @: a% e& ^7 N" K8 E: ~print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
" d1 W! [* f  ]dic['k3'].append(44), M9 O% l6 w' u' p0 D( W: I
print(dic)* F  H* E! L& |

, D0 E) E& ]4 X  @g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
' d( E5 S4 i, l+ K) }dic['k3'].insert(0,44)
/ n4 |" b' ^+ u: a  P7 mprint(dic)( |( I6 H! P! w" E# o3 V( `
27、转换& \) y6 F# F# p2 |+ Q. \
a. 将字符串 s = "alex" 转换成列表  s = "alex") l: E9 n, p4 ~' p& e
( j9 {, ]. r7 ~
print(list(s))b. 将字符串 s = "alex" 转换成元祖
) _2 _3 t% p, F1 F' xs = "alex"7 K& Z8 X' z: A( Y  \
print(tuple(s))2 X# z" F* {+ C0 J0 ^  g) K+ [
" C8 L' ^! O9 |: p
b. 将列表 li = ["alex", "seven"] 转换成元组0 d4 b4 _; @7 |
li = ["alex", "seven"], `5 l" l- X9 i1 \2 q
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表- y+ ]" a9 ^) i6 r* L
tu = ('Alex', "seven")
1 W) I8 e2 R0 I( ^& _, }8 nli=list(tu)
1 ]4 @0 l) C% E8 gprint(li)$ {+ s! P# ]0 O' G
! S( _9 _6 k* m: ]( x( ^
" o( G$ k$ a2 y
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
& L- P* g, V0 Z  i% H  u6 l& g; {; x) B& X. N* Z
dic={}$ a3 p4 N' o5 H9 r- G, l8 H
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
2 {2 C! A& x% a% x0 Q, M dic[k]=v
, I4 K4 t$ s1 Z- d" e0 P print(dic)27、转码n = "老男孩"
! t2 {$ F, j$ a; ga. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
! ~; U$ a! w, d- N% ma=n.encode('utf-8') 8 I" c' Z2 m# R1 k7 I
print(a)
' m1 [; z- k" J# f2 F: ~+ ?b=a.decode('utf-8')
0 R7 y/ U* m1 |) q. Lprint(b). R. K0 U. k5 \5 X" S- N
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
) E$ _! g) o1 r2 O# m1 ^print(a)* n# G4 n8 J+ R3 p1 w
b=a.decode('gbk')! E# R; l  D" `7 S, {- e# _
print(b)28、求 1-100 内的所有数的和2 V: q1 b! Z7 e
count=1* X( s( W& l) _' m0 ~6 r
sum=08 ?9 }6 N8 k* M) g: B6 }7 \6 l7 F
for i in range(100) :
9 J0 e' |3 ], e- {1 @5 {0 T' l: { sum=sum+count* [& n1 a$ H! B/ J7 J
count+=17 _8 @0 B3 W( |) {+ B. S4 G
print(sum)2 a5 u. h3 c; s. q/ D

* v1 i& p) K5 Wcount=1
9 q# k! E: R. [  L6 f; k" tsum=0
% u+ n8 q* c3 U$ pwhile count<=100 :2 k/ D, p$ ~2 o' C( D
sum+=count
% c6 z# A2 y, x- ^; s) q count+=1
1 V  C; b9 j1 S: ^6 z1 jprint(sum)29、元素分类
& c" M  y' A7 W- k9 e6 m' `! t# o有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
" ]% R9 Z. R( l; Y& V6 }( B将小于 66 的值保存至第二个 key 的值中。8 O) s6 N) T* {. y2 \/ R
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}% s! I5 P: x8 s& i, b
li=[11,22,33,44,55,66,77,88,99,90]2 T  T- t: i7 F' S: u  o
dic1={
# F* ]3 S( [7 j$ s1 M 'max':[],
5 W3 t- A( m4 D: F7 V, |5 T) ]1 u* B 'min':[]
' ?9 O2 z2 Z  c* \}0 }- F9 {4 |' \$ u
for i in li :+ S* b7 s* e, y/ H3 I) w; E7 A
if i <66 :5 i: I% ?0 i1 H& M3 I- R+ z$ H
      dic1['min'].append(i)+ V$ O3 }% Z6 R0 E2 j7 K3 [
else:  L/ y5 F2 U% z
      dic1['max'].append(i)
3 o" r3 W. e+ yprint(dic1)$ z' S) k# W+ k8 j' M' e3 @
* e& n8 c6 Q# f7 L) H+ E* _0 ^
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) G% A) ~# Q; F! J! N

Python基础知识汇总

主题推荐