一、基础部分

input() 接收用户的输入

1
2

temp = input("请输入一个数字")  
print(temp)

随机数 random 模块

1
2

import random					#导入
random.randint (a, b)			#随机a ~b 之间的整数

数据类型

1. 整数
   长度不受限制

2. 浮点数

精确计算浮点数：decimal

1
2

import decimal
a = decimal.Decimal('0.1')

E 记法（科学计数法）
E的意思是指数，指底数为10，E后边的数字就是10的多少次幂。
例如，15 000等于1.5×10 000，也就是1.5×10⁴，E 记法写成1.5e4。

3. 复数
   x = 1 + 2j 用浮点数存储
   获取实部：real

1
2

>>>x.real
1.0

获取虚部：imag

1
2

>>>x.imag
2.0

4. 类型转换
   int(x)： 转换成整数
   float(x)：转成浮点数
   str()：转换成一个字符串：
   complex(re, im)： 转成复数
   type()：获取变量的类型，
   更建议使用 isinstance()这个 内置函数 来判断变量的类型。
   isinstance()函数有两个参数：第一个是待确定类型的数据；第二个是指定一个数据类型。它会根据两个参数返回一个布尔类型的值，True表示类型一致，False表示类型不一致。举个例子：

   1 2 3 4 5 6 7

   >>> a = "你好世界" >>> isinstance(a, str) True >>> isinstance(520, float) False >>> isinstance(520, int) True

5. 算术操作符： +　-　*　/　%　**　//
   x // y： 向下取整（等同于其他语言中的 floor）
   %：取余
   divmod(x, y)： 返回 (x // y, x % y)
   abs(x) ： 绝对值（如果是复数，返回模）
   pow(x, y)：计算 x^y
   x ** y：计算 x^y

6. 布尔类型

**True**：1 == True
**False**：0 == False

定义为 False 的对象：None 和 False
值为 0 的数字类型：0， 0.0， 0j， Decimal(0), Fraction(0, 1)
空的序列和集合：’’, (), [], {}, set(), range(0)

6. 逻辑运算符
   and：与
   or：或
   not：非

   1 2 3 4

   # 特殊语法 5 > 3 < 4 5 > 3 and 3 < 4 # 等价 # 输出：true

Python 中任何对象都能直接进行真值测试

短路逻辑 or and
从左往右，只有当第一个操作数的值无法确定逻辑运算的结果时，才对第二个操作数进行求值。

7. 运算符优先级

+, -, *, /, //, % > 比较运算符 > 逻辑运算符
not > and > or

分支结构

断言

assert 关键字翻译过来就是“断言”，当这个关键字后边的条件为假的时候，程序自动崩溃并抛出 AssertionError 异常。

1
2

assert 3 < 4
# AssertionErroor

一般来说，可以用它在程序中置入检查点，当需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert关键字就非常有用了。

if

1
2

if condition:
    statement(s)

1
2
3
4

if condition:
    statement(s)
else:
    statement(s)

1
2
3
4
5
6
7

if condition1:
    statement(s)
elif condition2:
    statement(s)
elif condition3:
    statement(s)
...

1
2
3
4
5
6
7
8
9

if condition1:
    statement(s)
elif condition2:
    statement(s)
elif condition3:
    statement(s)
...
else:
    statement(s)

三元操作符

1
2
3
4
5
6
7
8
9
10
11
12

# 语法
条件成立时执行的语句 if condition else 条件不成立时执行的语句

# 原形式
if x< y:
    small =x
else:
    small =y

# 三元运算符的形式
small = x if x<y else y

循环结构

while

1
2

while condition:
    statement(s)

for

1
2

for 变量 in 可迭代对象:
    statement(s)

可迭代对象就是指那些元素可以被单独提取出来的对象，如目前最熟悉的字符串，像“FishC”就是由“F”“i”“s”“h”“C”五个字符元素构成的。那么，for循环语句每执行一次就会从该字符串（可迭代对象）中拿出其中一个字符，然后存放到变量中。

1
2
3
4
5
6
7
8

>>>for each in 'FishC':
    print(each)
# 输出
F
i
s
h
C

通过for语句来实现打印1+2+3+4+…+100

1
2
3
4
5
6
7
8
9

# 错误，因为100不是可迭代对象
sum=0
for i in 100:
    sum+=i
    print (sum)
	

for i in range(10):		#range(10)是左闭右开区间[0, 10)
	print(i)

range()是一个内置函数函数，它可以为指定的整数生成一个数字序列（可迭代对象）

1
2
3
4
5
6
7
8
9
10
11
12

# 注：list是将可迭代对象以列表的形式展示出来。

range(stop) # 生成[0,stop)的数字序列
# 例如 print(list(range(5))) 打印结果为 [0, 1, 2, 3, 4]

range(start, stop)  #生成[start,stop)的数字序列
# 例如 print(list(range(1,5))) 打印结果为[1, 2, 3, 4]

range(start, stop, step) #允许指定步长step（每个元素的间隔），这个步长除了可以是正整数，还可以是负整数：
# 例如list(range(0, 10, 2))，打印结果为[0, 2, 4, 6, 8]
# list(range(0, -10, -2))，打印结果为[0, -2, -4, -6, -8]

break

终止当前循环，跳出循环

continue

跳出本轮循环并开始下一轮循环（这里要注意的是：在开始下一轮循环之前，会先测试循环条件）。

else

while 和 for 循环后面也可以跟 else，表示当条件不成立的时候执行的内容

1
2
3
4
5
6
7
8
9

while 条件:
    循环体
else:
    条件不成立时执行的内容
		
for 变量 in 可迭代对象:
    循环体
else:
    条件不成立时执行的内容

正常境况下 else 不用写，因为本身条件不成立的时候就会结束循环执行后面的内容，但使用 break 时可能会不同：在 else 前面写 break，当 break 触发时不会执行 else 中的内容。

二、列表/元组/字符串

列表 list

变量类型为 <class 'list'>
列表类似数组，但可以存放不同类型的变量

创建列表

格式：中括号（数据之间用逗号分隔）

1

r = [1, 2, 3, 4, 5, '上山打老虎']

元素：1，2，3，4，5，‘上山打老虎’
下标：0，1，2，3，4 ，5
下标：-6，-5，-4，-3，-2，-1

删除元素

remove()：删除一个元素
注意：

1. 如果列表中存在多个匹配的元素，只会删除第一个；
2. 如果指定的元素不存在，那么程序就会报错。

pop()：删除并返回最后一个元素
clear()：清空列表

del 语句

1
2
3
4
5
6
7
8
9
10

# 删除某个（些）元素
eggs = ["鸡蛋", "鸭蛋", "鹅蛋", "铁蛋"]  
del eggs[0]  
print(eggs)
#输出：['鸭蛋', '鹅蛋', '铁蛋']

# 删除变量
del eggs  
print(eggs)
# 报错：name 'eggs' is not defined

切片语法

用一个冒号隔开两个索引值，左边是开始位置，右边是结束位置。
注意：结束位置上的元素是不包含的
如果为空，左边默认为列表第一个位置，右边默认为列表最后一个位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#已知列表r[1, 2, 3, 4, 5, '上山打老虎']
 
>>> r[0:3]
[1, 2, 3]

>>> r[:3]
[1, 2, 3]

>>> r[3:6]
[4, 5, '上山打老虎']

>>> r[3:]
[4, 5, '上山打老虎']


>>> r[-6:]	#从-6到-1
[1, 2, 3, 4, 5, '上山打老虎']

>>> r[:-1]	#从-6到-1
[1, 2, 3, 4, 5]

>>> r[:]	#整个列表
[1, 2, 3, 4, 5, '上山打老虎']

引入步长，默认值为1

1
2
3
4
5
6

>>> r[0:6:2] #指定步长2
[1, 3, 5]

>>> r[::2] #整个列表，指定步长2
>>> r[::-1] #翻转整个列表

[!NOTE]
列表切片并不会修改列表自身的组成结构和数据，它其实是为列表创建一个新的拷贝（副本）并返回。

例外的，del 语句可以使用列表切片，直接作用于原始列表

1
2
3

>>> del r[::2]
>>> r
[2, 4, 6, 8]

为切片后的列表赋值也会作用于原始列表

1
2
3

>>> r[0:2] = ['一','二']  
>>> r
['一', '二', 3, 4, 5, '上山打老虎']

添加元素

**append()**：列表末尾添加一个元素，在列表末尾 （只支持一个参数）
**extend()**：列表末尾添加另一个列表（支持多个参数）

1
2
3
4
5
6
7

>>> s = [1, 2, 3, 4, 5]
>>> s[len(s):] = [6]				#和s.append(6)相同
>>> s
[1, 2, 3, 4, 5, 6]
>>> s[len(s):] = [7, 8, 9]			#和s.extend([7,8,9])相同
>>> s
[1, 2, 3, 4, 5, 6, 7, 8, 9]

**insert(a, b)**：指定位置插入一个元素（第一个参数：位置下标，第二个参数：元素值）

1
2
3
4
5
6
7
8
9

>>> s = [1, 3, 4, 5]
>>> s.insert(1, 2)
>>> s
[1, 2, 3, 4, 5]

# 第一个参数支持负数，表示与列表末尾的相对距离
>>> number.insert(-1, 8.5)
>>> number
[0, 1, 2, 3, 4, 5, 6, 7, 8, 8.5, 9]

获取元素

len() 函数获取列表长度
random.choice() 随机获取一个元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 通过索引值
>>> eggs = ["鸡蛋", "鸭蛋", "鹅蛋", "铁蛋"]
>>> eggs[0]
'鸡蛋'
>>> eggs[3]
'铁蛋'

# 获取列表最后一个元素
>>> eggs[len(eggs)-1] # len()函数获取列表长度
>>> eggs[-1] # 直接获取
'铁蛋'

# random.choice()随机获取一个元素
>>> random.choice(eggs) # 直接获取

# 列表中还可以包含另一个列表，如果要获取内部子列表的某个元素，应该使用两次索引：
>>> eggs =['鸡蛋'，'铁蛋'，['天鹅蛋'，'企鹅蛋'，'加拿大鹅蛋']，'鸭蛋']
>>>eggs [2] [2]
'加拿大鹅蛋'

常用操作符

比较：当列表包含多个元素的时候，默认是从第一个元素开始比较，只要有一个 PK 赢了，就算整个列表赢了。字符串比较也是同样的道理（字符串比较的是每一个字符对应的 ASCII 码值的大小）。

加法：也叫连接操作符，它允许把多个列表对象合并在一起，其实就相当于 extend() 方法实现的效果。一般情况下建议使用 extend() 方法来扩展列表，因为这样显得更为规范和专业。另外，连接操作符并不能实现列表添加新元素的操作（只能是列表和列表相加）：

1
2
3
4
5

>>> list1 = [123, 456]
>>> list2 = [234, 123]
>>> list3 = list1 + list2
>>> list3
[123, 456, 234, 123]

乘法：又称重复操作符，重复列表内所有元素若干次

1
2
3

>>> list1 = ["FishC"]
>>> list1 * 3
['FishC', 'FishC', 'FishC']

in 和 not in（成员关系操作符）：在不在列表

1
2
3
4
5

>>> list1 = ["小猪", "小猫", ["你好世界", "小乌龟"], "小狗"]
>>> "你好世界" in list1
False
>>> "小乌龟" not in list1 
True #可见in和not in只能判断一个层次的成员关系

在开发中，有时候需要去除列表中重复的数据，只要利用好 in 和 not in，就可以巧妙地实现：

1
2
3
4
5
6
7
8

>>> old_list=['西班牙'，'葡萄牙'，'葡萄牙'，'牙买加'，'匈牙利]
>>> new_list = []
>>> for each in old_list:
			if each not in new_list:
				new_list.append (each)
>>>print (new_list)
['西班牙'，'葡萄牙'，'牙买加'，'匈牙利']

常用方法

count()：统计某个元素在列表中出现的次数：

1
2
3

>>> list1 = [1, 1, 2, 3, 5, 8, 13, 21]
>>> list1.count(1)
2

index()：返回某个元素在列表中第一次出现的索引值

1
2
3
4
5
6
7
8

>>> list1.index(1)
0

# 可以限定查找的范围：
>>> start = list1.index(1) + 1
>>> stop = len(list1)
>>> list1.index(1, start, stop)
1

reverse()：将整个列表原地翻转：

1
2
3

>>> list1 = [1, 1, 2, 3, 5, 8, 13, 21]
>>> list1.reverse()
[21, 13, 8, 5, 3, 2, 1, 1]

sort()：对列表元素从小到大排序：

1
2
3
4

>>> list1 = [8, 9, 3, 5, 2, 6, 10, 1, 0]
>>> list1.sort()
>>> list1
[0, 1, 2, 3, 5, 6, 8, 9, 10]

从大到小排序：

1. 先调用 sort()方法，然后调用 reverse()方法原地翻转
2. sort() 这个方法有三个参数，语法形式为：sort(func, key, reverse)
   func 和 key 参数用于设置排序的算法和关键字，默认是使用归并排序
   reverse 参数默认为 False，表示不颠倒顺序（世界上 sort 的默认形式也可以写成sort(reverse=False)）。因此，只需要把 False 改为 True，列表就相当于从大到小排序：

   1 2 3 4

   >>> list1 = [8, 9, 3, 5, 2, 6, 10, 1, 0] >>> list1.sort(reverse=True) >>> list1 [10, 9, 8, 6, 5, 3, 2, 1, 0]

copy() ：拷贝一个列表 浅拷贝

嵌套列表（创建二维列表，也就是矩阵）

1
2
3
4

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> matrix[0]				#第一行
[1, 2, 3]
>>> matrix[1][1]			#第二行第二列

is 运算符（同一性运算符）

检验两个变量是否指向同一个对象

①

1
2
3
4
5
6
7
8

>>> A = [0] * 3
>>> for i in range(3):
        A[i] = [0] *3				# √
>>> A
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

>>> A[0] is A[1]
False

②

1
2
3
4
5
6

>>> B = [[0] * 3] *3						#× 有bug
>>> B
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

>>> B[0] is B[1]
True

浅拷贝和深拷贝

y = x ： （引用）当 x 改变，y 也改变
y = x.copy() ： 拷贝整个列表（浅拷贝）当 x 改变，y 不改变
y = x[:]

浅拷贝：只拷贝了外层的对象，当包含嵌套列表时，只是引用

copy 模块:

浅拷贝：copy()

1
2
3

>>> import copy
>>> x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> y = copy.copy(x)

深拷贝：deepcopy()

1
2
3

>>> import copy
>>> x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> y = copy.deepcopy(x)

列表推导式

1
2
3
4

>>> oho = [1, 2, 3, 4, 5]
>>> oho = [i * 2 for i in oho]
>>> oho
[2, 4, 6, 8, 10]

（1）

1

[expression for target in iterable]

ord() : 将字符转换为对应的 Unicode 编码

1
2
3

>>> code = [ord(c) for c in 'FishC']
>>> code
[70, 105, 115, 104, 67]

1
2
3
4
5
6
7

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> col2 = [row[1] for row in matrix]
>>> col2
[2, 5, 8]
>>> diag = [matrix[i][i] for i in range(len(matrix))]
>>> diag
[1, 5, 9]

改变列表内容时，用 for 循环和列表推导式是不完全一样的。
for 循环：通过迭代，逐个修改原列表中的元素。
列表推导式：直接创建一个新的列表，再赋值给原来的变量。

创建嵌套列表：

1

s = [[0] * 3 for i in range(3)]

（2）

1

[expression for target in iterable if condition]

eg：

1
2
3

>>> even = [i for i in range(10) if i % 2 == 0]
>>> even
[0, 2, 4, 6, 8]

（3）

1
2
3
4

[expression for target in iterable1
for target in iterable2
...
for target in iterableN]

（4）

1
2
3
4

[expression for target in iterable1 if condition1
for target in iterable2 if condition2
...
for target in iterableN if conditionN]

元组 tuple

类型为 <class 'tuple'>

元组和列表的最大区别是：元组只可读，不可写。

创建和访问元组

1、创建
元组和列表，除了不可改变这个显著特征之外，还有一个明显的区别：创建列表用的是中括号，而创建元组大部分时候使用的是小括号（小括号可省略，逗号才是关键）：

1

tuple = (1, 2, 3, 4, 5, 6, 7, 8)

2、访问
访问方式与列表相同

1
2
3
4

>>> tuple[1]
2
>>> tuple[5:]
(6, 7, 8)

元组的标识符号：逗号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

>>> tuple1 = (520)
>>> type(tuple1)
<class 'int'>

# 在元素后面添加一个逗号（,）来实现类型识别
>>> tuple1 = (520,)
>>> type(tuple1)
<class 'tuple'> 

# 不写小括号也可以识别出类型
>>> tuple2 = 520,
>>> tuple1 == tuple2
True
>>> tuple3 = 1, 2, 3, 4, 5
>>> type(tuple3)
<class 'tuple'>

#逗号（,）才是关键，小括号只是起到补充的作用
>>> 8 * (8)
64
>>> 8 * (8,)
(8, 8, 8, 8, 8, 8, 8, 8)

创建空列表：temp = []
创建空元组：temp = ()
创建只有一个元素的元组：eg：tuple = (1,) 或者tuple = 1,

更新和删除

1、更新
所谓的更新并不是修改元组自身，因为元组只可读不可写，可以利用切片语法为元组创建一个新的拷贝（副本）。旧的元组一旦失去了变量的引用，就会被 Python 的垃圾回收机制释放掉。

1
2
3
4

>>> temp = (3, 4, 6, 7)
>>> temp = temp[:2] + (5,) + temp[2:]		# (5,) 括号，逗号，缺一不可
>>> temp
(3, 4, 5, 6, 7)

1
2
3
4
5
6
7
8
9

# 使用id函数查看id值
temp = (3, 4, 6, 7)  
print(id(temp))  
temp = temp[:2] + (5,) + temp[2:]  
print(id(temp))

#从返回值可以看出，这两个temp并不是同一个对象
#1785625602912
#1785625519552

补充：id() 函数用于返回指定对象的唯一 id 值，这个 id 值可以理解为现实生活中的身份证，在同一生命周期中，Python 确保每个对象的 id 值是唯一的。

2、删除
删除整个元组：del

1

del temp

在日常开发中，很少使用 del 去删除整个元组，因为 Python 的垃圾回收机制会在某个对象不再被使用的时候自动进行清理。

字符串

• 在一些编程语言中，字符和字符串是两个不同的概念，但在 Python 中，只有字符串这一个概念。
• 字符串 string 必须用 ' ' 或者 " " 表示
• 字符串只可读不可写，可以使用切片语法生成拷贝
• 字符串变量支持中文

1. 字符串的特殊赋值写法

   1 2 3 4 5

   // 特殊赋值写法 x = 3 y = 5 x,y = y, x print(x, y)

2. 字符串运算

   1 2 3 4 5 6 7 8 9

   # 字符串加法 print('520'+'1314') #输出 #5201314 # 字符串乘法 print("1" * 5) #输出 #11111

3. 转义字符 \ 防止引号冲突

4. 原始字符串

   1 2 3 4 5 6 7 8

   print("D:\three\two\one") # 错误，\斜杠被认为是转义字符 print( "D:\\three\\two\\one" ) # 正确 print(r"D:\three\two\one") #在引号前添加 r 或 R，称为原始字符串，原始字符串是为了解决ascii字符和正则表达式特殊字符间的冲突而产生的。 #输出 #D: hree wo\one #D:\three\two\one #D:\three\two\one

在使用字符串时需要注意的一点是：无论是否为原始字符串，都不能以反斜杠作为结尾（注：反斜杠放在字符串的末尾表示该字符串还没有结束，换行继续的意思）

5. 换行

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   # \n换行转义字符 print("1\n2\n3") #输出 #1 #2 #3 # 更好的方法：长字符串，三引号（单引号双引号均可） print("""1 2 3""") #输出 #1 #2 #3

   **`

字符串方法

[!NOTE] 提示

1. 只要涉及字符串修改的方法，并不是修改原字符串，而是返回字符串修改后的一个拷贝。

字符串拼接的三种方法：
•　简单字符串连接时，直接使用加号（+），例如：full_name = prefix + name。
•　复杂的，尤其有格式化需求时，使用格式化操作符（%）进行格式化连接，例如：result = "result is %s:%d" % (name, score)。
使用格式化的方法对字符串进行拼接：

1
2
3
4

>>> str1 = "一支穿云箭，千军万马来相见；"
>>> str2 = "两副忠义胆，刀山火海提命现。"
>>> "%s%s" % (str1, str2)
'一支穿云箭，千军万马来相见；两副忠义胆，刀山火海提命现。'

•　当有大量字符串拼接，尤其发生在循环体内部时，使用字符串的 join()方法无疑是最棒的，例如：result = "".join(iterator)。

字符串格式化

格式化字符串，就是按照统一的规格去输出一个字符串。

format()

format()方法接收位置参数和关键字参数，二者均传递到一个名为 replacement 的字段。而这个 replacement 字段在字符串内用大括号 {} 表示。
①位置参数

1
2

>>> "{0} love {1}.{2}".format("I","FishC","com")
'I love FishC.com'

②关键字参数

1
2

>>> "{a} love {b}.{c}".format(a="I",b="FishC",c="com")
'I love FishC.com'

如果将位置参数和关键字参数综合在一起使用，那么位置参数必须在关键字参数之前

1
2

>>> "{0} love {b}.{c}".format("I", b="FishC", c="com")
'I love FishC.com'

特别的
用多一层大括号包起来打印大括号：

1
2

>>> "{{0}}".format("不打印")
'{0}'

1
2

>>> "{0}：{1:.2f}".format("圆周率", 3.14159)
'圆周率：3.14'

可以看到，位置参数{1}跟平常有些不同，后边多了个冒号。在替换域中，冒号表示格式化符号的开始，“.2”的意思是四舍五入到保留两位小数点，而 f 的意思是浮点数，所以按照格式化符号的要求打印出了3.14。

格式化操作符%

当%的左右均为数字的时候，它表示求余数的操作；但当它出现在字符中的时候，它表示的是格式化操作符。

字符串格式化符号

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 例子
>>> '%c' % 97
'a'
>>> '%c%c%c%c%c' % a
'FishC'
>>> '%d转换为八进制是：%o' % (123, 123)
'123转换为八进制是：173'
>>> '%f用科学计数法表示为：%e' % (149500000, 149500000)
'149500000.000000用科学计数法表示为：1.495000e+08'

# 进制转换
print('十进制 -> 十六进制 : %d -> 0x%x' % (num, num))
print('十进制 -> 八进制 : %d -> 0o%o' % (num, num))
print('十进制 -> 二进制 : %d ->' % (num), bin(num))

格式化操作符辅助命令

1
2
3
4
5
6
7
8
9
10
11
12

>>> '%5.1f' % 27.658
' 27.7'
>>> '%.2e' % 27.658
'2.77e+01'
>>> '%10d' % 5
'         5'
>>> '%-10d' % 5
'5         '
>>> '%010d' % 5
'0000000005'
>>> '%#X' % 100
'0X64'

转义字符

序列

列表、元组和字符串的共同点：

• 都可以通过索引得到每一个元素
• 默认索引值总是从 0 开始
• 可以通过切片的方式得到一个范围内的元素的集合
• 有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
  他们统称为序列

序列方法

注： [iterable] 表示可迭代参数

list([iterable]) ：把一个可迭代对象转换为列表 ,参数可以为空
tuple([iterable]) ：把一个可迭代对象转换为元组
str(obj) ：把 obj 对象转换为字符串
len(sub) ：返回 sub 对象的长度
max() ：返回序列或者参数集合中的最大值，要保证序列或者参数的数据类型统一
min() ：返回序列或者参数集合中的最小值，要保证序列或者参数的数据类型统一
sum(iterable[, start]) ： 返回序列 iterable 和可选参数 start（表示从该值开始加起，默认值是0） 的总和

sorted(iterable, key=None, reverse=False) ： 从小到大排序
列表的内建方法 sort()是实现列表原地排序；而 sorted()是返回一个排序后的新列表。

reversed(sequence) ： 实现效果跟列表的内建方法 reverse()一致。
列表的内建方法是原地翻转，而 reversed()是返回一个翻转后的迭代器对象。
使用 list(reversed(sequence)) 可以打印该对象

enumerate(iterable) ： 生成由二元组（二元组就是元素数量为2的元组）构成的一个迭代对象，每个二元组由可迭代参数的索引号及其对应的元素组成.
使用 list(enumerate(iterable)) 可以打印该对象

zip(iter1[,iter2[...]]) ：返回由各个可迭代参数组成的元组（返回迭代器对象）.
使用 list(zip(iter1[,iter2[...]])) 可以打印该对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

# list([iterable])
>>> b = list("FishC")
>>> b
['F', 'i', 's', 'h', 'C']
>>> c = list((1, 1, 2, 3, 5, 8, 13))
>>> c
[1, 1, 2, 3, 5, 8, 13]

# len(sub)
>>> str1 = "I love fishc.com"
>>> len(str1)
16

# max()
>>> list1 = [1, 18, 13, 0, -98, 34, 54, 76, 32]
>>> max(list1)
76
>>> str1 = "I love fishc.com"
>>> max(str1)
'v'
>>> max(5, 8, 1, 13, 5, 29, 10, 7)
29

# sum(iterable[, start])
>>> tuple1 = 1, 2, 3, 4, 5
>>> sum(tuple1)
15
>>> sum(tuple1, 10)
25

# reversed(sequence)
>>> numbers = [32, 35, 76, 29, 4, 0, -56, 17]
>>> reversed(numbers) #返回迭代器
<list_reverseiterator object at 0x026DAFD0>
>>> list(reversed(numbers)) 
[17, -56, 0, 4, 29, 76, 35, 32]

# enumerate(iterable)
>>> enumerate(numbers)
<enumerate object at 0x0271BC28>
>>> list(enumerate(numbers))
[(0, 32), (1, 35), (2, 76), (3, 29), (4, 4), (5, 0), (6, -56), (7, 17)]

# zip(iter1[,iter2[...]])
>>> a = [1, 2, 3, 4, 5, 6]
>>> b = [4, 5, 6, 7]
>>> zip(a, b)
<zip object at 0x0271BC28>
>>> list(zip(a, b))
[(1, 4), (2, 5), (3, 6), (4, 7)]

三、函数

定义函数：

1
2

def  函数名(参数):
	...

调用： 函数名 (参数)

1
2
3
4

>>> def add(num1, num2):
		num = num1 + num2
		print(num)
>>> add(2, 3)

返回值（return）

1
2
3

>>> def add(num1, num2):
		return (num1 + num2)
>>> print(add(2, 3))

• 在 Python 中，并不需要定义函数的返回值类型，函数可以返回不同类型的值；而如果没有返回值，则默认返回 None。
• 如果返回了多个值，Python 默认是以元组的形式进行打包。
• 也可以利用列表将多种类型的值打包到一块儿再返回。

1 函数文档

1
2
3
4
5
6
7
8
9

def func(i):  
"""  
函数文档  
"""  
return i+1 

print(func(1)) 
# 打印：2

函数开头的几行字符串并不会被打印出来，但它将作为函数的一部分存储起来。这个字符串称为函数文档，它的功能与代码注释是一样的。

函数的文档字符串可以通过特殊属性 _ _doc_ _ 获取，可以通过 help()函数来查看函数的文档：

1
2
3
4
5
6
7
8
9
10
11

print(func.__doc__) 
# 打印：
# 函数文档

help(func)

# 打印：
#Help on function func in module __main__:
#
#func(i)
#    函数文档

2 关键字参数和默认参数

位置参数、关键字参数

• 在调用函数的时候，位置参数必须在关键字参数的前面

  1 2 3 4 5 6 7 8

  def test(num1, num2): print(num1 + "大于" + num2) test("1", "2") #位置参数，实参和形参位置一一对应 test(num2='2', num1='1') #关键字参数，传入实参时明确指定形参的变量名，其特点就是参数之间不存在先后顺序 #打印结果都为 #1大于2

默认参数：在定义函数时就给到的参数

• 在定义函数的时候，位置参数必须在默认参数的前面

  1 2 3 4

  >>> def SaySome(name = "你好世界", words = "让编程改变世界！"): print(name + '-->' + words) >>> SaySome() #你好世界-->让编程改变世界！

收集参数（可变参数）：实参个数不确定，在参数前加 *

1
2
3
4
5
6

>>> def test(*params):
		print('参数的长度是：', len(params))
		print('第二个参数是：', params[1])
>>> test(1, 'Percy', 9.99, 7, 5)
#参数的长度是： 5
#第二个参数是： Percy

• 收集参数前面的星号 * 起到的作用称为“打包”操作，通俗的理解就是将多个参数打包成一个元组的形式进行存储。
• 两个星号 ** 的收集参数表示为将参数们打包成字典的形式，传递给函数的任意数量的 key=value 实参会被打包进一个字典中

  1 2 3 4 5 6 7 8

  >>>def test(**params): print("有%d个参数"% len (params)) print("它们分别是: ", params) >>>test(a=1, b=2,c=3, d=4, e=5) 有5个参数 它们分别是:{ 'd': 4, 'e' : 5，'b': 2, 'c': 3, 'a' : 1}

• 如果在收集参数后面还需要指定其他参数，那么在调用函数的时候就应该使用关键参数来指定，否则 Python 就都会把实参都纳入到收集参数中。
• 建议大家如果定义的函数中带有收集参数，那么可以将其他参数设置为默认参数
• 星号 * 和**在形参中的作用是“打包”，而在实参中的作用则相反，起到“解包”的作用。“解包”操作也适用于其他的序列类型。

  1 2 3 4 5 6 7 8 9 10 11 12 13

  num = (1, 2, 3, 4, 5) print(num) print(*num) #(1, 2, 3, 4, 5) #1 2 3 4 5 >>>def test(**params): print("有%d个参数"% len (params)) print("它们分别是: ", params) >>> a = {"one":1, "two":2, "three":3} >>> test(**a) 有 3 个参数 它们分别是： {'three': 3, 'one': 1, 'two': 2}

3 函数和过程

函数（function）：有返回值
过程（procedure）：是简单、特殊并且没有返回值的

python 只有函数，没有过程。

4 作用域

global 关键字

Python使用屏蔽的手段对全局变量进行“保护”：一旦函数内部试图直接修改全局变量，Python 就会在函数内部创建一个名字一模一样的局部变量代替，这样修改的结果只会影响到局部变量，而全局变量则丝毫不变。

1
2
3
4
5
6
7
8

>>>count =5
>>>def myFun():
    count =10
    print (count)
>>>myFun ( )
10
>>>count
5

某些时候我们需要在函数内部改变全局变量：在函数内使用 global 关键字，可以将函数内的局部变量变为全局变量

1
2
3
4
5
6
7
8

>>>count =5
>>>def myFun():
    global count = 10
    print (count)
>>>myFun()
10
>>>count
10

内嵌函数

Python的函数定义是支持嵌套的，也就是允许在函数内部定义另一个函数，这种函数称为内嵌函数或者内部函数。

1
2
3
4
5
6

def function1():
	print('function1()被调用')
	def function2():
		print('function2()被调用')
	function2()
	return

注意：

• 内部函数function2()整个作用域都在外部函数function1()之内。
• 只能在function1()中调用function2()，在function1()之外，不能调用function2()。
• 在嵌套函数中，内部函数可以引用外部函数的局部变量：

[!NOTE] LEGB 原则
名字一样、作用域不同的变量引用，Python 引入了 LEGB 原则进行规范，变量的查找顺序依次就是 L→E→G→B：
•　L-Local：函数内的名字空间。
•　E-Enclosing function locals：嵌套函数中外部函数的名字空间。
•　G-Global：函数定义所在模块的名字空间。
•　B-Builtin：Python内置模块的名字空间。

闭包

Python中的闭包从表现形式上定义为：如果在一个内部函数里对外部作用域（但不是在全局作用域）的变量进行引用（简言之：就是在嵌套函数的环境下，内部函数引用了外部函数的局部变量），那么内部函数就会被认为是闭包。

1
2
3
4
5
6
7
8

>>>def funx(x):
	  def funY(y):
		  return x * y
    return funY
    
>>>temp =funx(8)
>>>temp (5)
40

• 不能在外部函数以外的地方对内部函数进行调用
• 在闭包中，外部函数的局部变量对应内部函数的局部变量，事实上相当于之前讲的全局变量与局部变量的对应关系，在内部函数中，只能对外部函数的局部变量进行访问，但不能进行修改。
• 闭包概念的引入是为了尽可能地避免使用全局变量，闭包允许将函数与其所操作的某些数据（环境）关联起来，这样外部函数就为内部函数构成了一个封闭的环境。

nonlocal 关键字：表明这不是一个局部变量，使用方式与 global 一样：

1
2
3
4
5
6
7
8
9
10

>>>def funX():
   x = 5
   def funY()∶
       nonlocal x
       x = x + 1
       return x
    return funY
>>>temp = funx()
>>>temp ()
6

装饰器 decorator

[!NOTE] 语法糖（Syntactic sugar）
语法糖（Syntactic sugar），就是在计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。

装饰器（decorator）的功能：将被装饰的函数当作参数传递给与装饰器对应的函数（名称相同的函数），并返回包装后的被装饰的函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

def log(func):  
    def wrapper():  
        print("开始调用eat()函数...")  
        func()  
        print("结束调用eat()函数...")  
    return wrapper  
  
  
def eat():  
    print("开始吃了")  
  
eat = log(eat)
eat()

#开始调用eat()函数...
#开始吃了
#结束调用eat()函数...

这个 eat = log(eat)看着总有些别扭，能不能改善一下呢？Python 因此发明了“@语法糖”来解决这个问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def log(func):  
		def wrapper():  
			print("开始调用eat()函数...")  
			func()  
			print("结束调用eat()函数...")  
		return wrapper  
  
@log
def eat():  
    print("开始吃了")  

eat()

#开始调用eat()函数...
#开始吃了
#结束调用eat()函数...

这样就省去了手动将 eat()函数传递给 log()再将返回值重新赋值的步骤。

5 函数式编程

lambda 表达式

普通形式的函数：

1
2
3
4

>>> def ds(x):
	   return 2* ×+1
>>>ds(5)
11

运用 lambda 关键字，创建匿名函数
基本语法是使用冒号（:）分隔函数的参数及返回值：冒号的左边放置函数的参数，如果有多个参数，使用逗号（,）分隔即可；冒号右边是函数的返回值。

1
2

g = lambda x : 2 * x + 1
g(5)

lambda 表达式的作用：

1. Python 写一些执行脚本时，使用 lambda 就可以省下定义函数过程，lambda 使代码更加精简。
2. 对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数，使用lambda不需要考虑命名问题。
3. 简化代码的可读性。

filter() 过滤器

filter()函数是一个过滤器，它的作用就是在海量的数据里面提取出有用的信息。

filter(function or None, iterable) --> filter object

filter() 这个内置函数有两个参数：第一个参数可以是一个函数也可以是 None

• 如果是一个函数的话，则将第二个可迭代对象里的每一个元素作为函数的参数进行计算，把返回 True 的值筛选出来；
• 如果为 None，则直接将第二个参数中为 True 的值筛选出来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#第一个参数是None
>>> list(filter(None, [1, 0, False, True]))
[1, True]

##第一个参数是函数
>>> def odd(x):
	return x % 2

>>> temp = range(10)
>>> show = filter(odd, temp)
>>> list(show)
[1, 3, 5, 7, 9]

#结合`lambda`关键字，修改代码
>>> list(filter(lambda x : x % 2, range(10)))
[1, 3, 5, 7, 9]

map() 映射

map(func, *iterables) --> map object

map()这个内置函数有两个参数，一个函数和一个可迭代对象，将可迭代对象的每一个元素作为函数的参数进行运算加工，直到可迭代序列每个元素都加工完毕，返回所有加工后的元素构成的新序列。

1
2

>>> list(map(lambda x : x * 2, range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

map()的第二个参数是收集参数，支持多个可迭代对象。map()会从所有可迭代对象中依次取一个元素组成一个元组，然后将元组传递给 func。注意：如果可迭代对象的长度不一致，则以较短的迭代结束为止。

1
2

>>> list(map(lambda x, y : x + y, [1, 3, 5], [10, 30, 50, 66, 88]))
[11, 33, 55]

6 递归

Python 3出于“善意的保护”，对递归深度默认是有限制的，自行设置递归的深度限制方法如下：

1
2

>>> import sys
>>> sys.setrecursionlimit(10000)  # 将递归深度限制设置为一万层

符合以下两个条件：

1. 有调用函数自身的行为
2. 有一个正确的返回条件（停止的条件）

eg：求 n 的阶乘

1
2
3
4
5
6
7
8

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n - 1)

num = int(input('请输入一个正整数：'))
print(num, '的阶乘是：', factorial(num))

运行：

1
2

请输入一个正整数：5
5 的阶乘是： 120

eg：斐波那契数列
①运用迭代

1
2
3
4
5
6
7
8

>>> def fab1(n):
	a = [1, 1]
	for i in range(n - 2):
		result = a[i] + a[i + 1]
		a.append(result)
	print(a.pop())

>>> fab1(12)

②运用递归

1
2
3
4
5
6
7
8
9
10
11

>>> def fab2(n):
	if n < 1:
		return 0
	elif n == 1:
		return 1
	elif n == 2:
		return 1
	else:
		return fab2(n - 1) + fab2(n - 2)

>>> fab2(12)

递归所占内存空间大，运算慢

四、字典/集合

1 字典（dict）

Python的字典又称哈希（hash）、关系数组

字典是Python中唯一的映射类型
映射类型区别于序列类型，序列类型以数组的形式存储，通过索引的方式来获取相应位置的值，一般索引值与对应位置存储的数据是毫无关系的。

创造和访问字典

• 关键符号：{}
• 由“键”和“值”共同构成，每一对键值组合称为“项”，中间由:连接。
• 字典的键必须独一无二（如果同一个键被赋值两次，后一个值会覆盖前面的值），但值则不必。值可以取任何数据类型，但必须是不可变的，如字符串、数或元组（列表不可以）。
• 访问字典里的值与访问序列类似，只需要把相应的键放入方括号即可。
• 有别于序列，字典不支持拼接（+）和重复（*）操作

1. 要声明一个空字典，直接用大括号即可：

   1 2 3

   >>> dict1 = {'李宁':'一切皆有可能', '耐克':'Just do it', '鱼C工作室':'让编程改变世界'} >>> print('鱼C工作室的口号是：', dict1['鱼C工作室']) 鱼C工作室的口号是： 让编程改变世界

2. 也可以使用 dict() 内置函数来创建字典：
   使用很多小括号的原因是 dict()函数的参数可以是一个序列（但不能是多个），所以要打包成一个元组（或列表）序列。

   1 2 3

   >>> dict1 = dict((('F', 70), ('i', 105), ('s', 115), ('h', 104), ('C', 67))) >>> dict1 {'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67}

3. 还可以通过提供具有映射关系的参数来创建字典

   1 2 3

   >>> dict1 = dict(F=70, i=105, s=115, h=104, C=67) >>> dict1 {'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67}

4. 还有一种创建方法是直接给字典的键赋值，如果键已存在，则改写键对应的值；如果键不存在，则创建一个新的键并赋值：

   1 2 3 4 5

   >>> dict1 {'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67} >>> dict1['x'] = 88 >>> dict1 {'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67, 'x': 88}

1
2
3
4
5
6

# 以下方法创建相同的字典
>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})

字典方法

创建字典

**fromkeys(seq[, value])**：创建并返回一个新的字典，它有两个参数；第一个参数是字典的键；第二个参数是可选的，是传入键对应的值，如果不提供，那么默认是None。

1
2
3
4
5
6
7
8
9
10
11
12

>>> dict1 = {}
>>> dict1.fromkeys((1, 2, 3))
{1: None, 2: None, 3: None}

>>> dict2 = {}
>>> dict2.fromkeys((1, 2, 3), 'Number')
{1: 'Number', 2: 'Number', 3: 'Number'}

>>> dict3 = {}
>>> dict3.fromkeys((1, 2, 3), ("one", "two", "three"))
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two',
'three')}

访问字典

**keys()**：返回字典中的键
**values()**：返回字典中所有的值
**items()**：返回字典中所有的键值对（也就是项）
**get(key[, default])**：提供了更宽松的方式去访问字典项，当键不存在的时候，get()方法并不会报错，只是默默地返回了一个 None，表示啥都没找到。如果希望找不到数据时返回指定的值，那么可以在第二个参数设置对应的默认返回值：
**setdefault(key[, default])**：与 get() 类似，但在字典中找不到相应的键时会自动添加键值对，默认值是 None，可以设置第二个参数。

1
2
3
4
5
6
7
8
9
10
11
12
13

dict1 = {"James": "小前锋", "Kobe": "得分后卫", "Yaoming": "中锋"}  
print(dict1.keys())  
print(dict1.values())  
print(dict1.items())  
print(dict1.get("James"))  
print(dict1.get("Durant")) # 键不存在返回None

#返回
#dict_keys(['James', 'Kobe', 'Yaoming'])
#dict_values(['小前锋', '得分后卫', '中锋'])
#dict_items([('James', '小前锋'), ('Kobe', '得分后卫'), ('Yaoming', '中锋')])
#小前锋
#None

如果不知道一个键是否在字典中，可以用成员资格操作符来判断。（in 和 not in）

1
2
3
4

>>> 3 in dict1
True
>>> 4 in dict2
False

其他操作

**clear()**：清空字典
**copy()**：浅拷贝整个字典
**pop(key[, default])**：给定键，弹出对应的值
**popitem()**：弹出一项（键和值） 字典没有一定的顺序，可以理解为随机弹出
**update()**：更新，可以修改值

1
2
3
4

>>> pets = {"米奇":"老鼠", "汤姆":"猫", "小白":"猪"}
>>> pets.update(小白="狗")
>>> pets
{'米奇': '老鼠', '汤姆': '猫', '小白': '狗'}

2 集合（set）

集合里的元素具有唯一性，自动清除重复的数据
集合是无序的

创建和访问集合

（1）创建：

1. 直接把一堆元素用 “{}” 括起来
   在Python 3里，如果用大括号括起一堆数字但没有体现出映射关系，那么Python就会认为这堆数据是一个集合而不是映射。

   1 2 3

   >>> num = {1, 2, 3, 4, 4, 5, 5} >>> num {1, 2, 3, 4, 5}

2. 使用 set() 工厂函数

1
2
3

>>> set1 = set([1, 3, 5, 7, 9])
>>> set1
{1, 3, 5, 7, 9}

（2）访问集合中的值：
可以使用for把集合中的数据一个个读取出来
可以通过in和not in判断一个元素是否在集合中已经存在

集合方法

add() 可以为集合添加元素
remove() 可以删除集合中已知的元素：

1
2
3
4
5
6
7
8

>>> num
{1, 2, 3, 4, 5}
>>> num.add(6)
>>> num
{1, 2, 3, 4, 5, 6}
>>> num.remove(5)
>>> num
{1, 2, 3, 4, 6}

不可变集合

有时候希望集合中的数据具有稳定性，也就是说，像元组一样，不能随意地增加或删除集合中的元素。那么可以定义成不可变集合，这里使用的是frozenset()函数，就是把元素给 frozen（冰冻）起来：

**frozenset()**：创建一个不可变集合

1
2
3
4
5
6

>>> num2 = frozenset([1, 2, 3, 4, 5])
>>> num2.add(0)
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    num2.add(0)
AttributeError: 'frozenset' object has no attribute 'add'

五、文件操作

打开文件

使用 open()这个内置函数来打开文件并返回文件对象

1

open(file, mode = 'r', buffering = -1, encoding = None, errors = None, newline = None, closefd=True, opener=None)

第一个参数是传入的文件名，如果只有文件名，不带路径的话，那么 Python 会在当前文件夹中去找到该文件并打开；
第二个参数指定文件打开模式

注意：需要写入文件，请确保之前的打开模式有’w’或’a’，’w’模式写入文件，此前的文件内容会被全部删除，如果要在原来的内容上追加，一定要使用’a’模式打开文件。

文件对象的方法

打开文件并取得文件对象之后，就可以利用文件对象的一些方法对文件进行读取、修改等操作。

Python 拥有垃圾收集机制，会在文件对象的引用计数降至零的时候自动关闭文件，所以在 Python 编程里，如果忘记关闭文件并不会造成内存泄漏那么危险的结果。
但并不是说就可以不要关闭文件，如果对文件进行了写入操作，那么应该在完成写入之后关闭文件。因为 Python 可能会缓存写入的数据，如果中途发生类似断电之类的事故，那些缓存的数据根本就不会写入到文件中。所以，为了安全起见，要养成使用完文件后立刻关闭的好习惯。
read() 是以字节为单位读取，如果不设置参数，那么会全部读取出来，文件指针指向文件末尾。
tell() 方法可以告诉你当前文件指针的位置：
seek()方法可以调整文件指针的位置。
readline() 方法用于在文件中读取一整行，就是从文件指针的位置向后读取，直到遇到换行符（\n）结束：

从一个文件里读取字符串非常简单，但如果想要读取出数值，那就需要多费点儿周折。因为无论是 read() 方法还是 readline() 方法，都是返回一个字符串，如果希望从字符串里提取出数值，可以使用 int() 函数或 float() 函数把类似’123’或’3.14’这类字符串强制转换为具体的数值。

将文件存入列表 list：

1
2
3

f = open(r"C:\Users\22625\Desktop\test.txt")  #内容为123
print(list(f))
#打印： ['123']

读取文本文件中的每一行： 文件对象自身支持迭代，直接使用 for 语句把内容迭代读取出来即可：

1
2
3
4

>>> f.seek (0,o)0
>>>for each_line in f:
print(each_line)

OS/OS. path 模块

模块是就是我们的源代码文件，其后缀名是.py。
模块可以被别的程序引入，以使用该模块中的函数等功能。
使用import 语句导入模块

1
2
3

>>> import random
>>> random.randint(0, 9)
3

OS：Operating System 操作系统

对于文件系统的访问，Python 一般是通过 OS 模块来实现的。Python 是跨平台的语言，也就是说，同样的源代码在不同的操作系统不需要修改就可以同样实现。有了 OS 模块，不需要关心什么操作系统下使用什么模块，OS 模块会帮你选择正确的模块并调用。

OS模块中关于文件／目录常用的函数使用方法

OS. path 模块中关于路径常用的函数使用方法

pickle 模块

pickle 翻译为泡菜

pickle 模块就可以非常容易地将列表、字典这类复杂数据类型存储为文件。它几乎可以把所有 Python 的对象都转化为二进制的形式存放，这个过程称为pickling（打包，存入），那么从二进制形式转换回对象的过程称为unpickling（打开包裹，读取）。

pickling

1
2
3
4
5

>>> import pickle								# 导入
>>> my_list = [123, 3.14, 'Percy', ['another list']]
>>> pickle_file = open('my_list.pkl', 'wb')			# 创建并打开文件
>>> pickle.dump(my_list, pickle_file)				# 把数据导入文件
>>> pickle_file.close()							# 关闭文件

这里希望把这个列表永久保存起来（保存成文件），打开的文件一定要以二进制的形式打开，后缀名倒是可以随意，不过既然是使用 pickle 保存，为了今后容易记忆，建议还是使用.pkl 或.pickle。
使用 dump 方法来保存数据，完成后记得保存，与操作普通文本文件一样。

程序执行之后 E 盘会出现一个 my_list.pkl 文件，用记事本打开之后显示乱码（因为它保存的是二进制形式）

unpickling

使用的时候只需用二进制模式先把文件打开，然后用load()把数据加载进来：

1
2
3
4

>>> pickle_file = open('my_list.pkl', 'rb')			# 打开文件
>>> my_list2 = pickle.load(pickle_file)				# 加载文件中的数据
>>> my_list2
[123, 3.14, 'Percy', ['another list']]

利用pickle模块，不仅可以保存列表，事实上pickle还可以保存任何你能想象得到的东西。

六、异常处理

1 标准异常总结

2 内置异常类的层次结构

BaseException
+– SystemExit
+– KeyboardInterrupt
+– GeneratorExit
+– Exception
      +– StopIteration
      +– ArithmeticError
      |    +– FloatingPointError
      |    +– OverflowError
      |    +– ZeroDivisionError
      +– AssertionError
      +– AttributeError
      +– BufferError
      +– EOFError
      +– ImportError
      +– LookupError
      |    +– IndexError
      |    +– KeyError
      +– MemoryError
      +– NameError
      |    +– UnboundLocalError
      +– OSError
      |    +– BlockingIOError
      |    +– ChildProcessError
      |    +– ConnectionError
      |    |    +– BrokenPipeError
      |    |    +– ConnectionAbortedError
      |    |    +– ConnectionRefusedError
      |    |    +– ConnectionResetError
      |    +– FileExistsError
      |    +– FileNotFoundError
      |    +– InterruptedError
      |    +– IsADirectoryError
      |    +– NotADirectoryError
      |    +– PermissionError
      |    +– ProcessLookupError
      |    +– TimeoutError
      +– ReferenceError
      +– RuntimeError
      |    +– NotImplementedError
      +– SyntaxError
      |    +– IndentationError
      |         +– TabError
      +– SystemError
      +– TypeError
      +– ValueError
      |    +– UnicodeError
      |         +– UnicodeDecodeError
      |         +– UnicodeEncodeError
      |         +– UnicodeTranslateError
      +– Warning
           +– DeprecationWarning
           +– PendingDeprecationWarning
           +– RuntimeWarning
           +– SyntaxWarning
           +– UserWarning
           +– FutureWarning
           +– ImportWarning
           +– UnicodeWarning
           +– BytesWarning
           +– ResourceWarning

3 异常捕获 try 语句

可以通过捕获这些异常，并纠正这些错误。
异常捕获可以使用 try 语句来实现，任何出现在 try 语句范围内的异常都会被及时捕获到。try 语句有两种实现形式：一种是 try-except；另一种是 try-finally。

注意：try 语句检测范围一旦出现异常，剩下的语句将不会被执行！

try-except语句

语法结构如下：

1
2
3
4

try:
		检测范围
except Exception[as reason]:  #[as reason]是可选项
		出现异常（Exception）后处理代码

1
2
3
4
5
6
7
8
9
10

f = open('我为什么是一个文档.txt')
     print(f.read())
     f.close()
     
# 如果该文档不存在就会报错：
Traceback (most recent call last):
  File "C:\Users\22625\Desktop\LearnPython\1.py", line 1, in <module>
    f = open('我为什么是一个文档.txt')
        ^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: '我为什么是一个文档.txt'

显然这样的用户体验不好，因此可以这么修改：

1
2
3
4
5
6
7
8
9

try:  
		f = open('我为什么是一个文档.txt')  
		print(f.read())  
		f.close()  
except OSError:  
		print('文件打开的过程中出错啦T_T')

#如果该文档不存在就会报错：
文件打开的过程中出错啦T_T

从程序员的角度来看，导致 OSError 异常的原因有很多（如 FileExistsError、FileNotFoundError、PermissionError 等），所以可能会更在意错误的具体内容，这里可以使用 as 把具体的错误信息给打印出来：

1
2
3
4
5
6
7
8
9

try:  
		f = open('我为什么是一个文档.txt')  
		print(f.read())  
		f.close()  
except OSError as reason:  
		print('文件打开的过程中出错的原因是：'+str(reason))
		
#如果该文档不存在就会报错：
文件打开的过程中出错的原因是：[Errno 2] No such file or directory: '我为什么是一个文档.txt'

针对不同异常设置多个except

一个try语句可以和多个except语句搭配，分别对感兴趣的异常进行检测处理：

1
2
3
4
5
6
7
8

try:  
		f = open('我是一个不存在的文档.txt')  
		print(f.read())  
		f.close()  
except OSError as reason:  
		print('文件出错啦T_T\n错误原因是:' + str(reason))  
except TypeError as reason:  
		print('类型出错啦T_T\n错误原因是:' + str(reason))

对多个异常统一处理

except后面还可以跟着多个异常，然后对这些异常进行统一的处理：

1
2
3
4
5
6
7

try:
	    sum = 1 + '1'
	    f = open('文件1.txt')
	    print(f.read())
	    f.close()
except (OSError, TypeError):
		print('出错啦！！')

捕获所有异常

如果无法确定要对哪一类异常进行处理，只是希望在 try 语句块里一旦出现任何异常，可以给用户一个“看得懂”的提醒，那么可以这么做：

1
2
3
4
5
6

try:  
		f = open('我是一个不存在的文档.txt')  
		print(f.read())  
		f.close()  
except:  
		print('出错啦!')

不过通常不建议这么做，因为它会隐藏所有程序员未想到并且未做好处理准备的错误，例如，当用户通过 Ctrl+C 快捷键强制终止程序，却会被解释为 KeyboardInterrupt 异常。

try-finally 语句

语法结构如下：

1
2
3
4
5
6

try:
	检测范围
except Exception[as reason]:
	出现异常（Exception）后处理代码
finally:
	无论如何都会被执行的代码

如果确实存在一个名为“我是一个不存在的文档.txt”的文件，open() 函数正常返回文件对象，但异常却发生在成功打开文件后的 sum = 1 + '1' 语句上。此时 Python 将直接跳到 except 语句，也就是说，文件打开了，但关闭文件的命令却被跳过了。

1
2
3
4
5
6
7

try:  
		f = open('我是一个不存在的文档.txt')  
		print(f.read()) 
		sum = 1 + '1' 
		f.close()  
except:  
		print('出错啦!')

为了实现像这种“就算出现异常，但也不得不执行的收尾工作（如在程序崩溃前保存用户文档）”，引入了 finally 来扩展 try：

1
2
3
4
5
6
7
8

try:
    f = open('文件1.txt', 'w')
    print(f.read())
    sum = 1 + '1'
except:
    print('出错啦!')
finally:
	   f.close()

如果try语句块中没有出现任何运行时错误，会跳过except语句块执行finally语句块的内容。如果出现异常，则会先执行except语句块的内容再执行finally语句块的内容。总之，finally语句块中的内容就是确保无论如何都将被执行的内容。

4 抛出异常 raise 语句

自己抛出一个异常，抛出的异常还可以带参数，表示异常的解释：
raise语句

1
2
3
4
5

>>> raise ZeroDivisionError('除数为零的异常')
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    raise ZeroDivisionError('除数为零的异常')
ZeroDivisionError: 除数为零的异常

5 else 语句

else 语句还能够与异常处理进行搭配，实现方法与循环语句搭配差不多：只要try语句块里没有出现任何异常，那么就会执行else语句块里的内容。

1
2
3
4
5
6

try:
    print(int('123'))
except ValueError as reason:
    print('出错啦！')
else:
    print('没有任何异常')

6 with 语句

即要打开文件又要关闭文件，还要关注异常处理，有点烦琐，所以 Python 提供了一个 with 语句，利用这个语句抽象出文件操作中频繁使用的 try/except/finally 相关的细节。对文件操作使用 with 语句，将大大减少代码量，而且再也不用担心出现文件打开了忘记关闭的问题了（with 会自动帮助关闭文件）。

1
2
3
4
5
6

try:
    with open('文件1.txt', 'w') as f: 
        for each_line in f:
            print(each_line)
except OSError as reason:
    print('出错啦！！', reason)

有了with语句，就再也不用担心忘记关闭文件了。

七、类和对象

对象 = 属性 + 方法

定义一个类：class关键字
Python 中的类名约定以大写字母开头, 函数用小写字母开头。

面向对象的特征（Object Oriented）：
a. 封装：信息隐蔽技术
b. 继承：子类自动共享父类之间数据和方法的机制
c. 多态：不同对象对同一方法响应不同的行动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Turtle:  
		# Python中的类名约定以大写字母开头  
		# 特征的描述称为属性，在代码层面来看其实就是变量
		color = 'green'  
		weight = 10  
		legs = 4  
		
		# 方法实际就是函数，通过调用这些函数来完成某些工作  
		def climb(self):  
			print("我正在很努力的向前爬...")  
  
		def run(self):  
			print("我正在飞快的向前跑...")  

#类的实例化
tt = Turble()

##调用方法
tt.climb()
我正在很努力的向前爬...

1 面向对象编程

**（1）self**：Python 的 self 相当于 C++ 的this指针

由同一个类可以生成无数个对象，这些对象长得都很相似，因为他们都是来源于同一个类的属性和方法，当一个对象的方法被调用的时候，对象会将自身作为第一个参数传给 self 参数，接收到 self 的时候，Python 就知道是哪一个对象在调用方法了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

>>> class Ball:
    def setName(self, name):
        self.name = name
    def talk(self):
        print('我是%s' % self.name)
            
>>> a = Ball()
>>> a.setName('足球')
>>> b = Ball()
>>> b.setName('篮球')
>>> a.talk()
我是足球
>>> b.talk()
我是篮球

**（2）构造函数 __init__()

通常把 __init__() 方法称为构造函数，__init__() 方法的魔力体现在只要实例化一个对象，这个方法就会在对象被创建时自动调用（在 C++里也可以看到类似的东西，叫“构造函数”）。
其实，实例化对象时是可以传入参数的，这些参数会自动传入__init__()方法中，可以通过重写这个方法来自定义对象的初始化操作。

1
2

__init__(self)
__init__(self, param1, param2...)

1
2
3
4
5
6
7
8
9