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、写代码
% M: j+ |& C" }' 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) :
& `  q1 W. w& V6 y) n  r8 | name = input('name:').strip()
+ F0 y: Y: K7 ]. Y- b9 ]6 t$ U pwd = input('pwd：').strip()
  x* K( {/ T7 l7 M) a
4 q; h* L) d" i; \ if name=='seven' and pwd=='123' :! J3 R, m) [* K' X3 t
      print('ok')
  F7 A2 Y3 B  _+ y& u5 Q: D else:
* u9 _* _7 ^9 Y  R% f       print('error')
7 I1 I- Z* d* ]3 Q. W: C% U       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)  :4 j4 B8 ^/ j! {" ]& t+ D
name = input('name: '). n- N- y7 r5 j% ]# ?) S# Y  X# z
pwd = input('pwd: ')
) e  d6 o( T- B1 |6 | if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':8 T/ G3 p" Z; I
      print('ok')$ f! ~1 W. {5 Q+ Q
else :: p" W& r( F$ H- ^2 D% ~7 m
      print('error')2 m6 V9 e$ q; E+ O7 @! T
      count+=111、写代码
# Z$ a" Q" f: V: [1 da. 使用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) :
2 s3 f8 E6 {5 g3 h+ T& q if i %2 != 0 :
$ Q; n6 P: P1 L" {  I9 _' Y       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :6 ^. C# O( ]3 A/ S6 W8 V: u# Q
if i %2 == 0:
2 U4 k( E& V; m  M( j       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"
1 v, Y3 e! L. @% d! P. X9 o! O  Fa. 移除 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)# q7 Z3 C$ v, g7 _! N" N
for i in name:/ w6 p) P1 @9 `2 z" ~& m
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain( b7 E# n+ h  \4 z: E
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
8 p+ j/ p0 p( Nprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')       A3 l( E3 Y* x" s* |( P
print(li)
2 b: A! o, R9 c' g ['alex', 'eric', 'rain', 'seven']
8 Z' M( |! y) L( _2 Mc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')- j+ c' s& b8 F, ^# [; w
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
5 k! f8 \% g% jprint(li), I$ ]7 g6 O+ R
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']1 j- _+ p& T& g- B
li.pop(1)
- _4 R+ W. s" i' H3 H6 t( tprint(li) ['alex', 'rain']# o# r" A' y$ {: Z* I
指名道姓的删除li = ['alex', 'eric', 'rain']
# n* n' H, `+ i  T, ^* J# Fli.remove('alex')
! J5 O; e( T) B- o" L+ \5 s2 M9 kprint(li)
' T7 F: u. F! z9 O1 M! w! H* Nf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']$ N$ G& j# N; V5 B" X3 Z, c
print(li.pop(1))/ Z7 F* r" \4 H6 O% C, `6 w6 W- E
print(li)" n/ ~! W& n. b# d

. N/ H7 U" V  ^6 ieric
+ Q. |2 n' b- T$ F' u9 d/ q: q" j['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
. {. R0 _/ @3 [7 O* |( F6 Q3 e. Pdel li[1:]: o/ C& s. P  J1 [
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
+ B9 r$ Z! V2 M, k  |( F- yli = ['alex', 'eric', 'rain']
9 y/ p% R5 Y- B+ A( nfor k,v in enumerate(li,1):
! ^( Q- J# B4 M9 {$ E print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
: P' T- B" }9 U% @9 Q1 E: g9 ]a. 请输出 “Kelly”
" o/ T1 B5 e, V  R1 ^# Q! d! uli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
( Z  Q/ ]( s5 Q/ Y4 V" Cprint(li[2][1][1]): Z, o1 g, @7 W/ Y+ g5 P+ _
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”! F- i. M) i8 @* m4 @2 H
li[2][2]='ALL'
( K+ s% S! N( V& W+ ]print(li)
4 F7 u6 N4 {! F, I$ J7 @" I24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')( I2 i/ b3 k* b( V6 C9 h
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
- ~* H/ v% D8 J+ K$ eprint(len(tu))
4 C  d  C# B8 v7 o1 Y; db. 获取元组的第 2 个元素，并输出
/ ]. K4 p- P; \( iprint(tu[1])) \/ K( a0 y( w% a
e. 请使用 for、len、range 输出元组的索引9 f9 q- c9 n/ H. M& K
for i in range(len(tu)) :* E9 G2 M3 x0 ]6 Q' D8 O" ?4 A
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
3 O3 `, \- Q# {  C) n$ L# Nfor k,v in enumerate(tu,10) :% {5 A' l! N) F9 i/ M
print(k,v)
1 e$ ]8 n7 K- I( G( t4 K10 alex8 P: z: ^% H  \7 d) L6 E! h
11 eric: e7 @; k2 E4 q( Z
12 rain
% S& M' j* ?3 c! f* }! O. v1 p$ Y; t" [
for k in enumerate(tu,10) :2 @6 B3 t" f7 ]0 ]6 f' u7 ]; }  a7 C
print(k)8 z2 m& f# I3 I3 r8 s7 F2 R: T$ g$ c
(10, 'alex')8 B% K$ P* V1 m9 u* Y1 `7 ~) i
(11, 'eric')
5 `+ P' x, Q% c* o" P  C(12, 'rain')
2 G8 p7 _! T; a( R5 v5 K) O' p/ k

( ?- a) X" b, Z5 e1 u0 F8 |25、有如下变量，请实现要求的功能
6 V, `9 M# {& f* _: utu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

- o3 u' f( s: s8 w6 ~d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
7 P6 d+ I/ d0 n+ Ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])* g7 n% k5 M0 X; D
res=tu[1][2]['k2'].append('seven')
* g6 j: s8 q. H: B( j* P; D  `1 U" J4 {
print(tu)2 D0 |0 K0 B' E5 \+ P
26、字典. u- |9 v0 c; [0 x& F
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:/ `4 m8 Y) u- V' j8 \5 v, h* I
print(i)b. 请循环输出所有的 value
! E1 q' |- j( m. Z  mfor i in dic:7 h2 w9 s" D6 a9 o1 |8 F6 u) ^
print(dic)/ i7 g7 h8 x6 j/ D; k
c. 请循环输出所有的 key 和 valuefor i in dic:! o3 ~4 H, k: Z
print(i,dic)
4 |0 x" g# e1 ?0 J0 Id. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
- [3 t* L$ F& @( Tdic['k4']='v4') o# V4 M9 U# t+ [2 c; r
print(dic)* }' h/ `; c2 S" b$ Z" X9 o! q
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典! B3 C( q3 k+ G$ x* C) `1 C9 g
dic['k1']='alex'
. W/ C' r4 K+ l, p& Pprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典9 p0 g* M1 F, Y; Z# {& v8 b5 i8 I
dic['k3'].append(44)
# K" y# f0 p* X& M, w1 i" K' P3 Xprint(dic)
6 q4 s* |, D* a6 O, l: B3 a+ e, a
+ l8 c. n6 ]' Q( ]% R4 I9 R% P% r% Qg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
; n2 E6 I* v/ j' d: N+ @  {dic['k3'].insert(0,44)
8 G8 p4 f- S$ s9 H$ P( Uprint(dic)
6 T! L( J4 `9 e+ n( [) @8 j9 m27、转换
6 A5 L2 ]! e$ Q. |' Ya. 将字符串 s = "alex" 转换成列表  s = "alex"6 O+ y8 ~3 f1 }4 V! ]3 g3 E" U1 x

, I0 M% E, P, aprint(list(s))b. 将字符串 s = "alex" 转换成元祖
6 _- R7 I$ S  p) s( s8 ~s = "alex"
2 c' i6 t( G. J7 P. {9 U2 L5 k' |print(tuple(s))
& @3 V1 }, d1 c! R+ y& m3 [5 h
! Z; w) c" Q" J& f- }  d+ Nb. 将列表 li = ["alex", "seven"] 转换成元组
- ^- P6 ?& z( R- zli = ["alex", "seven"]0 J& T- @8 e# t/ y6 a4 r: h3 p
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表! Z% d3 Q1 ~1 Q& _
tu = ('Alex', "seven")- I9 Y( n# ?0 X: Q$ E! O3 I; ]7 O
li=list(tu)2 N. D) E; N, z$ ]0 m$ H7 F
print(li); X0 ?# _6 y, ]; _! Q/ @
+ h8 h2 @  t6 ~- s

+ U# ~! {9 P) J8 U' X1 Y* X* \d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
6 ^: i7 Z# v8 P' t: D
9 ]6 C/ S+ c( B' n- gdic={}8 P% S% ^% f0 y1 q% P& R3 ?- ?5 j
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面' B6 V  h  C$ T9 z3 H; y
dic[k]=v- f3 Q9 C" a. m( l, f
print(dic)27、转码n = "老男孩": f% q' D* X* z
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩", l; ]! y4 S9 c+ I9 M
a=n.encode('utf-8') 9 J$ [. v. r' _6 y! x9 E6 E
print(a)( a: D7 V) M! e( }) N
b=a.decode('utf-8'): a( g6 R: s8 I6 ^1 m/ p2 ^& H- N; t
print(b)) N: _& Z+ o* f/ s! L$ @
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')- b  S( \# j/ J+ J  e4 N
print(a)
' w7 a& p/ {4 Q" S0 y! Y$ Hb=a.decode('gbk')
! u' m- A( F  F" |  r/ Zprint(b)28、求 1-100 内的所有数的和
. m$ ^2 n2 Y% ~7 g) @count=1$ r6 J; C% y( {; {
sum=07 U* e1 _8 t- s% n8 t. x
for i in range(100) :
/ Y" U3 I% F& X3 ^7 [# R6 o) S sum=sum+count" }9 o  V2 J. I$ @# r  c
count+=1
- @: e/ i! B# f' G0 B( Kprint(sum)
' S5 y8 }5 c4 @
: j2 n) g1 e, ~count=1, w/ A8 W8 P3 f
sum=0: n8 `" `) u  P" m& A% V9 |! I8 {$ T
while count<=100 :
$ l1 ~( `% y3 d- f. A" K) a. _. L2 L sum+=count  U% J. J. G$ U3 T( y
count+=16 n- I  i8 F$ I% G
print(sum)29、元素分类
( p9 z# Q" O) j* k5 r6 V* S. J有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
; d  _2 C6 Y# R. d将小于 66 的值保存至第二个 key 的值中。
- J: @, T3 X$ k7 p; ~即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
/ ~  @0 |0 j% t9 G- Uli=[11,22,33,44,55,66,77,88,99,90]$ u3 H, D) _+ U" j/ i8 Q, d
dic1={
! T) `1 D4 d; v2 |$ i 'max':[],, [0 C# n- w* G  T( K
'min':[]
* x3 `4 B* Y. ^' T' S) C, W" D% f}: u' h. L$ M/ }
for i in li :
% V4 V) ~5 s$ q1 D. h* B if i <66 :
* `& ^6 A+ `' e3 w       dic1['min'].append(i)5 M+ w; h3 l$ }# E3 l$ D
else:
- N7 S) |: c8 N  q; V       dic1['max'].append(i): T5 u, }7 a0 e% Z* G7 a8 I
print(dic1): g4 N5 I% K6 r
: B3 p! r6 P% V* b- M: ]1 h6 f
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}" L$ D) R  f- }2 K& e% r3 W

Python基础知识汇总

主题推荐