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、写代码
, p1 G. K, {8 Ja.实现用户输入用户名和密码，当用户名为 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 i' t2 l. f: N, Y! j/ l
name = input('name:').strip()
; Z- O0 A" M9 z( k pwd = input('pwd：').strip()6 m" ~& e) [4 P& \' `

& E1 h& ?# G  d, v5 i4 R* L9 S if name=='seven' and pwd=='123' :
2 d4 P/ o8 y7 x8 M       print('ok')+ u2 V: X/ Z" Z  M' g8 K
else:2 P4 q: Z: g) X% _5 b( W5 n
      print('error')
8 r5 x; S+ ]5 ^6 u! i       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)  :9 U: Z8 Y: _; c" H- u
name = input('name: ')
; H& I" y3 X9 k5 j pwd = input('pwd: '); _- z, N0 b5 Z
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':, v0 P! O0 A/ D0 C; M0 D
      print('ok')
. r+ p, L: n0 Z& u# o4 p else :
- h* a( H* r. L0 v       print('error')
& V5 c, y# a- B9 S3 j+ B' P& Z8 P       count+=111、写代码& ~* s7 R& A% g! [5 t
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) :; P# q, H! ?& D& @& f
if i %2 != 0 :! t' Q, N4 l& @! e& h
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
. n' N) l2 d3 b+ S: ~0 O7 S" C if i %2 == 0:
1 ^1 n7 w3 u" J       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"& a$ I6 e& s: _& N( R7 S
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 R  v+ ^9 {$ S/ N& N4 Sfor i in name:
3 T+ }, @% I( i; u( U print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain7 T6 f/ m7 M1 z( D; ^7 r3 ^$ t
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']; ?- s, Q9 ]; p1 M& E5 F4 T
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
$ t* W9 K9 |" }; t) rprint(li)3 {+ W( j0 h; a+ N2 U
['alex', 'eric', 'rain', 'seven']9 U9 p+ ^0 e7 a8 H1 j, p# \
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'). b! s9 ~0 ?& ]- s( b+ L( e" P
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')% J0 n: `. l4 `3 x! p% E
print(li)
2 q/ p. V* ~( Ue. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
4 s5 n& K- S# I& Oli.pop(1)
6 r5 c1 o0 H% Z7 q3 ~9 uprint(li) ['alex', 'rain']
: p2 p! y4 T+ j5 R) T6 G  `% {指名道姓的删除li = ['alex', 'eric', 'rain']
. X! g5 u0 x2 s% dli.remove('alex')) ^. U* [! t8 {8 B/ F) F8 @& b
print(li)' x; u  H9 E4 n# R- w* y
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
# a$ a0 }2 c+ yprint(li.pop(1))
; O0 P5 y) @$ g- o, Uprint(li)2 z+ k: j2 B+ x! w6 F1 P
' U7 K7 F  u% C
eric
$ `  W; r  |, R* r) H" D: U['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
8 ]/ I: G1 H/ }2 Q, N+ F4 h4 Fdel li[1:]2 Q. B+ W6 p7 ~% s% A/ _) F* L8 q
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始); q* J. Z7 b% ]! q. s
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
, ?& O' [6 Y0 T) ^. K7 a print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 M: x2 J' [" [. Ja. 请输出 “Kelly”4 c8 D' p5 _: s# V. |  ~$ m
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
1 y6 d5 w( @8 g7 Rprint(li[2][1][1])
1 o: @+ @( y2 j  o1 M) Xb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
% G7 I/ ^/ l3 J1 m3 v* jli[2][2]='ALL'
  k% K3 y: f' v, ^/ F. J7 pprint(li)
6 u; `4 k/ ^/ A1 L$ x  B24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')8 U2 c# D) h7 V# D$ H1 d
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
3 n4 [: a) d$ X! H" a/ h; z% B3 Xprint(len(tu))
) H' Z' K' V6 k2 Jb. 获取元组的第 2 个元素，并输出
8 v, e8 u2 V& L  v8 l. Qprint(tu[1])$ S' u% h; l0 r  ]
e. 请使用 for、len、range 输出元组的索引* I. d% a) \4 i5 b5 f/ Z& w& L& O% e
for i in range(len(tu)) :3 n% h: Q; U; D4 k
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
6 _6 L' x, W4 z# ]7 @' Jfor k,v in enumerate(tu,10) :& M2 y# M7 p" e8 X2 D
print(k,v)
% x2 G; S/ i  c. y: r10 alex8 U# c3 K, v* H- Q$ x
11 eric
4 e6 s9 ^6 P0 ~" Q9 \$ g12 rain+ D+ z$ R+ \  E+ g

$ s4 e( i$ R8 l' p9 Efor k in enumerate(tu,10) :% ^1 N( v1 V* M* z: Q' q) L/ d
print(k)
& T! _3 m! x5 k- F; R(10, 'alex')
& K+ K5 u( }/ f8 I(11, 'eric')
: u; @8 F6 Z8 p. c% u: S(12, 'rain')
, k/ Q+ X8 J+ [) p; S# b8 o' E8 c; K0 a) g- B- |2 o9 c3 t& a+ g1 i

- B* j# e2 f3 T5 b, t' z, U25、有如下变量，请实现要求的功能0 o, K6 ?4 ^5 c: w' f2 u
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

; Q! i  E8 P4 ud. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以2 n+ v6 u, j, k$ N7 b0 D
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
% H3 ?4 \# I0 z, J+ |- Q: _res=tu[1][2]['k2'].append('seven')2 q! f4 G9 j( V- ?' Z( Y

  E# a$ @: W  Pprint(tu)
" T4 i+ D7 z/ d  l( [: a26、字典# g4 d0 ~. O  F# w8 d
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:2 A0 Q1 [) _  ]* G" v0 H. p
print(i)b. 请循环输出所有的 value
8 {" y' s' N' |+ Ufor i in dic:& |: A" R) r+ v( \4 L
print(dic)! J0 B8 j6 w; Y  D" F5 i0 J
c. 请循环输出所有的 key 和 valuefor i in dic:
  |% E. r( c7 c. l$ o- L' @print(i,dic)
- f+ w( l2 X8 C1 hd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典) K. V, B- o- p* ?: O
dic['k4']='v4'8 m& T( d/ l) q# q& ?; X( A3 e
print(dic)
  M7 Y7 g5 n. Z1 {e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典5 I# W, Q: F6 n6 I
dic['k1']='alex'
9 r$ M# q3 F5 J' u+ gprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典' I' G( b) o* o# H. a/ I# s' ?5 e
dic['k3'].append(44)
6 b0 |) g: T- G* E  @' Yprint(dic)
7 {3 K1 K4 u4 w3 ]- C% D
# {7 ?& r% G, I9 Wg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典4 O. p2 N9 K( _
dic['k3'].insert(0,44)
print(dic): A7 I& n" G/ C( ]9 i- `2 |6 z
27、转换
2 |) t: q8 q9 y) f; aa. 将字符串 s = "alex" 转换成列表  s = "alex"8 B* H7 Z7 ]  }1 }2 U' k4 d
7 X- j% G6 Z6 |6 ?! b- f
print(list(s))b. 将字符串 s = "alex" 转换成元祖# j$ t, ?1 p' L+ h: P+ A8 _) y
s = "alex"6 m; Y& c  x# z% w& t) J* G
print(tuple(s))- b' T5 ?5 q/ B0 ]9 H) @0 ~

& ]+ |* f1 d! O0 K8 ]b. 将列表 li = ["alex", "seven"] 转换成元组
2 I6 X5 f0 |2 _li = ["alex", "seven"]) w' q" W& ?- J' o( j: @  O4 ?
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表0 P$ U6 \0 ~: i1 a- x+ Y
tu = ('Alex', "seven")/ ]6 Z  w+ ^- z7 t
li=list(tu)! {& p9 f: O! P) r2 R- E7 {: p
print(li)
( [8 V: B4 Z8 P- J2 i6 i1 ]; I4 S  _% \# ?; g5 f! G
. t3 K: v! d$ s) K# e1 d
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增1 s6 o) N: t% k6 A! p

* m8 u8 \! _7 {5 i5 g/ U: adic={}
# W( r2 T/ l& z- f; @+ w3 u: Wfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面& K+ H- w4 |( N  D: h8 x
dic[k]=v
3 M. t+ o; d4 \8 z print(dic)27、转码n = "老男孩"+ C, _" w8 C% @2 k# n& s% E
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"% x2 E- `8 e) F2 x: I  e# J4 O/ |
a=n.encode('utf-8')
  {2 F! q2 [8 }print(a): j$ t, Q% P1 R+ @/ N6 C" i
b=a.decode('utf-8')* `6 ~5 T6 D0 q7 B# Z0 m; [: Q
print(b)" ~, w* G! @% z$ i
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')9 a3 W) H' f: o8 Z
print(a)) T. T4 W6 F0 C9 ~$ l2 v
b=a.decode('gbk'), _5 H4 k6 _. `2 M+ Q1 W# F
print(b)28、求 1-100 内的所有数的和
, M2 s. C) Y6 Ecount=1
9 N+ j. o9 R, B& V  I" O  a- q$ Psum=09 W$ c. V) u) _- V+ E
for i in range(100) :
$ \# i7 [2 ~8 @ sum=sum+count4 t: p* h' r% K7 G: f/ V1 ?
count+=1
5 `: V! j% ]4 ]# j$ Dprint(sum)8 H* B2 F. @, N( C& _; [
$ U( S5 e. Z: X; O9 M! Q9 L
count=1
+ X; @( t3 m4 U0 F8 w* }1 |3 Xsum=0
# q# J, @/ _+ y  S. pwhile count<=100 :$ [. s- p/ a8 I! b3 Y% h
sum+=count5 P0 j6 e# u8 q4 B1 O  {
count+=1
% q+ p: j. _  P1 O3 Sprint(sum)29、元素分类: ~( m8 {% p& K
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
1 q$ m7 @4 \; |将小于 66 的值保存至第二个 key 的值中。, ^; c/ ?" A: A8 s' h6 q1 f2 q
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
  A0 g: Q6 }4 T' u% _3 }& F( T% Pli=[11,22,33,44,55,66,77,88,99,90]6 R, N' _  Y6 Y; N1 w* z: {
dic1={$ Q) i9 A9 x4 d. F' T4 R; H
'max':[],/ \" x. S6 u* }& V  X, t( @
'min':[]
9 s5 k+ L& }0 S. N/ j5 w, F4 `}
6 C9 [: h8 Z1 N) p$ k& X; Afor i in li :
. d$ N& k& Q* F0 D4 d if i <66 :
& N: n* T1 I0 Z4 i       dic1['min'].append(i)
5 S8 W) k; c- C8 _ else:' ~4 l: V, `* }7 V( l+ f
      dic1['max'].append(i)
' l5 s1 W7 ^  aprint(dic1); V: N) ?3 u- k& p
; p# k1 }/ d7 c8 B3 O2 E# A( `
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}% V8 B8 G3 a5 G: v  N+ ~

Python基础知识汇总

主题推荐