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、写代码
; u0 F6 }& r* J7 Z, s* ^* Z4 ?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) :; s( P  a* q1 R& p3 w- ?
name = input('name:').strip()
2 l' j/ H$ _6 o1 @: _ pwd = input('pwd：').strip()
& g" D* v: q5 `9 \& w& u! |) E% `" G0 B/ U6 u+ O, u. n1 M0 h6 Q( R% y: B4 p, N
if name=='seven' and pwd=='123' :7 P1 J1 J/ s& j4 d& |
      print('ok')$ J: N! i0 p; b. \/ S( O; Y8 }* C5 T
else:4 J0 z- @/ _, {! t& s2 \9 b2 @
      print('error')' F  W# D" y3 J; j4 n5 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)  :
- M/ z& \. M+ x7 {4 L name = input('name: ')5 a! M$ u' a# U3 Z; t' b
pwd = input('pwd: ')
9 u6 ]; t; H6 x/ g6 q  k2 W5 q# X if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':& j( U: D" W9 m# m& ]
      print('ok')
# |0 ]' g5 P  H9 M# S4 u else :
9 @" T) k; d, F) s6 Y* J0 i/ x/ B( G       print('error')* U6 T8 t: g  h
      count+=111、写代码9 [& r: K% n; x2 f8 `
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) :" y( E& Q" i) Y3 `  k) X; |& u
if i %2 != 0 :* ?% G# C1 w: h/ B! T0 D
      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 {$ G" z) ~ if i %2 == 0:
; w- ^$ }0 j9 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"
0 s+ D' Z  ?) @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)
, t8 U5 j; n/ efor i in name:
& y$ N1 b3 v0 m- Q% @6 M print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
; a6 v8 l/ [$ L22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
, ~. X5 R% `6 e' q3 D# I3 Tprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    / y; V$ P$ A: E% z
print(li)# o9 X: S1 L* }, Z- G, p2 f9 D8 T2 ]
['alex', 'eric', 'rain', 'seven']) X9 q% B) V  o6 `
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')* O8 y- v) W. Z$ d1 H' Z
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')3 e9 E0 v: C+ c/ ?' b) _" q% f
print(li)6 L" S! n# a9 [- z/ B% d
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
# H: [: i! e: m' I- Tli.pop(1). `# o# h9 g: c( M3 Y8 i/ I; b
print(li) ['alex', 'rain']9 |. o  A# R7 G0 `% A4 I! P( p
指名道姓的删除li = ['alex', 'eric', 'rain']3 H5 L" }! P# x( l- p
li.remove('alex')
3 Y5 [4 f+ V4 N# o, Fprint(li)
4 D% A/ d6 S5 yf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
5 a" Y5 M4 u, D) U/ C4 _print(li.pop(1))
8 e  }0 H. n- W) b3 Gprint(li)
7 x5 E( i0 s( w% D' G& j8 r9 l, G) z7 h5 T# |4 I
eric
- T  X: _) Z0 Z2 x, j['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']: I2 F, f/ k% a* A7 F  l6 j
del li[1:]5 }- B6 F* ?  {( s
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)& n" k8 o3 R% @7 m5 |# d
li = ['alex', 'eric', 'rain']/ _% n, o& j# w- t  Q# X& r  ^- r; }
for k,v in enumerate(li,1):9 t$ K! L: H1 f3 D% [
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 B: K& d; D$ g0 i) d
a. 请输出 “Kelly”( R' u3 g/ }" C6 D
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
& L! T2 e- I6 c# C' dprint(li[2][1][1])
  t% }- p$ ^/ M" Qb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
! W( V8 l! o" B9 }& k! cli[2][2]='ALL'
$ {/ c) f1 Z6 M: X! d5 Wprint(li)
6 x4 h# m4 p& F24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')6 u! R3 D5 }+ H6 T/ d
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')' z1 e+ D- Q# ~# D8 W. l8 N3 Y
print(len(tu))
* M# [9 `+ o+ k: [b. 获取元组的第 2 个元素，并输出
' B7 w8 l+ k; H( a& r% v3 r7 y/ Zprint(tu[1])
* B; p7 C7 e' x9 T1 Xe. 请使用 for、len、range 输出元组的索引
- t: t( g/ w9 u3 v, g! Ufor i in range(len(tu)) :
- O# C4 o: q0 h! H4 R print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)" v5 R( _+ J3 F- r
for k,v in enumerate(tu,10) :
! ]2 W" j! C/ ?+ J2 h print(k,v)
( t* }- V) u( C$ l10 alex
2 ~+ E( I! v+ R11 eric
" ^9 C+ B7 A& ~+ V12 rain; s  u& x7 Z% T5 N- H; l2 G+ o

8 P2 e  S! s3 e, R$ v7 A( xfor k in enumerate(tu,10) :
3 ]& f2 \! @: {6 y9 w2 k7 B( q: l print(k): x3 G8 r5 r) N! I+ ~" D
(10, 'alex')8 x0 B2 K% v$ F7 D7 @2 d" V
(11, 'eric')% s/ z! K% L# }* f( ~/ }4 Y
(12, 'rain')" R0 q) s, e, {
' d2 v8 l$ K) q& X

2 B) Y: u' k3 [  g; ~( s25、有如下变量，请实现要求的功能
6 E2 \5 G& z( V* {+ utu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

- d# M+ D4 R1 kd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以6 d. C% `$ {1 L& a# _9 {2 ^
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])" v$ P4 @, y# C' E( E
res=tu[1][2]['k2'].append('seven')/ U% y' ~; s: R. m
0 h  l- i* b7 Z5 s
print(tu)1 s9 Y  Q+ I* a' O& k* S
26、字典+ `" q- E3 J, m+ [0 o
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:. S- w. i" C  ?5 N
print(i)b. 请循环输出所有的 value
- K( W5 s1 d' o# d) s0 r- afor i in dic:
7 Q9 b2 {/ @7 c2 `- g& }3 w. a9 c print(dic)
6 K& Y, s8 }, {* hc. 请循环输出所有的 key 和 valuefor i in dic:
: g: b$ Q# A. G* oprint(i,dic)2 t2 `7 O* i4 h5 C( q1 M* H: W
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典1 @! q/ ]/ t( A
dic['k4']='v4'! s3 L% F6 }# v  k1 R6 |8 ~7 [
print(dic)
, a  h$ ], A8 I+ ]: R) Xe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典6 m& n, B2 K0 f& F+ I5 ^4 A
dic['k1']='alex'
: f9 x3 ]  a2 Z+ p' `- l% \1 Zprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
. i) m  |" [, H' c. J- Bdic['k3'].append(44)' N  N" t: ]7 E' Y: U# K- o
print(dic)
6 ?( {5 e8 d- T- \: n& l6 P
5 l/ @, U4 I8 |6 [* P% n' i) ?" `6 yg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典" b7 V: x! t0 I, v
dic['k3'].insert(0,44)
/ q1 F8 o1 b* o, ~( _print(dic)
6 z  y& J5 i6 n( |$ t27、转换% ~' G) B1 n' L; T/ U- K
a. 将字符串 s = "alex" 转换成列表  s = "alex"
6 R* B: d$ _  K( S" K: x+ ]' W6 }1 i" m) X5 r  }) n4 ?. B6 Z
print(list(s))b. 将字符串 s = "alex" 转换成元祖
9 Q7 T% V- q  ]8 P. ls = "alex"& I3 Z/ N1 ^" ~; j8 L( o
print(tuple(s)): K6 R0 g5 A* @* G& A! i. Y6 l
. `3 h+ ~/ a( V1 T9 c5 E0 a
b. 将列表 li = ["alex", "seven"] 转换成元组, ~6 X8 U/ F' a$ a, Y, Q8 E, y4 {
li = ["alex", "seven"]
" p, G. @8 t+ W1 B6 z1 m7 ^print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
+ ^8 y3 ?8 s9 r) }9 i; wtu = ('Alex', "seven")
3 w0 t) R- e- r; ali=list(tu)
# d, n# b+ |) f% {print(li)
; p! z" n# n7 p0 `  J- u: h: ?4 Y6 P. `

! w0 A9 g( `) M! X* qd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增3 L& f1 E0 k- O) B
: E8 n/ ^7 {- l
dic={}
7 g: M( ]1 d' Jfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
$ {4 k& [9 D; L- L dic[k]=v. o, b  s1 O. X5 ?+ y
print(dic)27、转码n = "老男孩"
" p2 `2 W5 P$ ra. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"' Z7 @3 W+ s1 _7 y* Z
a=n.encode('utf-8')
& r) ~0 O4 S& Dprint(a)( e8 U" k4 W, |* a2 {
b=a.decode('utf-8')
. Y: b! u0 ~5 G7 c3 p' o0 iprint(b)% q; D: R$ m$ o# C$ @- v! Q8 ~9 h
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')4 s/ X) h0 j2 d" h8 T' Q  K$ k
print(a)9 _. E- a' \$ t# G7 \, r! j
b=a.decode('gbk')+ |' w  P/ C' c  m6 W
print(b)28、求 1-100 内的所有数的和  {' o, `3 q" C
count=1
6 k4 H& y6 l) q  w6 E5 q- ?; z8 Gsum=0
* Z* x1 x6 U+ [5 o: [  l; \; vfor i in range(100) :
' N- C# y- t, t/ \' ] sum=sum+count; F0 B( ]& U6 v, L: P
count+=18 _: p2 |) j8 f  L9 ?' E
print(sum)0 e- _% N% M) I* g6 I

; a+ D' R# h* H6 I) \count=1- K  j& t/ h" x0 D  e
sum=05 G" ~5 |, p9 r$ b% V& L
while count<=100 :8 E& A5 c1 Z  M$ c: e! b
sum+=count
, x+ m8 i) z5 p count+=1
$ M/ K4 O/ B- d' Q0 n2 Z$ L0 ]print(sum)29、元素分类
& P  A+ V1 \& H9 d2 V4 w+ I" A有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，9 H) ?; S) g' N2 V, a+ |9 g
将小于 66 的值保存至第二个 key 的值中。
. _" ^  y. k8 v9 x: ?0 G$ o0 f即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
7 y& ^0 q$ D* F* j& N1 N. e, Kli=[11,22,33,44,55,66,77,88,99,90]# {8 V( c$ I  \3 R) F
dic1={, t, ^( C$ Z7 C+ r6 J
'max':[],
5 }) A3 J2 C  w- _  Q( c+ }* t 'min':[]
* L  z" u2 q$ U; q" i0 I* d}
: G# o* _% }, z8 c9 ^for i in li :
( `$ N6 [8 P7 [, m if i <66 :
# n2 Y' P2 P  r2 ?, T% L; G4 l       dic1['min'].append(i)
8 Y- @( H3 ~/ P) \ else:
8 L, X1 {0 B. M; p4 {2 a& i       dic1['max'].append(i)
/ I" @: a1 }1 v1 _, D. Z9 v( w# sprint(dic1)
, ]% i+ a, K: q8 F3 w8 m, G% r5 z7 t0 Y% D" j2 G0 _% u
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}5 R# @$ T0 Y, O) v  P

Python基础知识汇总

主题推荐