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、写代码+ y" Q9 ^0 U7 o3 n# c) ~
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) :
7 F% x6 ~, p# E- e# p" i9 u name = input('name:').strip()  U5 s6 A- ^, U
pwd = input('pwd：').strip()
, Y/ @# _$ r" }" ?/ b6 R
4 P" Q0 x) y# J6 g if name=='seven' and pwd=='123' :0 I$ [1 u' I9 e4 R% u& l" o3 q" s4 U, s+ n
      print('ok')
4 d! U2 X$ Y# O$ U else:
: O. f# E1 X5 N+ k- t' p1 `       print('error')
: M" G' i( K9 F* R! g) {       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)  :/ U* v! o8 N' @1 x4 {
name = input('name: ')8 O- g2 W; a0 R" I, j0 s) E  [
pwd = input('pwd: ')
- t5 \* U! y' T if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
9 a" D6 `6 U7 m# x* u/ R       print('ok')
3 s2 g) C+ P- [ else :
3 ?/ Z) E: n6 X/ r       print('error')3 j3 d1 T/ }& N; C5 ~9 H' m
      count+=111、写代码
7 C, d3 m9 G6 |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) :
" Q  f/ [- A% u) s4 ]  |8 U# L if i %2 != 0 :
7 u3 `" T- ~( O( }7 t" \( F       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :9 A, J7 f) c$ S$ M. z, Q4 J8 D. B
if i %2 == 0:
& B% J1 t# L- F: b$ E       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"7 T% I% `# ^- S% F6 G
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)
* d& g0 a  ^' I$ xfor i in name:
7 E3 H- `( s8 p' X. |: B print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain" k+ D+ s) V& N$ L+ f# P0 \) s  Y
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']3 j. I# m$ A+ f! j# L
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
: B( p$ L/ W. W9 Dprint(li)
; c; U# L9 z$ `* t% r; I0 J) k" E9 c ['alex', 'eric', 'rain', 'seven']$ l1 O% _: h* T& S% L6 P
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
/ `' t5 {0 @" iprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'); m3 n! K' l2 ?& Z
print(li)3 Z1 P% z" E  F6 c
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
  X/ P3 i3 m* S0 u# |8 ~, [li.pop(1)
/ Y; O9 v" ^; C: Y) ?print(li) ['alex', 'rain']; Y3 a+ i$ [* |3 s7 z4 }
指名道姓的删除li = ['alex', 'eric', 'rain']
# P0 ]* i  Q2 L+ k1 @2 ~* Uli.remove('alex')4 d0 e) A* z# ^9 l8 e
print(li)
( M4 k; [( i& u* m. n  ]% Cf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
( [+ c, \6 c5 m" vprint(li.pop(1))
, e2 m- R& E* ^5 ]  K" sprint(li)9 B0 l4 w- `0 N1 V  e( |
2 T8 @# i  J, Z; @4 \) O# K! o, w9 c
eric7 q* ~; h* l/ \2 y, W! M
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
9 n2 P+ t: H" R( l& C9 z8 [6 Y* F9 Bdel li[1:]
: P3 H7 ?) X& A) j0 B0 N7 k* oprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)3 D1 P0 O% y# ]# j! N7 D/ c
li = ['alex', 'eric', 'rain']
- ^2 [/ J! ?  R. Q0 R9 Lfor k,v in enumerate(li,1):! ~8 b" i1 M/ J% h" J
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]1 o5 K& {2 ~  r* j" k  c" z$ H
a. 请输出 “Kelly”4 I' ?3 f3 B. e5 T: L& u- `' R
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]  e, s& z, w+ q$ f) m
print(li[2][1][1])
+ T+ H( s" _& G$ P1 B. kb. 请使用索引找到 'all' 元素并将其修改为 “ALL”9 N- D* N0 {5 V, @9 {( g
li[2][2]='ALL'+ T1 c' j( ?6 |& Z5 X$ x0 J
print(li)
! i$ k( }5 T- C( E* K- _24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')' H- F" B' E: a
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
: ]( O3 R7 p1 |2 T& ^' cprint(len(tu))
$ A! z5 d7 c$ G$ fb. 获取元组的第 2 个元素，并输出
5 y7 y  I& \, h/ A1 X; f2 uprint(tu[1])
3 n5 ?5 B: r/ F9 l, V# ze. 请使用 for、len、range 输出元组的索引% l. x( M4 B" ^" D. I: g
for i in range(len(tu)) :
/ L/ p9 h& m1 D print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)6 A, P9 }3 I% P0 L! B( |
for k,v in enumerate(tu,10) :# H1 ~# G$ M& }" B$ y' U
print(k,v)
( e1 s/ S4 ?, i4 |1 X, l) o  G10 alex; F' }$ w" {# B$ ]/ d0 p
11 eric
% o8 j/ T1 m) q+ [7 b. [12 rain2 c* x8 M8 X3 X6 T' g! a: a

: m! D; b& Y) N$ L1 p4 [8 |7 V: u' ~for k in enumerate(tu,10) :5 P; L; t% [2 M2 E# G
print(k)9 h; c& O  i5 `+ j, x
(10, 'alex')
2 }7 m# c6 U! l! ~5 e(11, 'eric')
5 E, h- s1 ~; F, V% j' C- z(12, 'rain')1 h& \2 Y. t0 }( t0 ?$ `

3 h! g9 n) x+ w
. O+ b. ^4 D9 c25、有如下变量，请实现要求的功能
. |8 O9 u2 ^! }2 Qtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

. J8 C" u' D$ t1 \d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以5 b0 P9 H9 C0 N
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
" X" N3 ?' R% D6 e2 x+ Kres=tu[1][2]['k2'].append('seven')! n0 ?% y1 M9 A7 f# l
8 J1 g, r( _+ }- Y% x1 \0 g% ~
print(tu)
" T6 |" N, R! v7 F: {26、字典
: f* }* Q0 ]/ w, ?7 L8 Xdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:0 t6 ^0 T3 v! b" A
print(i)b. 请循环输出所有的 value
0 ~& A1 O; G; V3 y5 i6 `for i in dic:
& g  g5 y5 w  g" s* M/ K print(dic)
7 P( H$ m5 W. O) M( v: Rc. 请循环输出所有的 key 和 valuefor i in dic:, w$ q) N+ B4 W% q5 q* ^+ L3 n
print(i,dic)* r; i8 _4 `. u5 h/ v
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
/ S* e3 \* y: adic['k4']='v4'2 l0 Z7 W1 A8 }0 i, s0 Z6 N3 i
print(dic)
6 |+ U9 Y' w# x8 X$ [# ae. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
5 T, d# H! J6 T0 g2 W) Z) Bdic['k1']='alex'4 l# u6 u: e4 {
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典  r: ?2 X3 ^  {
dic['k3'].append(44)0 {* C+ X/ R. j% K: S0 B  e
print(dic)" ?! R) y8 B9 I5 Z

/ j) `# e$ F8 E8 S6 R) Vg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
* a0 Y7 H) `0 Z" O' `7 j; b  k/ L3 Ddic['k3'].insert(0,44)& V" H, r! I% p# N
print(dic)) i5 \. @2 h3 n; }. _& i. a9 B9 I
27、转换. x, e& G/ x) s' q5 x$ Q. r
a. 将字符串 s = "alex" 转换成列表  s = "alex"9 j3 }( q5 ^/ Q3 s5 b

# p) Q- Z3 U% Y  F) p: V+ Vprint(list(s))b. 将字符串 s = "alex" 转换成元祖
: ?' b/ |! `7 N4 J; ~4 j: Hs = "alex"7 V* x9 b; h2 m+ y% c( x
print(tuple(s))
; ?6 Q9 K, a6 }. R
7 }% \5 y$ n4 t( d. u- W. Hb. 将列表 li = ["alex", "seven"] 转换成元组4 A& d* U9 t0 R9 k& M% d
li = ["alex", "seven"]
) a, ]/ G7 z/ tprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
- d# q- q+ A" s7 k: z8 stu = ('Alex', "seven")$ |5 G  r+ T* U- n# h
li=list(tu)" \8 C% Z. \0 r6 E7 t0 Z2 q
print(li)
9 v$ W( E6 v  H3 T2 {# C: f% C* W- q
. M5 ]7 {$ l# I3 ~9 e) A
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
0 _# j) {/ l: E& c, [2 ?' o0 }$ L- S! S  Z
dic={}
) B/ c# |/ K, e7 R4 cfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
) ^4 G0 p% S/ M/ P( x1 e dic[k]=v, _) i  W& w1 w# |4 C# j
print(dic)27、转码n = "老男孩"
$ X5 Y! G+ v# G" Ia. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
: L. j) I& [6 t0 s$ C. |( g" @+ }* }a=n.encode('utf-8') " f8 ^) r* X$ ]% w! ^1 _
print(a)  q/ R( d: S% N. d6 T
b=a.decode('utf-8')
1 G0 ]1 K( d6 _2 p2 A1 c' `" Yprint(b)6 m7 A5 R2 p0 j% P$ X# t8 l" U7 [
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
, N- v- h0 X1 A2 J) Tprint(a)
1 r  g5 X7 y. ~' F4 Rb=a.decode('gbk')0 g9 @  ?0 m# }# U7 q
print(b)28、求 1-100 内的所有数的和, {# C1 F& N4 k" N6 N
count=1& f- c: U: ^: _6 K4 ^
sum=0
1 g/ q7 H2 C' ufor i in range(100) :, b7 y! G1 n" d: F+ b
sum=sum+count  I; c( n3 s& ^* U
count+=1
3 Z- K6 m( R0 I% a# t3 [2 }* Vprint(sum)( D8 Q+ `1 ^0 |5 G& W& v
* A; C7 j; Q- A% ^
count=14 [8 a/ X0 j3 b1 ^
sum=04 x7 P0 Q. r* ?& [: s
while count<=100 :4 J7 B- \/ x9 W1 Q+ }
sum+=count
* V5 |  @! w( a. k1 K count+=1
- l; ^+ W+ A3 I& K; v7 }0 v+ c$ Xprint(sum)29、元素分类" H$ ?' ?2 y. @& M) t& K
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
. ^. R4 e, Q% d) A2 Y" S. w将小于 66 的值保存至第二个 key 的值中。
6 O, ]" w0 `: U4 e) p  u即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
' x- L  P) B! nli=[11,22,33,44,55,66,77,88,99,90]
* |# H# e8 a/ a0 T, c7 }+ N6 [, odic1={
! Q/ D. d4 [# b! m. y4 S 'max':[],# M3 u: A) }# `7 {6 \5 K" g. L" X
'min':[]8 v, X1 U6 L/ _' ^& e
}
% h: a4 ^7 q6 C$ `# z9 cfor i in li :# D+ c+ K5 K9 |( c; `' `
if i <66 :6 e: t' \8 g( G. W# a
      dic1['min'].append(i)! V' S! n$ W5 s( O4 ?
else:
* R/ i8 A; V% M; Z, h       dic1['max'].append(i)( \; ?- ~2 Y4 W
print(dic1)" R8 p/ m. U8 D. x3 y0 @

1 ]/ x( M1 q; }---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
4 ~3 g+ j# {1 [, L; _

Python基础知识汇总

主题推荐