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、写代码
& ]6 O  ~: y; c# v$ a4 `; Va.实现用户输入用户名和密码，当用户名为 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 a. n; h! \8 y* H: y
name = input('name:').strip()
4 ?! {  Y& N' b/ \9 Y2 |3 t% k pwd = input('pwd：').strip()
8 j7 {! p. V) G& |
  B1 r0 q+ j# \ if name=='seven' and pwd=='123' :& t* y8 E8 U: ^; b8 p# Q
      print('ok')
2 a3 p' h! \' h" J) A6 g8 F else:
3 p  d; \" ?1 j5 l$ p1 P. ?       print('error')
0 A! S  L) L5 d5 J+ q# ~       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)  :) M8 @) g1 H$ W$ [6 C" v
name = input('name: ')
- @5 Q* T! k* l8 h& Y4 K* G pwd = input('pwd: '), B0 l# s: d* J+ h; u  S
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':9 N9 E4 G- C0 |% s' y- m8 X
      print('ok')
4 k6 B" I- A: d/ _& D) o else :
5 A! u* O2 f* E       print('error')
% @( h/ U- ~' X. J* }; k" p       count+=111、写代码
+ C$ q/ H! W) qa. 使用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, w% G4 N' ?; F& u4 |
if i %2 != 0 :
( G, k3 t3 C, F1 Q4 L8 t       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
( O+ I, `6 t8 s9 ]5 k+ I9 | if i %2 == 0:
6 f4 @" s0 t! r0 N5 A       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"
8 J# m  g9 O# x+ Y1 T+ w& ^) T' d5 @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)
6 |. d) C! H0 T5 U. g+ Afor i in name:
! x5 z$ `$ ~0 x' R7 _ print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
* H7 C$ Q) d9 D7 b. G22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
- M! t4 A2 E' l% O% fprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
; m1 y) }/ f* H; G: }$ \. [) rprint(li)
; p% }" v' w4 b* V ['alex', 'eric', 'rain', 'seven']' I2 X4 m1 f3 d" ]4 K
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
  u; T# \9 r! Kprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
% K: I$ _5 W+ N! G" ]print(li)' H/ {7 Z4 a% L7 f& L: q8 K& _% V
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
3 j* ]3 u2 c' Jli.pop(1)
2 i  Y; {. i4 p0 @7 Rprint(li) ['alex', 'rain']
0 p' m7 C* d5 B  D5 i( j指名道姓的删除li = ['alex', 'eric', 'rain']: \9 I9 ?  d6 g( W) n! R* E8 o
li.remove('alex'): e; n) D. g0 |0 X
print(li)
6 W% a) k) w, M3 Of. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']0 w% ?% ?8 K- k+ Y) u' ^- x# A
print(li.pop(1))
% v3 M! |5 ~! q9 \, k0 O5 V: Y' qprint(li)) z! c$ @; b/ u& e

% V& Y4 h5 c1 k  W( |: r  peric" U& w0 I3 S7 X
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']7 `% u3 B' ?6 r% U/ r  }
del li[1:]# D. G+ b; F) W0 C+ P' _% y
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
, Z4 x+ p9 m" j' d9 o/ G  f' ?6 b* oli = ['alex', 'eric', 'rain']
0 T" p: |' k6 ?7 @1 ?for k,v in enumerate(li,1):
5 B- I- p6 R; k! V2 O6 x! q  h* Y print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ D. g+ z; O  }& `a. 请输出 “Kelly”* O0 H' @3 H1 g4 \
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]$ h) Z$ n! l. i( Y- O$ d/ I
print(li[2][1][1])
" {6 A" ]/ V- L. u( L* vb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
0 H+ I/ z. @) _' I2 Z, cli[2][2]='ALL'  a+ x& q( h& J: \7 }) F
print(li)
! [6 k0 x5 v; V" D2 j24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
( d* S/ P% w  _  X  La. 计算元组长度并输出tu = ('alex', 'eric', 'rain')( S8 j1 v: }; [4 l3 R. b
print(len(tu))
8 o* \1 K  d5 W7 @  d; L) Eb. 获取元组的第 2 个元素，并输出' \' z$ ]; v+ W2 M7 {- M
print(tu[1]). z1 r9 {& |- o( e1 y5 ]
e. 请使用 for、len、range 输出元组的索引
+ b+ u; H; r( }* v5 W( m! tfor i in range(len(tu)) :, p/ {# P% P& c0 @- @/ ]
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
" ]- \6 W% M& v# T, K' A" c8 \* V  Hfor k,v in enumerate(tu,10) :
, B7 e. r2 L/ j! c7 N print(k,v)
3 Q  z! w* Z  o9 \. k10 alex
. i4 y8 [4 J4 r" E11 eric
8 {' b. U5 Y; o& Q3 g12 rain
: |% c# p. a4 i0 @8 ~: `& Q3 `9 C7 J/ T& @6 ^5 v
for k in enumerate(tu,10) :% H0 ]4 W. G1 E+ m( M
print(k)5 Y3 R  s* w4 l* j& M0 j
(10, 'alex')( S) k4 S4 p8 @. {4 H& l& y
(11, 'eric')* F+ |' y) b6 H7 T
(12, 'rain')
5 q+ l& L* I" a' w; v
' k* L6 d* j- M! {7 E! F' i# [6 K( r
25、有如下变量，请实现要求的功能
) A" a7 N- O! u9 \5 Rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
5 c& |2 Y5 q6 D
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
7 ], ^/ e/ }2 M, ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])- ]. y: x+ L& D7 u4 @# |
res=tu[1][2]['k2'].append('seven')
) r* I( h1 e/ u0 R& D+ V; G9 Z8 B  q: D/ F2 |9 o$ C5 D
print(tu)
3 M6 c% c/ l$ k) W3 t26、字典. x2 J* Y  ?1 L$ i# d- o
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:  I* t  {5 i7 o
print(i)b. 请循环输出所有的 value
1 L" c- g3 q  t+ s; ^% lfor i in dic:, H& w; ^# _* N( t6 Q; _
print(dic)
4 X  \) t  Z9 _3 t8 l: Z; e7 ?c. 请循环输出所有的 key 和 valuefor i in dic:( ]+ _% s/ t0 E; G$ W
print(i,dic)
5 E' @3 z6 Y5 p4 s0 k. Xd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典- W. S' j! G% j& O1 q, i- f0 J
dic['k4']='v4'
  g% c0 t- r* P2 b: j3 Gprint(dic)
& p' G; P1 t0 D/ K4 N+ @! k; |- y' G, ]e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典$ S+ A, `) V. f0 w7 y% [
dic['k1']='alex'! U3 L+ D4 {* W0 G5 j
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
& w% J& ?" A1 O9 C  ^# S9 Ldic['k3'].append(44)
+ b) Q/ Q+ Z8 q5 y9 P7 U! E( ?print(dic)
- C$ @# r: P: G4 o! a2 F, ^
: u" B$ r& `, Kg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
4 H( T; Z( O2 Idic['k3'].insert(0,44)
+ m3 w9 O6 g: B0 h) cprint(dic)% A% C" Y6 B6 \; ~
27、转换
1 [" ]/ S: h1 Y/ P& |a. 将字符串 s = "alex" 转换成列表  s = "alex"
- x' k7 C+ m+ E4 m" F8 G. K# _; p% b* p, `
print(list(s))b. 将字符串 s = "alex" 转换成元祖
2 Y5 @1 O# |5 E2 ^% M/ Q1 c' {s = "alex"
; a8 Y+ p1 D& |0 aprint(tuple(s))
' r# _% c  O7 H7 f4 s! a& O3 \. p2 I% x) I9 g0 s
b. 将列表 li = ["alex", "seven"] 转换成元组! ^) E5 [0 V) m
li = ["alex", "seven"]
) Q) V8 r3 U2 M4 J# c0 ^3 lprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
5 e9 @+ d4 q  [; D5 Utu = ('Alex', "seven")
1 {3 N! v: m2 _" ~' y- N( gli=list(tu)# S0 [( a+ Y# `
print(li)1 H* Z- }3 X  N% H3 N; i; z
4 y# S9 x0 L, a
; ?. _9 W6 R5 [6 l. W( g
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增5 h9 B8 U) m% U( E: q

8 ?( Z+ @# K5 w' e: e* Odic={}
/ a) ^# _" c1 m/ ?for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
2 Z$ K& Y0 U& X4 m! G5 T; c2 o dic[k]=v
, y# ~' x8 ?- `! x( a# e* S print(dic)27、转码n = "老男孩"3 F7 ?- S" X, L7 [% M- E
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"$ P6 w6 p1 u6 m% z* b; @  V
a=n.encode('utf-8') / q- s5 O4 P3 K# n
print(a)$ ?2 ?# Q) g  s) A! U
b=a.decode('utf-8')! O+ Y/ r) p7 v$ o
print(b)$ o+ l  e3 D( _7 `
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
! ?- b+ ?- {+ b% c% Zprint(a)
7 n" k# `& r% n/ T7 q( fb=a.decode('gbk')
% d7 y4 \) A8 U7 h# Hprint(b)28、求 1-100 内的所有数的和& t; t0 K( e/ ?1 |3 I( b* n
count=1
' G$ O0 o, R8 h# Ssum=0
/ [2 ?( V: U6 V" b) F3 hfor i in range(100) :' L# J- h, z& Q" A4 Q
sum=sum+count* Z& \: j% w/ X/ a' ?% {" I
count+=1% p1 Y0 p7 ?( O
print(sum)% N1 v* E* e- b' }4 [  e% D  P1 j
  ]5 f* I$ i! s8 G2 W
count=1
4 X5 F2 z; C" W) E9 @, n& i8 Tsum=0
+ u8 ~6 H& I+ z3 lwhile count<=100 :
- \! o" g7 m( N8 l% Q& t+ }* `0 Y sum+=count
7 y3 N# q0 F7 G9 a$ @; L count+=19 s4 M- d2 u3 ]4 _' `9 j- u7 l. c1 _
print(sum)29、元素分类9 K( J: _( U0 A7 V& M% v9 n
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
: ]( u3 q7 R' K2 f( |将小于 66 的值保存至第二个 key 的值中。
; F5 @" ?6 c1 L0 J即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
- q, o0 ]& U; J; V' gli=[11,22,33,44,55,66,77,88,99,90]
' `. |6 o9 J1 R" Y: V% edic1={1 A0 I& ?# r4 ?! z3 ?6 j( B& m
'max':[],
/ H+ o3 e! P3 f. f8 K2 T: S% o1 k6 M 'min':[]: f. B! D, S. h" u1 v0 M. L0 N
}% j  f4 L/ R/ Z  i$ o( C2 a" s
for i in li :$ f0 v. ]! g4 a' H/ @
if i <66 :7 b8 U, ]7 f0 I8 M2 J: g0 v
      dic1['min'].append(i)5 V: z, }3 D6 z9 A2 ?  [+ E$ _
else:
' ^8 _2 z, U, t2 v       dic1['max'].append(i), A+ h# t  Q$ I: w, T5 s
print(dic1)6 s7 f' e; D: F* ]+ L; C5 G4 H
, L8 P) J" q  J- n- h
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
( _! A; ]  W* r5 W( n; t$ i

Python基础知识汇总

主题推荐