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、写代码
! E! s/ k/ w4 f* H, ga.实现用户输入用户名和密码，当用户名为 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 Q! d2 ]' }4 x* S
name = input('name:').strip()
2 U4 z( o% F( b- f  b pwd = input('pwd：').strip()
0 ?+ u1 n1 L) K: s' ~3 v, k7 J0 d; y- [( d7 O) S7 m" |7 ~6 d/ L1 Z' o
if name=='seven' and pwd=='123' :/ Y5 s9 c6 C8 F' e: r( f9 ~  z
      print('ok')
2 z, f* f! p! B  p5 b4 @ else:
" j" _. f6 F/ _3 i* t# G5 ]9 q       print('error')
3 c/ |! J0 `: m/ c* }6 `       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)  :
( H+ c2 t! o# R9 L# d5 E( p# H* ^' k name = input('name: ')  F9 L8 a# F- `6 g
pwd = input('pwd: ')! K! d; l# \9 \. b+ u
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
' ?- M: h& h' T6 ]2 R" i       print('ok')
2 N7 H! C5 f, \1 W/ e) W) I else :( @4 R* F6 J# V+ y
      print('error')$ y7 f$ s( b  i
      count+=111、写代码" X8 G) L/ T9 K+ O4 u0 L
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) :
# U2 V" @1 [" o& b1 u, O if i %2 != 0 :
% j$ F9 G6 i: z& E  M2 o       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :" C$ q6 R& O% k. V2 q: c7 ~
if i %2 == 0:. q" H( m/ ~; t8 Z( M
      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"
$ T# F) M6 P4 H$ b4 V- Ea. 移除 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)0 ~9 w5 L/ U' o5 v8 b7 B
for i in name:
% X  e% q0 }. g! v7 b print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain$ t7 O5 v( t. E+ X+ y+ u
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
4 \. U& {! x- v; N* v& Q, a4 I$ aprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    4 h2 c  w* ~3 z! \
print(li), y8 {+ x+ E) c8 F) h7 M- j% P" n
['alex', 'eric', 'rain', 'seven']$ S' d5 Z. n+ l9 X
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
8 H7 Q$ z+ }% K, y& Hprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
$ X8 Z( M( l/ z- e9 p: k5 Lprint(li)$ z4 [/ v1 S( H
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']6 e) p; s1 d, b6 o5 A6 t
li.pop(1)
# v% ~! {6 X; {; q/ v0 ]2 V4 |4 uprint(li) ['alex', 'rain']2 Y5 i2 b/ e1 a& w3 T9 I
指名道姓的删除li = ['alex', 'eric', 'rain']
; [5 p( x+ K$ rli.remove('alex')
$ c/ `0 p( [3 w3 y7 tprint(li). o1 r( L& H' e( _5 E+ u) P! v
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']) R% m: M; B' P* q! L  ]! U
print(li.pop(1))9 P6 f' D4 W6 A% J. V6 f* V
print(li)
  p. H% l1 V: K: B. z+ o: p
) J5 N7 M: ]/ I) `/ [eric' l9 @0 g; W# }6 @9 {* @/ }' c
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
/ M7 g( E' U/ K7 M$ fdel li[1:]" {& ^+ n/ s+ X3 U( i8 _! w! k
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
' y" M* q9 H5 H, V! I, P& Z2 Hli = ['alex', 'eric', 'rain']6 c/ z4 l9 }" d* Y, ~3 N
for k,v in enumerate(li,1):
' J7 n& k# ?9 L+ h+ Z2 N% v print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
8 v; |0 Z- h7 Y, Z% Pa. 请输出 “Kelly”
+ Y3 a+ O2 O. Q3 @li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
1 X% F* @. l3 o# Y2 }1 cprint(li[2][1][1])
- B! h( U; h/ l6 O% O+ }: |b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
/ A* B" `- b7 W1 l. \+ V  d$ Q, yli[2][2]='ALL'
5 t  k6 @2 ^" ?print(li)
: [& p/ k- Q1 R5 }0 Y24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
* y9 p  {! g# i4 J* d1 la. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
, h2 v) J% ~( I( k; a$ T) mprint(len(tu))
$ z, w8 l8 }8 H, W# Q1 ?b. 获取元组的第 2 个元素，并输出
: Z& P7 ~# ~0 ?' _5 Y0 T8 nprint(tu[1])
- R' y4 j3 B9 @% z+ w9 Ue. 请使用 for、len、range 输出元组的索引! g$ c" s6 Q( P4 c; P) _: c# ~
for i in range(len(tu)) :
' B4 O8 }( ]0 ?% _6 G  N print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)) F( E) p2 j/ @
for k,v in enumerate(tu,10) :% O: q1 l' V3 F, m2 c* `2 c: J: I
print(k,v); j' r4 s7 Q7 W( V" A; b) V8 k0 u
10 alex& V$ w' |/ v0 p
11 eric3 z6 Y8 e3 V2 W- E8 v5 t" A6 E
12 rain
" j3 }4 F" Z* `) P* j* ~9 I6 a; B+ a  X7 B3 [, y- |
for k in enumerate(tu,10) :
! d. t# N, @$ H$ B: M; j  ? print(k)
) H# }! b8 m( p(10, 'alex')
+ W) j4 g; V) K% X1 K# z(11, 'eric')* T$ A; t, F0 G5 k" T' L% E
(12, 'rain')+ O* _$ W% a3 G8 ?7 q0 D4 J3 @

- S. v/ a7 I# q0 t; _  M3 l$ z: q) Y, p- w
25、有如下变量，请实现要求的功能
4 r9 S. |) a" btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

0 M! {1 L/ a. ]d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以% ^- X! ^, r  f. L" u6 ^4 R
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
8 x- l( M; w0 p5 r* j9 ires=tu[1][2]['k2'].append('seven')
! [/ m9 j, C5 A& i/ k/ m; b: {. H9 o" [- V" x# {/ q
print(tu)! P) C: b) m% ~" e* A( f* _: r
26、字典0 D; U+ L0 f6 `+ ~% {$ _  v
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
" i' I7 y2 V% ^5 l/ g print(i)b. 请循环输出所有的 value
8 G3 X& \6 D# ~3 ~; P+ H7 M. X5 n  Wfor i in dic:  D: `8 f5 R# A* O
print(dic)
5 l1 S, M( j4 |: Mc. 请循环输出所有的 key 和 valuefor i in dic:
# m% p3 g: J% @print(i,dic)
$ c: I& @/ {, O* D, q  g' f' Kd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
! l) A" o* H5 D7 ~. q& M5 V" W/ ]) [dic['k4']='v4'  U) h/ J! [, {
print(dic)
& S' O6 h; @2 x& k, m" p% F5 @e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典. H9 m; k* v4 q
dic['k1']='alex', W& P! n  e  E- ~' ^! s
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典0 m2 W, u0 u: [$ @  h: p( {7 B$ ]
dic['k3'].append(44)
" X  U* V0 s' l' M5 ?* c! fprint(dic)* S% \1 m% d9 X& P' X2 a9 q
" R: T. _8 u# o& ?$ I" P7 o! t; y
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典- z' R. z! A0 g6 D
dic['k3'].insert(0,44)
0 X' @' X1 w( i" uprint(dic)) u" T  m# |6 c! }" ]
27、转换
3 Z* o4 T& m# W. F: sa. 将字符串 s = "alex" 转换成列表  s = "alex": X  |6 C  n7 N# N% c. I! i
7 o/ y3 d  Q, y+ J6 v) `
print(list(s))b. 将字符串 s = "alex" 转换成元祖/ i; F* U) |6 @( \
s = "alex", l/ a; _" G; N; y1 H! d7 `/ ^
print(tuple(s))
" o, F) [' A! ?& E( n. s. W& J+ ^6 h. q3 @/ }  A8 c
b. 将列表 li = ["alex", "seven"] 转换成元组
- J0 z6 D- u8 N$ M* d1 m' {8 ~li = ["alex", "seven"]( [" s: [9 \7 A1 f6 a  Z
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
( M5 F# g/ `! b2 ?- Htu = ('Alex', "seven")
5 Z  `/ ?7 z/ b  P3 r8 W) jli=list(tu)
1 |5 T! ^' W0 {& Y3 A! Tprint(li)* S9 h' x* g9 K! H% c

5 W- U. X* I$ s6 S1 g& d" R' c0 h7 ?, w/ Y4 w2 v- W) F' q% h  j
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
- `( D. ]$ O0 o2 l" `8 d6 R' r& m3 {
7 ]4 e+ _0 T8 l, @% ~; l  t! U( Gdic={}
: g8 T, A7 V) Jfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面7 c. ]2 v0 M! `
dic[k]=v
, f; R- [8 d4 F: C9 z+ i print(dic)27、转码n = "老男孩"
- {$ d) I& T6 V/ s7 L& C+ ]a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
! b: O; |; c: l1 R" m) A9 U' Na=n.encode('utf-8')
: A8 z" Q9 _/ C) g+ Q9 l' A) m% E& cprint(a)) S6 B7 {1 }5 M. b* _3 p2 g
b=a.decode('utf-8')- n$ \' R/ p+ r) W- U8 ?
print(b)
) K3 f5 i& p4 l9 i" M0 I3 gb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')2 o( A5 ^0 m8 I" u7 k9 \2 `; i
print(a)2 ?& {6 p9 P5 S- i8 C
b=a.decode('gbk')
2 c+ O% g3 Z4 o1 }: M% l6 J2 aprint(b)28、求 1-100 内的所有数的和# M& D$ W2 P' k% `
count=1; u; H. z' w3 }( v' ^) B- y
sum=0: R! u4 B. P; ~* b" H
for i in range(100) :& H+ k9 \/ v  T. N" z9 c9 t
sum=sum+count9 G0 m* x& O8 E) Z
count+=1
3 z5 }9 K" j- I  W5 V( g. g. Sprint(sum). B: T5 e# w% c0 y2 A" d3 c5 c

, w* V4 V  y+ R* n7 g) n$ l4 Vcount=1
  {, J; L, K# u, @( B! d) ssum=0" S8 C6 G7 W3 Q! G
while count<=100 :2 b' |$ F  h9 o6 `' x% j
sum+=count
) K% i7 B8 H7 e3 \4 { count+=1
8 B2 \6 q$ j- m+ u# v& L5 Gprint(sum)29、元素分类; R/ e* T0 x. ^/ R8 S5 ?. N9 B$ y
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
, o5 ^  o- c  S# ]8 X, {" u将小于 66 的值保存至第二个 key 的值中。
6 A# H( b# p0 A1 e' |( T" Z# J即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}" @( S% ]0 l9 c0 N2 `
li=[11,22,33,44,55,66,77,88,99,90]
6 x6 a4 o; k1 ldic1={. X7 A6 S, P7 A1 L, V6 F! b0 S& x" L
'max':[],8 y5 a6 m) c  K$ G0 e
'min':[]
+ L$ G* r/ r: i6 ~, F}
$ z2 D6 Z- v, D( ]3 P+ V4 Efor i in li :$ N/ J! @; f4 L3 \2 k: u
if i <66 :' e* T4 a" m6 y, A/ o2 o
      dic1['min'].append(i)- Y+ B4 _. F5 Z0 ]
else:
! Q9 K7 K" x3 _# `2 z3 W, C       dic1['max'].append(i)
  g; K- `  @* G6 fprint(dic1); G% W$ e" O8 r! z8 x. z
3 J% S; z! b0 C+ W: g0 j
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}* K/ q4 D- O) E( i+ X1 `# i

Python基础知识汇总

主题推荐