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、写代码
& K9 V/ n" ~" n& e$ Z: 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' l0 e, r; ~ name = input('name:').strip()
6 S2 V9 S7 f; G3 x( i pwd = input('pwd：').strip()
; x" N) k4 T) I' R
8 U* h% \/ x$ Q if name=='seven' and pwd=='123' :
) a  T# |5 C+ L. F* f2 @- J4 `       print('ok')
$ L$ U* j8 B. a1 ^2 `9 _& K1 I% _6 g* o else:
  y8 U/ v& i" X% j5 R9 R       print('error')0 ^& b/ y8 @4 f$ P5 S: E
      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- v8 P1 {" s# `( G name = input('name: '), p, o. [) n7 C& B% b
pwd = input('pwd: ')$ \4 S; k% R3 t
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':; j* x  |8 }: L7 s. Y  m
      print('ok')
3 S3 {! d& E1 s else :
* J2 i& v1 P* V  V       print('error')  ?7 ?2 `' Z" P! S  Q  q. f
      count+=111、写代码4 t; L+ C0 W+ w" V2 v& i; E2 m: S6 f
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) :
; M) R2 e+ B) j; {, V if i %2 != 0 :
) V" V0 h5 K% M- v9 f) c. |       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 P+ r: B* S6 e" Q$ C
if i %2 == 0:* {% @8 w. U/ Y  ~& S# @0 z. O
      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 E, P0 c& x2 G+ V' t3 a& 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)3 n3 T/ N$ L, X9 q
for i in name:
7 s' v- J0 K: D2 {: k" i- G print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain0 @9 y% S1 |& C) u# ^  s4 F
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
$ U% _- Y+ w2 ]1 i- ?1 Sprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
  V7 Q" I7 b+ S! U0 mprint(li)
! R$ `# x( }  U9 H8 E+ |# R ['alex', 'eric', 'rain', 'seven']
, u  a2 `: r5 ?  P/ M2 p1 u; sc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
$ a& X! T  l- gprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
! h/ w  o; x) z! t. v/ hprint(li)  V4 H8 s/ N7 B4 b9 k# o  z
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
9 i# A% P( ^- P, Ili.pop(1)7 q# L7 Q) t6 w4 W3 F; q
print(li) ['alex', 'rain']
) W. T$ U  m5 o指名道姓的删除li = ['alex', 'eric', 'rain']9 ?% y" o# k- z, M% T! ~
li.remove('alex')
1 {; V/ Y/ X* Xprint(li)  A0 H3 X6 S, K
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
5 @" D) O( ]# R7 O) ]  M8 Pprint(li.pop(1))
9 ]- B2 H/ F$ k, wprint(li)6 k6 }$ k) M( w" h1 V7 G
2 H2 U; Y6 Y# F$ U$ j
eric
7 n3 O2 J1 w9 I  h['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']5 p6 g! c! h1 U  B
del li[1:]0 P1 Y" G: }# d9 o7 k9 U" e2 e
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)2 U7 M4 Z9 G7 o& e/ I% y
li = ['alex', 'eric', 'rain']
% E: [! ~/ [" ^$ ^8 kfor k,v in enumerate(li,1):5 S+ W  C: [& }% X- E# X
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
, C; S, g9 ]8 O% la. 请输出 “Kelly”# G5 j) D" P4 J1 j- q9 a6 h
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]% D1 G) x% l, l) q* l3 v
print(li[2][1][1])
/ r( A5 g# T1 _! N% \$ Y' Jb. 请使用索引找到 'all' 元素并将其修改为 “ALL”) l0 Y  n, [- F# \- K' M
li[2][2]='ALL'
( T7 w* Z& v7 Bprint(li)# z' K% z: Y0 a
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
( h9 B, m+ Q6 D) V! Ia. 计算元组长度并输出tu = ('alex', 'eric', 'rain')( Y! [, ~/ |$ x* b% u
print(len(tu))
/ s( L% P: I( g9 R6 z' K3 S6 \4 s! _2 Zb. 获取元组的第 2 个元素，并输出
& B/ ~* p% Z$ l) j% ]print(tu[1])
0 J- [8 q* f5 E5 x+ R# ce. 请使用 for、len、range 输出元组的索引2 v) @& W; t- V0 c& \0 N+ U0 e
for i in range(len(tu)) :
# {% l8 q# G9 G/ h6 L print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
4 B6 I$ {- f$ T7 v: G: h0 t6 |' Mfor k,v in enumerate(tu,10) :
- p1 z' |& D) S4 V4 V% j- p3 z; E print(k,v)2 B: e* k% ?/ G# S
10 alex, u3 M7 [& F% W9 |5 P; j
11 eric
; ^  ]' I. V1 S12 rain1 _/ ]; s9 H% {

* J% Y3 @4 k( p* A+ @for k in enumerate(tu,10) :2 `" d) o9 @9 P* i" N9 {5 |% G
print(k)
# R8 a$ E1 _3 P/ F6 g(10, 'alex')0 M! S! H- L* J) K
(11, 'eric')
( s5 R! {5 i0 C; ~(12, 'rain')5 p5 j* W1 S4 O6 M

5 E7 i: r- Q) D/ U) m) Z. U% c: Q, O# L
25、有如下变量，请实现要求的功能5 ~+ S+ Y) V" p- U
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

& s/ i) L0 C+ r- J$ h' y; C  Md. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以8 Q8 ^) ?; g- ], L, i) X- A- y
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
- K% i( g* t0 d1 @res=tu[1][2]['k2'].append('seven')9 i+ W& v% ?+ l8 u/ q; n
7 S$ u2 C5 ~' p! |
print(tu)4 V" H) k1 Z, p4 D8 z
26、字典7 i% k+ y- U  W9 s4 B8 J
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:* m( |$ W* [+ r8 l
print(i)b. 请循环输出所有的 value
) T* z7 z; ^. j- J' [1 afor i in dic:
1 W) T* c  U( G1 ~" Q9 W print(dic)7 s6 _1 o  S& M* _! M
c. 请循环输出所有的 key 和 valuefor i in dic:+ A$ }' ^1 Q! O! V& A& M3 h' T
print(i,dic)
& w* F' O6 W6 `' b8 n/ qd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典* P4 E7 T, A1 w: d* Y4 \9 I
dic['k4']='v4'
# {  C) c7 g3 W! R/ U0 D0 k; Eprint(dic)
) }. q. E. F% N2 ye. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
3 A7 Y+ i3 G- d( D1 q% cdic['k1']='alex') r1 t7 ^% H3 c& M
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典1 G: I& O, g% `; ?# L) V9 u" b0 W
dic['k3'].append(44)8 A+ E+ J2 V4 J3 u, o
print(dic), F3 J1 c( o% N9 h* z! u
4 E9 C. C) r; S" v1 _
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
4 f1 K2 _' Q5 a7 d! J7 V! t" g  u; Ldic['k3'].insert(0,44)
, s( z% Z$ I& p, w3 lprint(dic)
/ p: i3 B0 w* B. P8 s/ K7 I5 V27、转换, h) y% B) \/ X8 p% p% `3 a+ N' D
a. 将字符串 s = "alex" 转换成列表  s = "alex"
4 ^: U& c5 J$ ]! i) E# [2 G
" n1 x5 Z8 e9 j1 f( b, z3 pprint(list(s))b. 将字符串 s = "alex" 转换成元祖, h% |- Y$ P" U- k3 Y2 f3 D
s = "alex"2 B- Y7 O# s! H# B, y
print(tuple(s))
, \  V: t3 F" m! M: c4 T5 ]1 {6 Q2 W# A9 B% T
b. 将列表 li = ["alex", "seven"] 转换成元组
( O0 w2 q7 }$ F8 x! X7 jli = ["alex", "seven"]: g1 u8 `* T, S  O: m, H
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表6 l( i, Z% d( i8 n+ ~& ~) Z1 c( W
tu = ('Alex', "seven")
- ?, e8 [/ U2 @. i9 H- }li=list(tu)/ f# N4 c; ?, r
print(li)" a( e. h( r2 h% l

( l4 P( z: |4 @- _
' j# m& h/ }1 @1 g: X1 W  dd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增4 c4 S- D  _: M2 e7 y
3 J+ w: c2 M3 D
dic={}
& E& Y' g1 J) y3 d% X: Y7 Rfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
# a: n$ }) S+ M; ?5 O( V, c dic[k]=v/ ^. ^, M2 @5 R3 P6 q
print(dic)27、转码n = "老男孩"
1 H0 ~- n6 t$ F# x4 R& _4 e1 j) na. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"" d+ g) F- O. ^8 R, Y( v* \- g) S. l
a=n.encode('utf-8')
6 H# X9 q, C2 `2 y7 g  mprint(a)% \1 |! U8 e* d5 n  Z& R, I
b=a.decode('utf-8')
3 E3 i; q& A* z9 }& V; sprint(b)
, |( B! Q8 H! v5 M  R5 U; p/ \; ?- Qb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')9 `' P2 D5 d) A2 E* l
print(a)
+ B/ w+ x+ V3 u, g, D* @b=a.decode('gbk')
3 I# }. u* B/ x# W4 L5 Hprint(b)28、求 1-100 内的所有数的和
4 g- r- q2 u& Z1 [count=1- }* ^- K/ `9 [
sum=0
4 h2 S0 l' [$ }: P7 x: `$ Tfor i in range(100) :. Q) v/ r" i: @; [
sum=sum+count
+ k) a! w1 }& W) A count+=1$ ?; O, w6 o0 `4 w; i, {& z5 v3 ~
print(sum)
  e: k- I4 u2 I
0 |7 J! L. b# u+ T$ \count=1
& h- n4 e# a; o3 `sum=0* k& {% V, h! d/ G. a) S/ C
while count<=100 :
4 R6 \( @+ y+ I2 ]$ Q) R. d sum+=count7 u5 U6 R6 e8 h8 N" w
count+=1
8 C# G9 V/ O/ Q" O* z& ?: V- a: dprint(sum)29、元素分类( P' W4 J  _. }! y  Q
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，  i( d6 L5 U( T% ?. s2 s. Y
将小于 66 的值保存至第二个 key 的值中。, @6 ]  {' A3 D9 k# x
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
  j* {5 V7 r  D9 Q% {% Dli=[11,22,33,44,55,66,77,88,99,90]
  ^0 |" P- _: y! D" r0 Zdic1={
* X/ a: M% p/ u0 d% H) H 'max':[]," I. ^9 V1 g2 n) J
'min':[]" @" A% k3 L! ~% v: V
}, E  ^5 K( q3 B4 J- j% n3 L
for i in li :5 A: x' H4 H7 R2 [% a1 \( O
if i <66 :7 s1 `: D& j* A& B* t8 ?
      dic1['min'].append(i)
1 E) @  ^. @" K0 t1 H# _ else:) @3 U$ V' a* a0 E4 U8 M
      dic1['max'].append(i): [, S+ a+ p1 u
print(dic1)
) F" T. o' W, [' L3 z) x) ]3 {6 [* Y& r3 D; @4 }
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
9 ~& z. t( n' C( F- [, r( Y+ M7 t. x& P

Python基础知识汇总

主题推荐