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、写代码7 U& N2 P( w* B; Z3 Z  k$ W# x, _' H
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) :% V1 R* P3 K# K9 a5 @9 P, x( ^
name = input('name:').strip(), p6 R& z/ |# x2 D6 d, o
pwd = input('pwd：').strip()/ x4 @1 R- x9 ]% ]) L
: t3 ?$ p7 z. k  v( I+ K/ A
if name=='seven' and pwd=='123' :' X  o3 f1 D% f, H- m% Z, j8 Q% T
      print('ok')
% u6 G5 C; D1 N" f# U+ ^ else:7 t3 H: i; N5 f5 u0 A6 D8 V
      print('error')& L4 z3 q- e: `2 t
      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)  :
% r+ s0 H. `* B& _# c8 _6 m name = input('name: ')$ s9 n- f' z. A* ~1 L5 b
pwd = input('pwd: ')
4 K' w! _7 P( T) }9 y% K7 Q) x if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
8 ~' P7 x! r8 G6 c# [       print('ok')! m* _+ R2 m8 B* m8 Z5 v2 M0 Q
else :
2 u3 w" i6 j- k$ H5 X       print('error')
* C. e2 L1 a% j' \1 N* f       count+=111、写代码
) m' g1 p: t3 S3 @- t2 d) I: ^! aa. 使用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) :
; e  x) d& k1 U if i %2 != 0 :
3 U0 j0 s. p' |4 [8 g       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :/ {% }( C9 _. o1 v- }8 i) C
if i %2 == 0:9 c5 C. ~5 F& c: G% c* S- n
      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 t3 s( \( o; s' Ga. 移除 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)
( |2 ^6 q+ |+ W/ c/ ifor i in name:
/ z$ U4 b2 w0 |1 s, @ print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
2 D+ n) B8 F# M" F$ g/ d22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']/ k$ f: x+ ?2 \. x( h* x2 Z
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    % F* L* [4 h2 P& k5 t- x
print(li)
4 v5 p* h- |* b' S ['alex', 'eric', 'rain', 'seven']  Y8 u# y0 [0 W6 n
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
6 x, ~- s7 F9 }) aprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
: f$ n0 F: ^0 v8 J8 Iprint(li)2 b4 O# x( h  R+ F. n* u
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
' J0 a; v; G3 I5 }, G& k# U! ?li.pop(1)
0 y4 T6 m9 h  l( X5 Lprint(li) ['alex', 'rain']7 V- z& A. @; }9 T
指名道姓的删除li = ['alex', 'eric', 'rain']  b8 P$ u& I) ]
li.remove('alex')
  [5 X# D' ~- h( w7 K; V3 ]print(li)8 h. n0 K# J: h6 l
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
" N% o8 D$ @' X5 R( J& n% l3 Y( O( nprint(li.pop(1))% s3 d" J7 N1 ]8 t  o. ~
print(li)7 Z/ V0 V% ~) B. w6 v  K' w; h
$ E' n/ q! s3 {, u3 [* ]* _
eric
7 N+ e9 \- d& R& l['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']; r; m) G& l; f4 I' p- K
del li[1:]
' U+ U4 @7 T3 M( U2 dprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)* \$ L# O: a9 {+ X7 {% G
li = ['alex', 'eric', 'rain']3 z) s: G# F, U/ k0 q/ y8 o2 K# o
for k,v in enumerate(li,1):: s0 e$ u% ~2 i% _* D6 H4 k# y
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]1 G" ~- N! v. s' b
a. 请输出 “Kelly”
8 F# g4 L, P5 ^6 `0 e9 pli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]$ w: i% z" y. `/ ]" Z8 F# D- B: L
print(li[2][1][1])
, m9 N, K8 O4 Y2 p' p$ k; Eb. 请使用索引找到 'all' 元素并将其修改为 “ALL”- P# R$ A' u6 O! ]2 _" M2 h0 R  Z
li[2][2]='ALL'
7 v, g% R) y8 H) I& C6 u- H% Qprint(li)
$ r8 D0 Z! n* W  }& N" {9 l& N24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
  P) V2 G4 K: A+ e$ Pa. 计算元组长度并输出tu = ('alex', 'eric', 'rain'): V0 D' L; Q0 i" `9 `% I
print(len(tu))
5 e. m; e$ ]0 M! M$ ab. 获取元组的第 2 个元素，并输出
$ v# }9 l/ a7 }: z1 k2 h- zprint(tu[1])
/ M5 ?( B; V0 J/ @+ j1 X* Re. 请使用 for、len、range 输出元组的索引
6 w6 s" i- t+ R$ Lfor i in range(len(tu)) :4 C) r# e, f) M+ f2 o( k1 h: V# R
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
% T# b, z( M- I- V+ Z, G  Tfor k,v in enumerate(tu,10) :
, E" F! V8 h) \" ` print(k,v)
& u% U5 d1 ?# ?" C$ ^  T10 alex
1 m) x" t( e! e& N$ P, C, L% x3 Y11 eric8 s$ e4 ^, M/ c" Z/ w
12 rain. x$ \  i1 @; U" O( T$ {( k. s; u

, F* ?( t& }4 L0 p8 y- v( s% Q5 zfor k in enumerate(tu,10) :$ L! Y1 ?% b* T: ]
print(k). F) H0 }" I/ C/ t
(10, 'alex')( d. c; [" \/ c9 X
(11, 'eric')1 W6 g7 `  D* ?
(12, 'rain')
! R+ b: @9 s5 l
8 r% r8 h- h; J, E2 v1 S; V/ q* r5 o4 `' M( e8 D
25、有如下变量，请实现要求的功能2 ^! B, L* C" Y7 r$ X, F
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

/ L  E2 V1 A/ Y1 R4 j1 H. T/ sd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
- ~' s7 M0 e- `tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]), N; R6 j* o* @' O
res=tu[1][2]['k2'].append('seven')
2 p1 R" n+ H3 o( A: W. J+ u" A' N2 |# t# `- P, C  R% X' y
print(tu)% o" r5 Z& M; ?4 ~8 G2 _4 C
26、字典
8 t5 ^, V3 y' Q6 t- rdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
; J# Y8 ?9 @$ q7 u& C& A) S) Z print(i)b. 请循环输出所有的 value
( M* H( H. t, X8 @1 yfor i in dic:
2 B6 u0 O7 L. p# m# C. D% h print(dic)& X7 J- Q* D# a$ i7 J& s
c. 请循环输出所有的 key 和 valuefor i in dic:6 x* D" \1 \. U" t
print(i,dic)
; z8 j4 G/ |% t& fd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
3 x8 _1 ~  Y1 c* n9 odic['k4']='v4'. J) X4 D2 w% \: c& e) [
print(dic)
! ?6 C9 `! k' S/ P2 H: Xe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典' i" t& Z6 W* v2 W
dic['k1']='alex'. ?. F' J0 D& Y, r- |1 @
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
: G, R8 Z" T2 e7 @! f3 e- }dic['k3'].append(44), H. e+ t" _: f1 H$ w; H
print(dic)
) ~% P. L) g( j6 b0 }8 S5 S5 r% L
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典& E5 r7 f% R  ?$ G( D
dic['k3'].insert(0,44)% s9 U( u. j) U% A2 W: I
print(dic)
0 f. m4 n  u5 m27、转换- k$ v& O/ Z  P; M' _
a. 将字符串 s = "alex" 转换成列表  s = "alex"! ]! v5 {4 }9 ?$ \

4 I! C7 v/ _' w2 T/ O, X8 b8 C0 A$ Xprint(list(s))b. 将字符串 s = "alex" 转换成元祖
  U6 O+ O) U# S9 y8 y+ Ns = "alex"
# d& L1 \! x& k  t' r/ Eprint(tuple(s))
/ J. ^% g/ n6 O9 X6 s, Z: {# }1 p7 Q
1 p) R4 y5 K' a0 R0 \, o! I# Sb. 将列表 li = ["alex", "seven"] 转换成元组3 V$ d" A& ]+ C' u! @
li = ["alex", "seven"]! M  ]5 C; ]' @$ _. _: B
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表* x7 P$ W7 M' d4 J. C3 A8 J8 ~* N
tu = ('Alex', "seven"): L* q6 L& N; E' _1 l4 T
li=list(tu)
) r/ z$ g' }* n4 b6 r$ I" P9 nprint(li). U9 \, v6 u" D2 Q( o( o+ l: F
# x  x' m, `8 D: T  g/ E
) R: F! V0 Y2 N: O4 {' t$ P1 G
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增( m7 a: L+ d" m2 v
- a! b! N5 |; `( w
dic={}
1 e7 _% I4 Y9 g' s4 n7 P6 d* Gfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
0 [" {3 S+ ~, [  w1 k9 ~5 E dic[k]=v
  ~) Y1 S# u& Q, L print(dic)27、转码n = "老男孩"9 O' R3 I5 l, x, |8 K
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"' u2 n% ?$ {* o( p
a=n.encode('utf-8')
  d0 c0 b& a3 ?5 G0 Hprint(a)
- p; g* p( r& j4 v% {0 u( Ab=a.decode('utf-8')/ }' B6 n4 }! ^, g
print(b)0 W* v- Q! I- Y# I, O1 ?7 R6 v- R
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')8 k* N7 Q( N  i6 ^% c0 m
print(a)$ t; A4 M" V0 d: W& C5 q
b=a.decode('gbk')5 G- p: \' k# _* [9 o3 Q
print(b)28、求 1-100 内的所有数的和
+ W) z2 ?5 z3 g, c2 {count=12 {1 F* V- y0 c# K3 O& L8 k) M3 c
sum=0
5 v) ]/ ]& q* J9 q5 H# _! O& }for i in range(100) :
1 h/ r7 N5 y) N; Q0 k sum=sum+count
( f8 O9 D8 o3 P: \; g. y3 ^# w count+=1! {, q( O$ m: u  B" M- Z# a
print(sum)9 ]1 e' k# r) z( q7 o* z9 C' J2 y* Z

3 Z$ w  c5 E: Z7 a6 p5 qcount=1
7 A% H; s( f; t$ {$ k6 {4 z: Ssum=0! R+ Y4 }/ k6 S. m) f
while count<=100 :
0 c+ ]; H, v1 D& @ sum+=count
# o& a- f% F$ D2 B1 ?  t count+=1; M# {( h$ j7 I# u3 I) Q
print(sum)29、元素分类
. c1 [8 o6 C% i  _1 s; a; H* J有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
5 i+ M8 X# s5 T& v/ ^6 X* ]将小于 66 的值保存至第二个 key 的值中。
1 Y( \% X$ E6 U: M. y) ~8 e; F即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}) Z1 @/ Q9 X, P- l- I
li=[11,22,33,44,55,66,77,88,99,90]  m/ B( g% ]/ J  p0 f2 O$ R$ c# h  r7 R
dic1={4 o' ?% r! _: X
'max':[],: C# r9 k6 O4 J5 ~
'min':[]5 _& m9 u* a7 O& E/ n
}& E% I" p3 u1 ?
for i in li :# F* L9 N/ H3 t; e
if i <66 :$ K; T( R" e- N$ @( @# |7 q4 j
      dic1['min'].append(i)- j! E# h6 d( u9 T% ~
else:7 k/ M* g. {7 ?+ Y( H6 O9 Z
      dic1['max'].append(i)" x4 ^0 V7 m8 e% K4 H& \
print(dic1)
8 y2 F! @5 J/ U; _2 S5 S, ~$ ]$ s, M0 L8 E* U& C$ F; }
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
2 ]6 d1 r7 h$ p0 x: I

Python基础知识汇总

主题推荐