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、写代码, |. _- X* L1 w2 U, j3 M
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) :/ ~' {9 y+ M2 Y6 E( j  ?, `
name = input('name:').strip()! W1 `6 A) e: }2 P/ e+ _
pwd = input('pwd：').strip()
* G, ?* V8 G  |. c: S$ G
( j& R$ y& a; E  v5 p6 a: L if name=='seven' and pwd=='123' :
" L, H4 M' B  B  Q       print('ok')
. ?5 ]( u9 d, c9 ] else:
" g7 v. R! U6 J7 S: H7 Z9 n- w       print('error')# b1 r8 s0 u" n4 H6 [) c
      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)  :. C" }2 H7 s4 ~; s
name = input('name: ')2 `4 m  E9 |' u( E$ L; M
pwd = input('pwd: ')4 L8 Z) x) Q7 b) v6 ~7 g" i
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
( y, N9 H6 U( y% Y' O/ n       print('ok')
- Z; U; L/ d6 D, i+ B" h# v6 H else :
5 x4 e) m6 b( r9 ]       print('error')# D0 u2 J) [: J
      count+=111、写代码& r9 K3 C) b- b% P8 Z0 d
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) :
% [: h% D7 W7 [' N if i %2 != 0 :# c; g1 d1 a7 h4 D1 v9 v
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
- z: I# g, f/ P' a6 P8 @  A if i %2 == 0:, M) d9 X! B/ O( W6 Q* {  g
      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"
2 z5 {/ u5 J8 u, H) w6 `' H% X* X2 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)9 P" n' G/ ]5 n2 Q
for i in name:( L$ g" ~5 P/ Y0 v: c7 O
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
# H: q) ^' k5 V8 C) W22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
9 y2 ?, p* m. L( f# v% f. p+ dprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    & m, `% u- w! r6 V2 H; P
print(li)1 f, C7 j' v5 c% v5 S
['alex', 'eric', 'rain', 'seven']$ F- i0 n" l; Q( i- G
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
0 Z3 I, [6 q1 F& i; c' h% M: yprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')9 F8 r& y1 V5 o/ V4 t( s
print(li)+ l& |6 S+ T+ N
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
6 t' v/ J( ?( S& W& m- Vli.pop(1)
7 P4 M( r$ @! Hprint(li) ['alex', 'rain']/ Q. s2 w+ t; n8 i2 E
指名道姓的删除li = ['alex', 'eric', 'rain']6 L3 O  c1 Z+ e+ _  X4 G
li.remove('alex')
& U1 h+ C6 R" t; Rprint(li)
2 D, @3 B7 G1 yf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']7 e/ L+ r; I* g: k" |) q6 e
print(li.pop(1))" f( k4 |, l+ u6 @- u4 f4 L- r! q& d, f
print(li)! _+ A( W, L5 G9 D4 y
/ c7 \# ?0 {1 P. L2 ^' {
eric$ I( C' _; ?# d/ o$ y
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
) V( R4 u& M% f' i3 Adel li[1:]3 q& @8 e+ X% s/ K1 A5 h0 u2 `
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
: W& w+ M3 w0 u" p! K, h! }. ili = ['alex', 'eric', 'rain']9 X+ x, W4 d/ E! r/ U
for k,v in enumerate(li,1):* h" b/ M) q0 H, F' ^0 y
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]& e9 K; W; ]# l) h. `; ]! r1 I! d4 M
a. 请输出 “Kelly”
) H3 K! e: {3 mli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) a  t# i- Q. M2 M9 w+ {print(li[2][1][1])' b* ]/ J+ H' L# D" f- j
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”7 D( T& o4 N6 U
li[2][2]='ALL'
  {* L. T& ?0 Iprint(li)
& K) c# B! a/ b* T- Q9 ^24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
% O8 o/ p$ K5 u4 D0 t; oa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')# d) M# J1 I7 Y: G" ]- P' Y
print(len(tu))
) t8 s8 d( D* V1 U( N$ Kb. 获取元组的第 2 个元素，并输出: j- z4 W5 _7 g* e* A) D) S+ `
print(tu[1])' M  l1 z* F: P/ H4 l
e. 请使用 for、len、range 输出元组的索引
( P, E! I+ x( |: M5 ]2 \for i in range(len(tu)) :  X" x: ]3 Z. S" i. V" z7 q9 Y
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
2 c" `/ @/ V/ e' {4 nfor k,v in enumerate(tu,10) :
/ h( c& U2 g* V6 z% m7 o# F print(k,v)+ r  l2 H& z" y1 C2 {: W
10 alex
1 p  C" [2 j9 [1 N( D! w11 eric
2 J" M& U$ F$ d7 i, d, a12 rain3 Y+ b1 e: C3 b$ N  B' K
3 ?( M1 C9 o, o. q6 m6 {
for k in enumerate(tu,10) :
& T  r6 ~, F  P8 u print(k)
7 ~; v7 Z3 o) g9 x' J  i(10, 'alex'), L; L9 S2 j% j& x3 d
(11, 'eric')' q0 M  {- ~5 D; P! y, q4 M/ ^
(12, 'rain')
( A* q! ^/ m  W* |: T# q& W0 c2 z& T  l- k$ ~
( I  l; i& Z, P* `& h4 E
25、有如下变量，请实现要求的功能7 H* H* m/ a& b/ I* e+ l8 o
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

( g6 O9 U  p2 n0 _* u3 ?+ P+ md. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
' D1 }4 ]1 \8 z+ F  P9 Ptu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
; n, |) b$ O1 \( C7 ]2 e9 ?res=tu[1][2]['k2'].append('seven')" v5 `, o( p* J+ s; u- S4 w" O" K

% }8 @7 R8 @: f$ s7 g/ W% G7 Fprint(tu)
* L% X+ W  C2 e+ ^3 ~. e26、字典
! k- r1 N& J1 Jdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
+ w6 W3 u$ U# e  d- C) `& z( m print(i)b. 请循环输出所有的 value
$ n+ F: Q$ P3 h( P3 [- E" p' nfor i in dic:
6 v3 V/ t* C+ b( u( X print(dic)
* c  P' o* Z# o; {c. 请循环输出所有的 key 和 valuefor i in dic:
( {1 S: S8 n8 x: Qprint(i,dic)' X9 G! L3 r1 j6 T
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
6 P" q( Z0 X! }; p$ _8 W) ]dic['k4']='v4'
  w( N1 r% L' j- M: K  s! [print(dic)6 m2 o& N5 ~, q2 k# f
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
+ l% h$ Y, t; p6 F; H$ Fdic['k1']='alex'
2 l" H- y' K. K' N' u; Jprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典/ V7 z" q2 l# [7 }- w% G; z5 U
dic['k3'].append(44)2 z: h- D# H8 v1 d
print(dic)5 c+ S0 f2 R6 g6 I
" q1 j- x/ o' s3 m% j
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典9 m- \$ R7 X, F$ |) Y1 W
dic['k3'].insert(0,44)
' N3 x9 `( n: Rprint(dic)8 `( {0 w$ j, l9 k
27、转换
( X- q/ L4 g9 t3 u3 @. ]1 ?a. 将字符串 s = "alex" 转换成列表  s = "alex"$ F* \, j5 W% @9 x& \5 D* H
3 ?( i' ~' {4 z. x+ k# t( N, _3 w
print(list(s))b. 将字符串 s = "alex" 转换成元祖
: q9 E1 Y3 U! b; Js = "alex"
. B9 L0 M/ x6 f/ F+ w# v% i$ }print(tuple(s))
5 [9 ?- b  T. L+ S3 v( R, R  Z
( [* [- t- A' ^6 o; s0 xb. 将列表 li = ["alex", "seven"] 转换成元组2 F0 b- h7 e2 V. ~; h, i
li = ["alex", "seven"]
! I, [# V, \2 s' o& lprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表, K! t/ q( I* ~  S' [! E
tu = ('Alex', "seven")+ W  T& i# f1 M5 ]: {% ], t9 R6 U
li=list(tu)" A6 d7 G( x3 @6 B3 s8 i
print(li)
; B! O9 D4 _( Y$ B6 J$ t) ~/ R0 `$ b6 D1 V6 i0 \

- W) Y  y% d% A9 ], ^& Ed. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
& P: s( B: X5 k2 z: q  Z6 Y
+ s# a$ Q1 O+ q8 g( f0 K" \1 c0 mdic={}
0 e& ]( S1 V4 k: M6 Wfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. Z+ |- O1 H+ g8 M dic[k]=v7 W# ?6 u; \1 l6 w
print(dic)27、转码n = "老男孩"' w8 H0 x+ ]" S2 D
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"2 U% b5 f5 t- |$ \; L+ K9 x
a=n.encode('utf-8') 3 _0 x+ P4 C! A$ X- r$ D8 ^" Y
print(a)& l. C5 v. a+ S4 v. R8 b( F5 u
b=a.decode('utf-8')
& q  Z4 v$ W2 [7 w% mprint(b)
$ M; U8 s- h+ i; X  i3 Y% Qb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
: M. W$ @3 b. tprint(a)  W, d# d  _8 j3 G: L. s
b=a.decode('gbk')0 \. w7 c& x0 G; X9 i$ ]
print(b)28、求 1-100 内的所有数的和1 B; W6 r4 L& [# B( K* `
count=1
: V$ q$ ?6 E) d) l7 P* \sum=00 {5 w  V9 D' i" X/ f
for i in range(100) :
( c; E. O3 O, i" ]4 ?; A sum=sum+count/ j6 I% x$ c  o, K0 t
count+=1
+ d1 y! m5 }$ ^0 u. R6 _print(sum)
  T+ g6 [) u+ e# G# m/ y. |& n; s' q/ Z+ a1 a) u
count=1& s& c6 H8 F. F" o% {
sum=0' s# t$ n" V) _+ {. W
while count<=100 :
) v3 X! s) m+ e0 [ sum+=count" |" }/ T, V3 g9 d9 E1 v
count+=1: g# f5 d+ E" L5 l* J  R
print(sum)29、元素分类
" e& m7 c; n9 _& R( p* H3 {6 k有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
" {; O7 b* e, o+ D9 Q" T4 @+ O# U将小于 66 的值保存至第二个 key 的值中。
2 M! r/ F( T7 _& a/ d" a* h即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
; L( B4 ~; g8 g, Nli=[11,22,33,44,55,66,77,88,99,90]
* _) g% q, P: F. Z+ Z1 Tdic1={
! ]0 Y# E, P' f) _/ f' v 'max':[],
$ \7 s, O/ R8 j5 k; T% O 'min':[]
) q! c. ]4 ^4 x. g1 F* x7 g}
4 J& v0 W% d5 ^( m) T! l1 efor i in li :
# J) G2 l9 V  P3 X8 ^6 e if i <66 :
- C/ {, ?; ?8 c/ A. j( X7 u" L1 ^       dic1['min'].append(i)" C* N0 v# V6 p) A! u* i
else:
! t% B& H8 @; g2 Z+ j9 I       dic1['max'].append(i)3 C9 W: k9 @, f$ |" a
print(dic1)
6 D, \/ o3 F9 u0 {# g" j7 I1 ?- ~, V+ x6 l1 ~* F4 c3 f% N
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}, W9 |# j" B$ t4 q) w

Python基础知识汇总

主题推荐