面向对象程序设计
面向对象编程（Object-oriented Programming，简称OOP），是一种封装代码的方法。
面向对象中，常用术语包括：
- 类：可以理解是一个模板，通过它可以创建出无数个具体实例。比如，前面编写的 tortoise 表示的只是乌龟这个物种，通过它可以创建出无数个实例来代表各种不同特征的乌龟（这一过程又称为类的实例化）。
- 对象：类并不能直接使用，通过类创建出的实例（又称对象）才能使用。这有点像汽车图纸和汽车的关系，图纸本身（类）并不能为人们使用，通过图纸创建出的一辆辆车（对象）才能使用。
- 属性：类中的所有变量称为属性。例如，
tortoise这个类中，bodyColor、footNum、weight、hasShell都是这个类拥有的属性。 - 方法：类中的所有函数通常称为方法。不过，和函数所有不同的是，类方法至少要包含一个
self参数（后续会做详细介绍）。例如，tortoise类中，crawl()、eat()、sleep()、protect()都是这个类所拥有的方法，类方法无法单独使用，只能和类的对象一起使用
定义类
Python中使用类的顺序是：先创建（定义）类，然后再创建类的实例对象，通过实例对象实现特定的功能。
Python中，创建一个类使用 class关键字实现，其基本语法格式如下：
class 类名：
零个到多个类属性...
零个到多个类方法...
从上面定义来看，Python的类定义有点像函数定义，都是以 冒号（:） 作为类体的开始，以统一缩进的部分作为类体的。区别只是函数定义使用def关键字，而类定义则使用 class关键字。
class Person :
'''这是一个学习Python定义的一个Person类'''
# 下面定义了一个类属性
hair = 'black'
# 下面定义了一个say方法
def say(self, content):
print(content)
__init__()类构造方法
在创建类时，我们可以手动添加一个 __init__()方法，该方法是一个特殊的类实例方法，称为构造方法（或构造函数）。构造方法用于创建对象时使用，每当创建一个类的实例对象时，Python 解释器都会自动调用它。
def __init__(self,...):
代码块
此方法的方法名中，开头和结尾各有2个下划线，且中间不能有空格。
__init__()方法可以包含多个参数，但必须包含一个名为self的参数，且必须作为第一个参数。也就是说，类的构造方法最少也要有一个self参数。
class Person :
'''这是一个学习Python定义的一个Person类'''
def __init__(self):
print("调用构造方法")
zhangsan = Person()
"""运行结果
调用构造方法
"""
class Person :
'''这是一个学习Python定义的一个Person类'''
def __init__(self,name,age):
print("这个人的名字是：",name," 年龄为：",age)
#创建 zhangsan 对象，并传递参数给构造函数
zhangsan = Person("张三",20)
"""运行结果
这个人的名字是： 张三 年龄为： 20
"""
类对象的创建和使用
创建类对象的过程又称为类的实例化。
对已创建的类进行实例化，其语法格式如下：
类名(参数)
当创建类时，若没有显式创建__init()__构造方法或者该构造方法中只有一个self参数，则创建类对象时的参数可以省略不写
class Person :
'''这是一个学习Python定义的一个Person类'''
# 下面定义了2个类变量
name = "zhangsan"
age = "20"
def __init__(self,name,age):
#下面定义 2 个实例变量
self.name = name
self.age = age
print("这个人的名字是：",name," 年龄为：",age)
# 下面定义了一个say实例方法
def say(self, content):
print(content)
# 将该Person对象赋给p变量
p = Person("张三",20)
类对象的使用
创建对象之后，接下来即可使用该对象了。Python的对象大致有以下作用：
- 操作对象的实例变量，包括访问、修改实例变量的值、以及给对象添加或删除实例变量）。
- 调用对象的方法，包括调用对象的方法，已经给对象动态添加方法。
类对象访问变量或方法
格式如下：
对象名.变量名 # 使用已创建好的类对象访问类中实例变量
对象名.方法名(参数) # 使用类对象调用类中方法
对象名和变量名以及方法名之间用点"."连接。
# 输出p的name、age实例变量
print(p.name, p.age)
# 访问p的name实例变量，直接为该实例变量赋值
p.name = '李刚'
# 调用p的say()方法，声明say()方法时定义了2个形参，但第一个形参（self）不需要传值，因此调用该方法只需为第二个形参指定一个值
p.say('Python语言很简单，学习很容易！')
# 再次输出p的name、age实例变量
print(p.name, p.age)
"""运行结果
这个人的名字是： 张三 年龄为： 20
张三 20
Python语言很简单，学习很容易！
李刚 20
"""
给类对象动态添加变量
Python支持为已创建好的对象动态增加实例变量，方法也很简单，只要为它的新变量赋值即可。
# 为p对象增加一个skills实例变量
p.skills = ['programming', 'swimming']
print(p.skills)
"""
['programming', 'swimming']
"""
# 删除p对象的name实例变量
del p.name
# 再次访问p的name实例变量
print(p.name) # 'Person' object has no attribute 'name'
给类对象动态添加方法
Python也允许为对象动态增加方法。比如上面程序中在定义Person类时只定义了一个say()方法，但程序完全可以为 p 对象动态增加方法。
但需要说明的是，为p对象动态增加的方法，Python不会自动将调用者自动绑定到第一个参数（即使将第一个参数命名为self也没用）。例如如下代码：
# 先定义一个函数
def info(self):
print("---info函数---", self)
# 使用info对p的foo方法赋值（动态绑定方法）
p.foo = info
# Python不会自动将调用者绑定到第一个参数，
# 因此程序需要手动将调用者绑定为第一个参数
p.foo(p) # ①
# 使用lambda表达式为p对象的bar方法赋值（动态绑定方法）
p.bar = lambda self: print('--lambda表达式--', self)
p.bar(p) # ②
上面的第 5 行和第 11 行代码分别使用函数、lambda表达式为 p 对象动态增加了方法，但对于动态增加的方法，Python不会自动将方法调用者绑定到它们的第一个参数，因此程序必须手动为第一个参数传入参数值，如上面程序中①号、②号代码所示。
self用法
同一个类可以产生多个对象，当某个对象调用类方法时，该对象会把自身的引用作为第一个参数自动传给该方法，换句话说，Python会自动绑定类方法的第一个参数指向调用该方法的对象。如此，Python解释器就能知道到底要操作哪个对象的方法了。
对于构造方法来说，self参数（第一个参数）代表该构造方法正在初始化的对象。
class Dog:
def __init__(self):
print(self,"在调用构造方法")
# 定义一个jump()方法
def jump(self):
print(self,"正在执行jump方法")
# 定义一个run()方法，run()方法需要借助jump()方法
def run(self):
print(self,"正在执行run方法")
# 使用self参数引用调用run()方法的对象
self.jump()
dog1 = Dog()
dog1.run()
dog2 = Dog()
dog2.run()
上面代码中，jump()和run() 中的self代表该方法的调用者，即谁在调用该方法，那么 self就代表谁，因此，该程序的运行结果为：
<__main__.Dog object at 0x00000276B14B12B0> 在调用构造方法
<__main__.Dog object at 0x00000276B14B12B0> 正在执行run方法
<__main__.Dog object at 0x00000276B14B12B0> 正在执行jump方法
<__main__.Dog object at 0x00000276B14B1F28> 在调用构造方法
<__main__.Dog object at 0x00000276B14B1F28> 正在执行run方法
<__main__.Dog object at 0x00000276B14B1F28> 正在执行jump方法
当Python对象的一个方法调用另一个方法时，不可以省略self。
class InConstructor :
def __init__(self) :
# 在构造方法里定义一个foo变量（局部变量）
foo = 0
# 使用self代表该构造方法正在初始化的对象
# 下面的代码将会把该构造方法正在初始化的对象的foo实例变量设为6
self.foo = 6
# 所有使用InConstructor创建的对象的foo实例变量将被设为6
print(InConstructor().foo) # 输出6
在InConstructor的构造方法中，self参数总是引用该构造方法正在初始化的对象。程序中将正在执行初始化的InConstructor对象的foo实例变量设为 6，这意味着该构造方法返回的所有对象的foo实例变量都等于 6。
类变量和实例变量
类变量（类属性）
类变量指的是定义在类中，但在各个类方法外的变量。类变量的特点是：所有类的实例化对象都可以共享类变量的值，即类变量可以在所有实例化对象中作为公用资源。
注意，类变量推荐直接用类名访问，但也可以使用对象名访问。
class Address :
detail = '广州'
post_code = '510660'
def info (self):
# 尝试直接访问类变量
#print(detail) # 报错
# 通过类来访问类变量
print(Address.detail) # 输出 广州
print(Address.post_code) # 输出 510660
#创建 2 个类对象
addr1 = Address()
addr1.info()
addr2 = Address()
addr2.info()
# 修改Address类的类变量
Address.detail = '佛山'
Address.post_code = '460110'
addr1.info()
addr2.info()
"""运算结果
广州
510660
广州
510660
佛山
460110
佛山
460110
"""
在 Python 中，除了可以通过类名访问类属性之外，还可以动态地为类和对象添加类变量。例如，在上面代码的基础，添加以下代码：
Address.depict ="佛山很美"
print(addr1.depict)
print(addr2.depict)
"""
佛山很美
佛山很美
"""
实例变量（实例属性）
实例变量指的是定义在类的方法中的属性，它的特点是：只作用于调用方法的对象。
注意，实例变量只能通过对象名访问，无法通过类名直接访问。
class Inventory:
# 定义两个类变量
item = '鼠标'
quantity = 2000
# 定义实例方法
def change(self, item, quantity):
# 下面赋值语句不是对类变量赋值，而是定义新的实例变量
self.item = item
self.quantity = quantity
# 创建Inventory对象
iv = Inventory()
iv.change('显示器', 500)
# 访问iv的item和quantity实例变量
print(iv.item) # 显示器
print(iv.quantity) # 500
# 访问Inventory的item和quantity类变量
print(Inventory.item) # 鼠标
print(Inventory.quantity) # 2000
实例方法、静态方法和类方法详解
和类属性可细分为类属性和实例属性一样，类中的方法也可以有更细致的划分，具体可分为类方法、实例方法和静态方法。
类实例方法
通常情况下，在类中定义的方法默认都是实例方法。
class Person :
#类构造方法，也属于实例方法
def __init__(self, name = 'Charlie', age=8):
self.name = name
self.age = age
# 下面定义了一个say实例方法
def say(self, content):
print(content)
#创建一个类对象
person = Person()
#类对象调用实例方法
person.say("类对象调用实例方法")
#类名调用实例方法，需手动给 self 参数传值
Person.say(person,"类名调用实例方法")
"""
类对象调用实例方法
类名调用实例方法
"""
类方法
Python类方法和实例方法相似，它最少也要包含一个参数，只不过，类方法中通常将其命名为cls，且Python会自动将类本身绑定给cls参数（而不是类对象）。因此，在调用类方法时，无需显式为cls参数传参。
除此之外，和实例方法最大的不同在于，类方法需要使用＠classmethod进行修饰，例如：
class Bird:
# classmethod修饰的方法是类方法
@classmethod
def fly (cls):
print('类方法fly: ', cls)
注意，如果没有＠classmethod，则Python解释器会将fly()方法认定为实例方法，而不是类方法。
类方法推荐使用类名直接调用，当然也可以使用实例对象来调用（不推荐），例如：
# 调用类方法，Bird类会自动绑定到第一个参数
Bird.fly()
b = Bird()
# 使用对象调用fly()类方法，其实依然还是使用类调用，
# 因此第一个参数依然被自动绑定到Bird类
b.fly()
"""
类方法fly: <class '__main__.Bird'>
类方法fly: <class '__main__.Bird'>
"""
类静态方法
静态方法，其实就是我们学过的函数，和函数唯一的区别是，静态方法定义在类这个空间（类命名空间）中，而函数则定义在程序所在的空间（全局命名空间）中。
静态方法没有类似self、cls这样的特殊参数，因此Python解释器不会对它包含的参数做任何类或对象的绑定，也正是因为如此，此方法中无法调用任何类和对象的属性和方法，静态方法其实和类的关系不大。
静态方法需要使用＠staticmethod修饰，例如：
class Bird:
# staticmethod修饰的方法是静态方法
@staticmethod
def info (p):
print('静态方法info: ', p)
#类名直接调用静态方法
Bird.info("类名")
#类对象调用静态方法
b = Bird()
b.info("类对象")
"""
静态方法info: 类名
静态方法info: 类对象
"""
在使用Python编程时，一般不需要使用类方法或静态方法，程序完全可以使用函数来代替类方法或静态方法。但是在特殊的场景（比如使用工厂模式）下，类方法或静态方法也是不错的选择。
类调用实例方法
使用类调用实例方法，那么该方法的第一个参数（self）怎么自动绑定呢？
class User:
def walk (self):
print(self, '正在慢慢地走')
# 通过类调用实例方法
User.walk()
运行上面代码，程序会报出如下错误：
TypeError: walk() missing 1 required positional argument:'self'
如果程序依然希望使用类来调用实例方法，则必须手动为方法的第一个参数传入参数值。例如，将上面的最后一行代码改为如下形式：
u = User()
# 显式为方法的第一个参数绑定参数值
User.walk(u)
此代码显式地为walk()方法的第一个参数绑定了参数值，这样的调用效果完全等同于执行u.walk()。
描述符
Python中，通过使用描述符，可以让程序员在引用一个对象属性时自定义要完成的工作。
本质上看，描述符就是一个类，只不过它定义了另一个类中属性的访问方式。换句话说，一个类可以将属性管理全权委托给描述符类。
描述符类基于以下 3 个特殊方法，换句话说，这 3 个方法组成了描述符协议：
__set__(self, obj, type=None)：在设置属性时将调用这一方法（后续用setter表示）；__get__(self, obj, value)：在读取属性时将调用这一方法（后续用getter表示）；__delete__(self, obj)：对属性调用del时将调用这一方法。
其中，实现了setter和 getter方法的描述符类被称为数据描述符；反之，如果只实现了getter方法，则称为非数据描述符。
实际上，在每次查找属性时，描述符协议中的方法都由类对象的特殊方法 __getattribute__()调用（注意不要和__getattr__()弄混）。也就是说，每次使用类对象.属性（或者getattr(类对象，属性值)）的调用方式时，都会隐式地调用 __getattribute__()，它会按照下列顺序查找该属性：
- 验证该属性是否为类实例对象的数据描述符；
- 如果不是，就查看该属性是否能在类实例对象的
__dict__中找到； - 最后，查看该属性是否为类实例对象的非数据描述符。
#描述符类
class revealAccess:
def __init__(self, initval = None, name = 'var'):
self.val = initval
self.name = name
def __get__(self, obj, objtype):
print("Retrieving",self.name)
return self.val
def __set__(self, obj, val):
print("updating",self.name)
self.val = val
class myClass:
x = revealAccess(10,'var "x"')
y = 5
m = myClass()
print(m.x)
m.x = 20
print(m.x)
print(m.y)
运行结果为：
Retrieving var "x"
10
updating var "x"
Retrieving var "x"
20
5
从这个例子可以看到，如果一个类的某个属性有数据描述符，那么每次查找这个属性时，都会调用描述符的__get__()方法，并返回它的值；同样，每次在对该属性赋值时，也会调用__set__()方法。
注意，虽然上面例子中没有使用__del__()方法，但也很容易理解，当每次使用del类对象.属性（或者delattr(类对象，属性)）语句时，都会调用该方法。
定义属性
property()函数
在不破坏类封装原则的基础上，为了能够有效操作类中的属性，类中应包含读（或写）类属性的多个getter（或setter）方法，这样就可以通过“类对象.方法(参数)”的方式操作属性，例如：
class Rectangle:
# 定义构造方法
def __init__(self, width, height):
self.width = width
self.height = height
# 定义setsize()函数
def setsize (self , size):
self.width, self.height = size
# 定义getsize()函数
def getsize (self):
return self.width, self.height
# 定义delsize()函数
def delsize (self):
self.width, self.height = 0, 0
rect = Rectangle(3 , 4)
rect.setsize((6,8))
print(rect.getsize()) # (6,8)
Python中提供了 property()函数，可以实现在不破坏类封装原则的前提下，让开发者依旧使用“类对象.属性”的方式操作类中的属性。
property()函数的基本使用格式如下：
属性名=property(fget=None, fset=None, fdel=None, doc=None)
其中，fget参数用于指定获取该属性值的类方法；fset参数用于指定设置该属性值的方法；fdel参数用于指定删除该属性值的方法；最后的doc是一个文档字符串，用于提供说明此函数的作用。
开发者调用property()函数时，可以传入 0 个（既不能读，也不能写的属性）、1 个（只读属性）、2 个（读写属性）、3 个（读写属性，也可删除）和 4 个（读写属性，也可删除，包含文档说明）参数。
例如，对前面的Rectangle类做适当的修改，使用property()函数定义一个size属性：
class Rectangle:
# 定义构造方法
def __init__(self, width, height):
self.width = width
self.height = height
# 定义setsize()函数
def setsize (self , size):
self.width, self.height = size
# 定义getsize()函数
def getsize (self):
return self.width, self.height
# 定义getsize()函数
def delsize (self):
self.width, self.height = 0, 0
# 使用property定义属性
size = property(getsize, setsize, delsize, '用于描述矩形大小的属性')
# 访问size属性的说明文档
print(Rectangle.size.__doc__)
# 通过内置的help()函数查看Rectangle.size的说明文档
help(Rectangle.size)
rect = Rectangle(4, 3)
# 访问rect的size属性
print(rect.size) # (4, 3)
# 对rect的size属性赋值
rect.size = 9, 7
# 访问rect的width、height实例变量
print(rect.width) # 9
print(rect.height) # 7
# 删除rect的size属性
del rect.size
# 访问rect的width、height实例变量
print(rect.width) # 0
print(rect.height) # 0
"""运行结果
用于描述矩形大小的属性
Help on property:
用于描述矩形大小的属性
(4, 3)
9
7
0
0
"""
程序中，使用property()函数定义了一个size属性，在定义该属性时一共传入了 4 个参数，这意味着该属性可读、可写、可删除，也有说明文档。所以，该程序尝试对Rectangle对象的size属性进行读、写、删除操作，其实这种读、写、删除操作分别被委托给getsize()、setsize()和delsize()方法来实现。
@property装饰器
get属性
Python还提供了@property装饰器。通过@property装饰器，可以直接通过方法名来访问方法，不需要在方法名后添加一对“（）”小括号。
@property的语法格式如下：
@property
def 方法名(self)
代码块
例如，定义一个矩形类，并定义用 @property 修饰的方法操作类中的 area 私有属性，代码如下：
class Rect:
def __init__(self,area):
self.__area = area
@property
def area(self):
return self.__area
rect = Rect(30)
#直接通过方法名来访问 area 方法
print("矩形的面积是：",rect.area) # 运行结果为：矩形的面积为： 30
上面程序中，使用＠property修饰了area()方法，这样就使得该方法变成了area属性的getter方法。需要注意的是，如果类中只包含该方法，那么area属性将是一个只读属性。也就是说，在使用Rect类时，无法对area属性重新赋值，即运行如下代码会报错：
rect.area = 90
print("修改后的面积：",rect.area)
"""运行结果
Traceback (most recent call last):
File "C:\Users\mengma\Desktop\1.py", line 10, in <module>
rect.area = 90
AttributeError: can't set attribute
"""
set属性
要想实现修改area属性的值，还需要为area属性添加setter方法，就需要用到setter装饰器，它的语法格式如下：
@方法名.setter
def 方法名(self, value):
代码块
例如，为Rect类中的area方法添加setter方法，代码如下：
@area.setter
def area(self, value):
self.__area = value
rect.area = 90
print("修改后的面积：",rect.area) # 运行结果为： 修改后的面积: 90
del属性
还可以使用deleter装饰器来删除指定属性，其语法格式为：
@方法名.deleter
def 方法名(self):
代码块
例如，在Rect类中，给area()方法添加deleter方法，实现代码如下：
@area.deleter
def area(self):
self.__area = 0
del rect.area
print("删除后的area值为：",rect.area) # 运行结果为： 删除后的area值为： 0
封装机制
封装（Encapsulation）是面向对象的三大特征之一（另外两个是继承和多态），它指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。
封装机制保证了类内部数据结构的完整性，因为使用类的用户无法直接看到类中的数据结构，只能使用类允许公开的数据，很好地避免了外部对内部数据的影响，提高了程序的可维护性。
为了实现良好的封装，需要从以下两个方面来考虑：
- 将对象的属性和实现细节隐藏起来，不允许外部直接访问。
- 把方法暴露出来，让方法来控制对这些属性进行安全的访问和操作。
因此，实际上封装有两个方面的含义：把该隐藏的隐藏起来，把该暴露的暴露出来。
python中，只要将 Python 类的成员命名为以双下画线开头的，Python 就会把它们隐藏起来。
class User :
def __hide(self):
print('示范隐藏的hide方法')
def getname(self):
return self.__name
def setname(self, name):
if len(name) < 3 or len(name) > 8:
raise ValueError('用户名长度必须在3～8之间')
self.__name = name
name = property(getname, setname)
def setage(self, age):
if age < 18 or age > 70:
raise ValueError('用户名年龄必须在18在70之间')
self.__age = age
def getage(self):
return self.__age
age = property(getage, setage)
# 创建User对象
u = User()
# 对name属性赋值，实际上调用setname()方法
u.name = 'fk' # 引发 ValueError: 用户名长度必须在3～8之间
u.name = 'fkit'
u.age = 25
print(u.name) # fkit
print(u.age) # 25
# 尝试调用隐藏的__hide()方法
u.__hide() # AttributeError:'User' object has no attribute 'hide'
上面程序将User的两个实例变量分别命名为 __name 和 __age，这两个实例变量就会被隐藏起来，这样程序就无法直接访问 __name 、__age 变量，只能通过setname()、getname()、setage()、getage()这些访问器方法进行访问，而setname()、setage()会对用户设置的 name、age进行控制，只有符合条件的name、age才允许设置。
Python其实没有真正的隐藏机制，双下画线只是Python的一个小技巧，Python 会“偷偷”地改变以双下画线开头的方法名，会在这些方法名前添加单下画线和类名。因此上面的__hide()方法其实可以按如下方式调用（通常并不推荐这么干）：
# 调用隐藏的__hide()方法
u._User__hide() # 示范隐藏的hide方法
继承机制
继承是面向对象的三大特征之一，也是实现代码复用的重要手段。继承经常用于创建和现有类功能类似的新类，又或是新类只需要在现有类基础上添加一些成员（属性和方法），但又不想直接将现有类代码复制给新类。
Python 中，实现继承的类称为子类，被继承的类称为父类（也可称为基类、超类）。子类继承父类的语法是：在定义子类时，将多个父类放在子类之后的圆括号里。语法格式如下：
class 类名(父类1, 父类2, ...)：
#类定义部分
注意，Python 的继承是多继承机制，即一个子类可以同时拥有多个直接父类。
class Fruit:
def info(self):
print("我是一个水果！重%g克" % self.weight)
class Food:
def taste(self):
print("不同食物的口感不同")
# 定义Apple类，继承了Fruit和Food类
class Apple(Fruit, Food):
pass
# 创建Apple对象
a = Apple()
a.weight = 5.6
# 调用Apple对象的info()方法
a.info()
# 调用Apple对象的taste()方法
a.taste()
"""运行结果
我是一个水果！重5.6克
不同食物的口感不同
"""
子类如何找到父类的属性和方法
方法解析顺序（Method Resolution Order），简称 MRO。对于只支持单继承的编程语言来说，MRO很简单，就是从当前类开始，逐个搜索它的父类；而对于Python，它支持多继承，MRO相对会复杂一些。
Python发展至今，经历了以下 3 种MRO算法，分别是：
- 从左往右，采用深度优先搜索（
DFS）的算法，称为旧式类的MRO； - 自
Python 2.2版本开始，新式类在采用深度优先搜索算法的基础上，对其做了优化； - 自
Python 2.3版本，对新式类采用了C3算法。由于Python 3.x仅支持新式类，所以该版本只使用C3算法。
旧式类MRO算法
class A:
def method(self):
print("CommonA")
class B(A):
pass
class C(A):
def method(self):
print("CommonC")
class D(B, C):
pass
print(D().method())
此程序中的 4 个类是一个“菱形”继承的关系，当使用 D 类对象访问method()方法时，根据深度优先算法，搜索顺序为 D->B->A->C->A。
因此，使用旧式类的MRO算法最先搜索得到的是基类 A 中的method()方法，即在Python 2.x版本中，此程序的运行结果为：
CommonA
但是，这个结果显然不是想要的，我们希望搜索到的是 C 类中的method()方法。
新式类MRO算法
Python 2.2版本推出了新的计算新式类MRO的方法，它仍然采用从左至右的深度优先遍历，但是如果遍历中出现重复的类，只保留最后一个。
仍以上面程序为例，通过深度优先遍历，其搜索顺序为 D->B->A->C->A，由于此顺序中有 2 个 A，因此仅保留后一个，简化后得到最终的搜索顺序为 D->B->C->A。
这种MRO方式已经能够解决“菱形”继承的问题，但是可能会违反单调性原则。所谓单调性原则，是指在类存在多继承时，子类不能改变基类的MRO搜索顺序，否则会导致程序发生异常。
class X(object):
pass
class Y(object):
pass
class A(X,Y):
pass
class B(Y,X):
pass
class C(A, B):
pass
通过进行深度遍历，得到搜索顺序为 C->A->X->object->Y->object->B->Y->object->X->object，再进行简化（相同取后者），得到 C->A->B->Y->X->object。
下面来分析这样的搜索顺序是否合理，我们来看下各个类中的MRO：
- 对于
A，其搜索顺序为A->X->Y->object； - 对于
B，其搜索顺序为B->Y->X->object； - 对于
C，其搜索顺序为C->A->B->X->Y->object。
可以看到，B和C中，X、Y的搜索顺序是相反的，也就是说，当B被继承时，它本身的搜索顺序发生了改变，这违反了单调性原则。
MRO C3
在Python 2.3及后续版本中，运行程序一，得到如下结果：
CommonC
运行程序二，会产生如下异常：
Traceback (most recent call last):
File " ", line 9, in <module>
class C(A, B):
TypeError: Cannot create a consistent method resolution
order (MRO) for bases X, Y
以程序一为主，C3把各个类的MRO记为如下等式：
- 类
A：L[A] = merge(A , object) - 类
B：L[B] = [B] + merge(L[A] , [A]) - 类
C：L[C] = [C] + merge(L[A] , [A]) - 类
D：L[D] = [D] + merge(L[A] , L[B] , [A] , [B])
注意，以类 A 等式为例，其中merge包含的A称为L[A]的头，剩余元素（这里仅有一个object）称为尾。
这里的关键在于merge，它的运算方式如下：
- 检查第一个列表的头元素（如
L[A]的头），记作H。 - 若
H未出现在merge中其它列表的尾部，则将其输出，并将其从所有列表中删除，然后回到步骤 1；否则，取出下一个列表的头部记作 H，继续该步骤。
重复上述步骤，直至列表为空或者不能再找出可以输出的元素。如果是前一种情况，则算法结束；如果是后一种情况，Python会抛出异常。
由此，可以计算出类B的MRO，其计算过程为：
L[B] = [B] + merge(L[A],[A])
= [B] + merge([A,object],[A])
= [B,A] + merge([object])
= [B,A,object]
父类方法重写
子类扩展了父类，子类是一种特殊的父类。大部分时候，子类总是以父类为基础，额外增加新的方法。但在一些场景中，子类需要重写父类的方法。
class Bird:
# Bird类的fly()方法
def fly(self):
print("我在天空里自由自在地飞翔...")
class Ostrich(Bird):
# 重写Bird类的fly()方法
def fly(self):
print("我只能在地上奔跑...")
# 创建Ostrich对象
os = Ostrich()
# 执行Ostrich对象的fly()方法，将输出"我只能在地上奔跑..."
os.fly()
这种子类包含与父类同名的方法的现象被称为方法重写（Override），也被称为方法覆盖。可以说子类重写了父类的方法，也可以说子类覆盖了父类的方法。
使用未绑定方法调用被重写的方法
如果在子类中调用重写之后的方法，Python总是会执行子类重写的方法，不会执行父类中被重写的方法。如果需要在子类中调用父类中被重写的实例方法，则可以通过类名调用。区别在于：在通过类名调用实例方法时，Python 不会为实例方法的第一个参数 self 自动绑定参数值，而是需要程序显式绑定第一个参数 self。这种机制被称为未绑定方法。
class BaseClass:
def foo (self):
print('父类中定义的foo方法')
class SubClass(BaseClass):
# 重写父类的foo方法
def foo (self):
print('子类重写父类中的foo方法')
def bar (self):
print('执行bar方法')
# 直接执行foo方法，将会调用子类重写之后的foo()方法
self.foo()
# 使用类名调用实例方法（未绑定方法）调用父类被重写的方法
BaseClass.foo(self)
sc = SubClass()
sc.bar()
super()函数：调用父类的构造方法
Python的子类也会继承得到父类的构造方法，但如果子类有多个直接父类，那么会优先选择排在最前面的父类的构造方法。例如如下代码：
class Employee :
def __init__ (self, salary):
self.salary = salary
def work (self):
print('普通员工正在写代码，工资是:', self.salary)
class Customer:
def __init__ (self, favorite, address):
self.favorite = favorite
self.address = address
def info (self):
print('我是一个顾客，我的爱好是: %s,地址是%s' % (self.favorite, self.address))
# Manager继承了Employee、Customer
class Manager (Employee, Customer):
pass
m = Manager(25000)
m.work() #①
#m.info() #②
上面程序中第 13 行代码定义了Manager类，该类继承了Employee和Customer两个父类。接下来程序中的Manager类将会优先使用Employee类的构造方法（因为它排在前面），所以程序使用Manager(25000)来创建Manager对象。该构造方法只会初始化 salary实例变量，因此执行上面程序中 ① 号代码是没有任何问题的。
但是当执行到 ② 号代码时就会引发错误，这是由于程序在使用Employee类的构造方法创建Manager对象时，程序并未初始化Customer对象所需的两个实例变量：favorite和address，因此程序引发错误。
为了让 Manager 能同时初始化两个父类中的实例变量，Manager 应该定义自己的构造方法，即重写父类的构造方法。Python 要求，如果子类重写了父类的构造方法，那么子类的构造方法必须调用父类的构造方法。
子类的构造方法调用父类的构造方法有两种方式：
- 使用未绑定方法，这种方式很容易理解。因为构造方法也是实例方法，当然可以通过这种方式来调用。
- 使用
super()函数调用父类的构造方法。
注意，当子类继承多个父类是，super()函数只能用来调用第一个父类的构造方法，而其它父类的构造方法只能使用未绑定的方式调用。
# Manager继承了Employee、Customer
class Manager(Employee, Customer):
# 重写父类的构造方法
def __init__(self, salary, favorite, address):
print('--Manager的构造方法--')
# 通过super()函数调用父类的构造方法
super().__init__(salary)
# 与上一行代码的效果相同
#super(Manager, self).__init__(salary)
# 使用未绑定方法调用父类的构造方法
Customer.__init__(self, favorite, address)
# 创建Manager对象
m = Manager(25000, 'IT产品', '广州')
m.work() #①
m.info() #②
"""运行结果
--Manager的构造方法--
普通员工正在写代码，工资是：2500。
我是一个顾客，我的爱好是：IT产品，地址是广州
"""
Python 中，由于基类不会在 __init__() 中被隐式地调用，需要程序员显式调用它们。这种情况下，当程序中包含多重继承的类层次结构时，使用super是非常危险的，往往会在类的初始化过程中出现问题。
多态
多态也是一个非常重要的特性，Python是弱类型语言，即在使用变量时，无需为其指定具体的数据类型，这就可能出现，同一个变量会赋值不同的类对象，例如：
class Bird:
def move(self, field):
print('鸟在%s' % field)
class Dog:
def move(self, field):
print('狗在%s' % field)
a = Bird()
a.move("飞")
a = Dog()
a.move("跑")
"""运行结果
鸟在飞
狗在跑
"""
可以看到，a 可以被先后赋值为 Bird 类和 Dog 类的对象。而在此基础上，发生多态还要满足以下 2 个前提条件：
- 继承：多态一定是发生在子类和父类之间；
- 重写：子类重写了父类的方法。
class Animal:
def move(self,field):
print("动物在%s" % field)
class Bird(Animal):
def move(self, field):
print('鸟在%s' % field)
class Dog(Animal):
def move(self, field):
print('狗在%s' % field)
a = Animal()
a.move("叫")
a = Bird()
a.move("飞")
a = Dog()
a.move("跑")
"""运行结果
动物在叫
鸟在飞
狗在跑
"""
类特殊成员
__new__()方法：创建类实例
__new__()是一种负责创建类实例的静态方法，它无需使用staticmethod装饰器修饰，且该方法会优先__init__()初始化方法被调用。
一般情况下，覆写__new__()的实现将会使用合适的参数调用其超类的 super().__new__()，并在返回之前修改实例。例如：
class demoClass:
instances_created = 0
def __new__(cls,*args,**kwargs):
print("__new__():",cls,args,kwargs)
instance = super().__new__(cls)
instance.number = cls.instances_created
cls.instances_created += 1
return instance
def __init__(self,attribute):
print("__init__():",self,attribute)
self.attribute = attribute
test1 = demoClass("abc")
test2 = demoClass("xyz")
print(test1.number,test1.instances_created)
print(test2.number,test2.instances_created)
输出结果为：
__new__(): <class '__main__.demoClass'> ('abc',) {}
__init__(): <__main__.demoClass object at 0x0000026FC0DF8080> abc
__new__(): <class '__main__.demoClass'> ('xyz',) {}
__init__(): <__main__.demoClass object at 0x0000026FC0DED358> xyz
0 2
1 2
__new__()通常会返回该类的一个实例，但有时也可能会返回其他类的实例，如果发生了这种情况，则会跳过对__init__()方法的调用。而在某些情况下（比如需要修改不可变类实例（Python的某些内置类型）的创建行为），利用这一点会事半功倍。比如：
class nonZero(int):
def __new__(cls,value):
return super().__new__(cls,value) if value != 0 else None
def __init__(self,skipped_value):
#此例中会跳过此方法
print("__init__()")
super().__init__()
print(type(nonZero(-12)))
print(type(nonZero(0)))
运行结果为：
__init__()
<class '__main__.nonZero'>
<class 'NoneType'>
那么，什么情况下使用__new__()呢？答案很简单，在__init__()不够用的时候。
例如，前面例子中对Python不可变的内置类型（如int、str、float等）进行了子类化，这是因为一旦创建了这样不可变的对象实例，就无法在__init__()方法中对其进行修改。
有些读者可能会认为，__new__()对执行重要的对象初始化很有用，如果用户忘记使用super()，可能会漏掉这一初始化。虽然这听上去很合理，但有一个主要的缺点，即如果使用这样的方法，那么即便初始化过程已经是预期的行为，程序员明确跳过初始化步骤也会变得更加困难。不仅如此，它还破坏了“__init__()中执行所有初始化工作”的潜规则。
注意，由于__new__()不限于返回同一个类的实例，所以很容易被滥用，不负责任地使用这种方法可能会对代码有害，所以要谨慎使用。一般来说，对于特定问题，最好搜索其他可用的解决方案，最好不要影响对象的创建过程，使其违背程序员的预期。比如说，前面提到的覆写不可变类型初始化的例子，完全可以用工厂方法（一种设计模式）来替代。
__repr__()方法：显示属性
前面章节中，我们经常会直接输出类的实例化对象，例如：
class CLanguage:
pass
clangs = CLanguage()
print(clangs)
程序运行结果为：
<__main__.CLanguage object at 0x000001A7275221D0>
通常情况下，直接输出某个实例化对象，本意往往是想了解该对象的基本信息，例如该对象有哪些属性，它们的值各是多少等等。但默认情况下，我们得到的信息只会是“类名+object at+内存地址”，对我们了解该实例化对象帮助不大。
那么，有没有可能自定义输出实例化对象时的信息呢？答案是肯定，通过重写类的__repr__()方法即可。事实上，当我们输出某个实例化对象时，其调用的就是该对象的__repr__()方法，输出的是该方法的返回值。
以本节开头的程序为例，执行print(clangs)等同于执行print(clangs.__repr__())，程序的输出结果是一样的（输出的内存地址可能不同）。
和__init__(self)的性质一样，Python中的每个类都包含__repr__()方法，因为object类包含__reper__()方法，而Python中所有的类都直接或间接继承自object类。
默认情况下，__repr__()会返回和调用者有关的 “类名+object at+内存地址”信息。当然，我们还可以通过在类中重写这个方法，从而实现当输出实例化对象时，输出我们想要的信息。
举个例子：
class CLanguage:
def __init__(self):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
def __repr__(self):
return "CLanguage[name="+ self.name +",add=" + self.add +"]"
clangs = CLanguage()
print(clangs)
程序运行结果为：
CLanguage[name=我的世界,add=http://wodeshijie.com]
由此可见，__repr__()方法是类的实例化对象用来做“自我介绍”的方法，默认情况下，它会返回当前对象的“类名+object at+内存地址”，而如果对该方法进行重写，可以为其制作自定义的自我描述信息。
__del__()方法：销毁对象
我们知道，Python通过调用__init__()方法构造当前类的实例化对象，而本节要学的__del__()方法，功能正好和__init__()相反，其用来销毁实例化对象。
事实上在编写程序时，如果之前创建的类实例化对象后续不再使用，最好在适当位置手动将其销毁，释放其占用的内存空间（整个过程称为垃圾回收（简称GC））。
大多数情况下，Python开发者不需要手动进行垃圾回收，因为Python有自动的垃圾回收机制（下面会讲），能自动将不需要使用的实例对象进行销毁。
无论是手动销毁，还是Python自动帮我们销毁，都会调用__del__()方法。举个例子：
class CLanguage:
def __init__(self):
print("调用 __init__() 方法构造对象")
def __del__(self):
print("调用__del__() 销毁对象，释放其空间")
clangs = CLanguage()
del clangs
程序运行结果为：
调用 __init__() 方法构造对象
调用__del__() 销毁对象，释放其空间
但是，读者千万不要误认为，只要为该实例对象调用__del__()方法，该对象所占用的内存空间就会被释放。举个例子：
class CLanguage:
def __init__(self):
print("调用 __init__() 方法构造对象")
def __del__(self):
print("调用__del__() 销毁对象，释放其空间")
clangs = CLanguage()
#添加一个引用clangs对象的实例对象
cl = clangs
del clangs
print("***********")
程序运行结果为：
调用 __init__() 方法构造对象
***********
调用__del__() 销毁对象，释放其空间
注意，最后一行输出信息，是程序执行即将结束时调用__del__()方法输出的。
可以看到，当程序中有其它变量（比如这里的cl）引用该实例对象时，即便手动调用__del__()方法，该方法也不会立即执行。这和Python的垃圾回收机制的实现有关。
Python采用自动引用计数（简称ARC）的方式实现垃圾回收机制。该方法的核心思想是：每个Python对象都会配置一个计数器，初始 Python实例对象的计数器值都为0，如果有变量引用该实例对象，其计数器的值会加1，依次类推；反之，每当一个变量取消对该实例对象的引用，计数器会减1。如果一个Python对象的的计数器值为0，则表明没有变量引用该Python对象，即证明程序不再需要它，此时Python就会自动调用__del__()方法将其回收。
以上面程序中的clangs为例，实际上构建clangs实例对象的过程分为2 步，先使用CLanguage()调用该类中的__init__()方法构造出一个该类的对象（将其称为C，计数器为0），并立即用clangs这个变量作为所建实例对象的引用（ C的计数器值+ 1）。在此基础上，又有一个clang变量引用clangs（其实相当于引用CLanguage()，此时C的计数器再+1），这时如果调用del clangs语句，只会导致C的计数器减1（值变为1），因为C的计数器值不为0，因此C不会被销毁（不会执行__del__()方法）。
如果在上面程序结尾，添加如下语句：
del cl
print("-----------")
则程序的执行结果为：
调用 __init__() 方法构造对象
***********
调用__del__() 销毁对象，释放其空间
-----------
可以看到，当执行del cl语句时，其应用的对象实例对象C的计数器继续-1（变为0），对于计数器为0的实例对象，Python会自动将其视为垃圾进行回收。
需要额外说明的是，如果我们重写子类的__del__()方法（父类为非object的类），则必须显式调用父类的__del__()方法，这样才能保证在回收子类对象时，其占用的资源（可能包含继承自父类的部分资源）能被彻底释放。为了说明这一点，这里举一个反例：
class CLanguage:
def __del__(self):
print("调用父类 __del__() 方法")
class cl(CLanguage):
def __del__(self):
print("调用子类 __del__() 方法")
c = cl()
del c
程序运行结果为：
调用子类 __del__() 方法
__dir__()用法：列出对象的所有属性（方法）名
前面在介绍Python内置函数时，提到了dir()函数，通过此函数可以某个对象拥有的所有的属性名和方法名，该函数会返回一个包含有所有属性名和方法名的有序列表。
举个例子：
class CLanguage:
def __init__ (self,):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
def say():
pass
clangs = CLanguage()
print(dir(clangs))
程序运行结果为：
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'add', 'name', 'say']
注意，通过dir()函数，不仅仅输出本类中新添加的属性名和方法（最后3 个），还会输出从父类（这里为object类）继承得到的属性名和方法名。
值得一提的是，dir()函数的内部实现，其实是在调用参数对象__dir__()方法的基础上，对该方法返回的属性名和方法名做了排序。
所以，除了使用dir()函数，我们完全可以自行调用该对象具有的 dir() 方法：
class CLanguage:
def __init__ (self,):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
def say():
pass
clangs = CLanguage()
print(clangs.__dir__())
程序运行结果为：
['name', 'add', '__module__', '__init__', 'say', '__dict__', '__weakref__', '__doc__', '__repr__', '__hash__', '__str__', '__getattribute__', '__setattr__', '__delattr__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__new__', '__reduce_ex__', '__reduce__', '__subclasshook__', '__init_subclass__', '__format__', '__sizeof__', '__dir__', '__class__']
显然，使用__dir__()方法和dir()函数输出的数据是相同，仅仅顺序不同。
__dict__属性：查看对象内部所有属性名和属性值组成的字典
在Python类的内部，无论是类属性还是实例属性，都是以字典的形式进行存储的，其中属性名作为键，而值作为该键对应的值。
为了方便用户查看类中包含哪些属性，Python类提供了__dict__属性。需要注意的一点是，该属性可以用类名或者类的实例对象来调用，用类名直接调用__dict__，会输出该由类中所有类属性组成的字典；而使用类的实例对象调用__dict__，会输出由类中所有实例属性组成的字典。
举个例子：
class CLanguage:
a = 1
b = 2
def __init__ (self):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
#通过类名调用__dict__
print(CLanguage.__dict__)
#通过类实例对象调用 __dict__
clangs = CLanguage()
print(clangs.__dict__)
程序输出结果为：
{'__module__': '__main__', 'a': 1, 'b': 2, '__init__': <function CLanguage.__init__ at 0x0000022C69833E18>, '__dict__': <attribute '__dict__' of 'CLanguage' objects>, '__weakref__': <attribute '__weakref__' of 'CLanguage' objects>, '__doc__': None}
{'name': '我的世界', 'add': 'http://wodeshijie.com'}
不仅如此，对于具有继承关系的父类和子类来说，父类有自己的__dict__，同样子类也有自己的__dict__，它不会包含父类的__dict__。例如：
class CLanguage:
a = 1
b = 2
def __init__ (self):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
class CL(CLanguage):
c = 1
d = 2
def __init__ (self):
self.na = "你的世界"
self.ad = "http://nideshijie.com"
#父类名调用__dict__
print(CLanguage.__dict__)
#子类名调用__dict__
print(CL.__dict__)
#父类实例对象调用 __dict__
clangs = CLanguage()
print(clangs.__dict__)
#子类实例对象调用 __dict__
cl = CL()
print(cl.__dict__)
运行结果为：
{'__module__': '__main__', 'a': 1, 'b': 2, '__init__': <function CLanguage.__init__ at 0x000001721A853E18>, '__dict__': <attribute '__dict__' of 'CLanguage' objects>, '__weakref__': <attribute '__weakref__' of 'CLanguage' objects>, '__doc__': None}
{'__module__': '__main__', 'c': 1, 'd': 2, '__init__': <function CL.__init__ at 0x000001721CD15510>, '__doc__': None}
{'name': '我的世界', 'add': 'http://wodeshijie.com'}
{'na': '你的世界', 'ad': 'http://nideshijie.com'}
显然，通过子类直接调用的__dict__中，并没有包含父类中的a和b类属性；同样，通过子类对象调用的__dict__，也没有包含父类对象拥有的name和add实例属性。
除此之外，借助由类实例对象调用__dict__属性获取的字典，可以使用字典的方式对其中实例属性的值进行修改，例如：
class CLanguage:
a = "aaa"
b = 2
def __init__ (self):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
#通过类实例对象调用 __dict__
clangs = CLanguage()
print(clangs.__dict__)
clangs.__dict__['name'] = "你的世界"
print(clangs.name)
程序运行结果为：
{'name': '我的世界', 'add': 'http://wodeshijie.com'}
你的世界
注意，无法通过类似的方式修改类变量的值。
setattr()、getattr()、hasattr()函数用法详解
除了前面介绍的几个类中的特殊方法外，本节再介绍 3 个常用的函数，分别是hasattr()、getattr()以及setattr()。
hasattr()函数
hasattr()函数用来判断某个类实例对象是否包含指定名称的属性或方法。该函数的语法格式如下：
hasattr(obj, name)
其中obj指的是某个类的实例对象，name表示指定的属性名或方法名。同时，该函数会将判断的结果（True或者 False）作为返回值反馈回来。
举个例子：
class CLanguage:
def __init__ (self):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
def say(self):
print("我正在学Python")
clangs = CLanguage()
print(hasattr(clangs,"name"))
print(hasattr(clangs,"add"))
print(hasattr(clangs,"say"))
程序输出结果为：
True
True
True
显然，无论是属性名还是方法名，都在hasattr()函数的匹配范围内。因此，我们只能通过该函数判断实例对象是否包含该名称的属性或方法，但不能精确判断，该名称代表的是属性还是方法。
getattr()函数
getattr()函数获取某个类实例对象中指定属性的值。没错，和hasattr()函数不同，该函数只会从类对象包含的所有属性中进行查找。
getattr()函数的语法格式如下：
getattr(obj, name[, default])
其中，obj表示指定的类实例对象，name表示指定的属性名，而default是可选参数，用于设定该函数的默认返回值，即当函数查找失败时，如果不指定default参数，则程序将直接报AttributeError错误，反之该函数将返回default指定的值。
举个例子：
class CLanguage:
def __init__ (self):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
def say(self):
print("我正在学Python")
clangs = CLanguage()
print(getattr(clangs,"name"))
print(getattr(clangs,"add"))
print(getattr(clangs,"say"))
print(getattr(clangs,"display",'nodisplay'))
程序执行结果为：
我的世界
http://wodeshijie.com
<bound method CLanguage.say of <__main__.CLanguage object at 0x000001FC2F2E3198>>
nodisplay
可以看到，对于类中已有的属性，getattr()会返回它们的值，而如果该名称为方法名，则返回该方法的状态信息；反之，如果该明白不为类对象所有，要么返回默认的参数，要么程序报AttributeError错误。
setattr()函数
setattr()函数的功能相对比较复杂，它最基础的功能是修改类实例对象中的属性值。其次，它还可以实现为实例对象动态添加属性或者方法。
setattr()函数的语法格式如下：
setattr(obj, name, value)
首先，下面例子演示如何通过该函数修改某个类实例对象的属性值：
class CLanguage:
def __init__ (self):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
def say(self):
print("我正在学Python")
clangs = CLanguage()
print(clangs.name)
print(clangs.add)
setattr(clangs,"name","你的世界")
setattr(clangs,"add","http://nideshijie.com")
print(clangs.name)
print(clangs.add)
程序运行结果为：
我的世界
http://wodeshijie.com
你的世界
http://nideshijie.com
甚至利用setattr()函数，还可以将类属性修改为一个类方法，同样也可以将类方法修改成一个类属性。例如：
def say(self):
print("我正在学Python")
class CLanguage:
def __init__ (self):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
clangs = CLanguage()
print(clangs.name)
print(clangs.add)
setattr(clangs,"name",say)
clangs.name(clangs)
程序运行结果为：
我的世界
http://wodeshijie.com
我正在学Python
显然，通过修改name属性的值为say（这是一个外部定义的函数），原来的name属性就变成了一个name()方法。
使用setattr()函数对实例对象中执行名称的属性或方法进行修改时，如果该名称查找失败，Python解释器不会报错，而是会给该实例对象动态添加一个指定名称的属性或方法。例如：
def say(self):
print("我正在学Python")
class CLanguage:
pass
clangs = CLanguage()
setattr(clangs,"name","我的世界")
setattr(clangs,"say",say)
print(clangs.name)
clangs.say(clangs)
程序执行结果为：
我的世界
我正在学Python
可以看到，虽然CLanguage为空类，但通过setattr()函数，我们为clangs对象动态添加了一个name属性和一个 say()方法。
issubclass和isinstance函数：检查类型
Python提供了如下两个函数来检查类型：
issubclass(cls, class_or_tuple)：检查cls是否为后一个类或元组包含的多个类中任意类的子类。isinstance(obj, class_or_tuple)：检查obj是否为后一个类或元组包含的多个类中任意类的对象。
通过使用上面两个函数，程序可以方便地先执行检查，然后才调用方法，这样可以保证程序不会出现意外情况。
如下程序示范了通过这两个函数来检查类型：
# 定义一个字符串
hello = "Hello";
# "Hello"是str类的实例，输出True
print('"Hello"是否是str类的实例: ', isinstance(hello, str))
# "Hello"是object类的子类的实例，输出True
print('"Hello"是否是object类的实例: ', isinstance(hello, object))
# str是object类的子类，输出True
print('str是否是object类的子类: ', issubclass(str, object))
# "Hello"不是tuple类及其子类的实例，输出False
print('"Hello"是否是tuple类的实例: ', isinstance(hello, tuple))
# str不是tuple类的子类，输出False
print('str是否是tuple类的子类: ', issubclass(str, tuple))
# 定义一个列表
my_list = [2, 4]
# [2, 4]是list类的实例，输出True
print('[2, 4]是否是list类的实例: ', isinstance(my_list, list))
# [2, 4]是object类的子类的实例，输出True
print('[2, 4]是否是object类及其子类的实例: ', isinstance(my_list, object))
# list是object类的子类，输出True
print('list是否是object类的子类: ', issubclass(list, object))
# [2, 4]不是tuple类及其子类的实例，输出False
print('[2, 4]是否是tuple类及其子类的实例: ', isinstance([2, 4], tuple))
# list不是tuple类的子类，输出False
print('list是否是tuple类的子类: ', issubclass(list, tuple))
通过上面程序可以看出，issubclass()和isinstance()两个函数的用法差不多，区别只是issubclass()的第一个参数是类名，而isinstance()的第一个参数是变量，这也与两个函数的意义对应：issubclass用于判断是否为子类，而isinstance()用于判断是否为该类或子类的实例。
issubclass()和isinstance()两个函数的第二个参数都可使用元组。例如如下代码：
data = (20, 'fkit')
print('data是否为列表或元组: ', isinstance(data, (list, tuple))) # True
# str不是list或者tuple的子类，输出False
print('str是否为list或tuple的子类: ', issubclass(str, (list, tuple)))
# str是list或tuple或object的子类，输出True
print('str是否为list或tuple或object的子类 ', issubclass(str, (list, tuple, object)))
此外，Python为所有类都提供了一个__bases__属性，通过该属性可以查看该类的所有直接父类，该属性返回所有直接父类组成的元组。例如如下代码：
class A:
pass
class B:
pass
class C(A, B):
pass
print('类A的所有父类:', A.__bases__)
print('类B的所有父类:', B.__bases__)
print('类C的所有父类:', C.__bases__)
运行上面程序，可以看到如下运行结果：
类A的所有父类: (<class 'object'>,)
类B的所有父类: (<class 'object'>,)
类C的所有父类: (<class '__main__.A'>, <class '__main__.B'>)
从上面的运行结果可以看出，如果在定义类时没有显式指定它的父类，则这些类默认的父类是object类。
Python还为所有类都提供了一个__subclasses__()方法，通过该方法可以查看该类的所有直接子类，该方法返回该类的所有子类组成的列表。例如在上面程序中增加如下两行：
print('类A的所有子类:', A.__subclasses__())
print('类B的所有子类:', B.__subclasses__())
运行上面代码，可以看到如下输出结果：
类A的所有子类: [<class '__main__.C'>]
类B的所有子类: [<class '__main__.C'>]
__call__()方法：可调用对象
本节再介绍Python类中一个非常特殊的实例方法，即__call__()。该方法的功能类似于在类中重载()运算符，使得类实例对象可以像调用普通函数那样，以“对象名()”的形式使用。
举个例子：
class CLanguage:
# 定义__call__方法
def __call__(self,name,add):
print("调用__call__()方法",name,add)
clangs = CLanguage()
clangs("我的世界","http://wodeshijie.com")
程序执行结果为：
调用__call__()方法 我的世界 http://wodeshijie.com
可以看到，通过在CLanguage类中实现__call__()方法，使的clangs实例对象变为了可调用对象。
Python中，凡是可以将()直接应用到自身并执行，都称为可调用对象。可调用对象包括自定义的函数、Python内置函数以及本节所讲的类实例对象。
对于可调用对象，实际上“名称()”可以理解为是“名称.__call__()”的简写。仍以上面程序中定义的clangs实例对象为例，其最后一行代码还可以改写为如下形式：
clangs.__call__("我的世界","http://wodeshijie.com")
运行程序会发现，其运行结果和之前完全相同。
这里再举一个自定义函数的例子，例如：
def say():
print("你的世界：http://nideshijie.com")
say()
say.__call__()
程序执行结果为：
你的世界：http://nideshijie.com
你的世界：http://nideshijie.com
不仅如此，类中的实例方法也有以上2种调用方式，这里不再举例，有兴趣的读者可自行编写代码尝试。
用__call__()弥补hasattr()函数的短板
前面章节介绍了hasattr()函数的用法，该函数的功能是查找类的实例对象中是否包含指定名称的属性或者方法，但该函数有一个缺陷，即它无法判断该指定的名称，到底是类属性还是类方法。
要解决这个问题，我们可以借助可调用对象的概念。要知道，类实例对象包含的方法，其实也属于可调用对象，但类属性却不是。举个例子：
class CLanguage:
def __init__ (self):
self.name = "我的世界"
self.add = "http://wodeshijie.com"
def say(self):
print("我正在学Python")
clangs = CLanguage()
if hasattr(clangs,"name"):
print(hasattr(clangs.name,"__call__"))
print("**********")
if hasattr(clangs,"say"):
print(hasattr(clangs.say,"__call__"))
程序执行结果为：
False
**********
True
可以看到，由于name是类属性，它没有以__call__为名的__call__()方法；而say是类方法，它是可调用对象，因此它有__call__()方法。
可重载运算符
其实在Python内部，每种序列类型都是Python的一个类，例如列表是list类，字典是dict类等，这些序列类的内部使用了一个叫作“重载运算符”的技术来实现不同运算符所对应的操作。
所谓重载运算符，指的是在类中定义并实现一个与运算符对应的处理方法，这样当类对象在进行运算符操作时，系统就会调用类中相应的方法来处理。
这里给大家举一个与重载运算符相关的实例：
class MyClass: #自定义一个类
def __init__(self, name , age): #定义该类的初始化函数
self.name = name #将传入的参数值赋值给成员交量
self.age = age
def __str__(self): #用于将值转化为字符串形式，等同于 str(obj)
return "name:"+self.name+";age:"+str(self.age)
__repr__ = __str__ #转化为供解释器读取的形式
def __lt__(self, record): #重载 self<record 运算符
if self.age < record.age:
return True
else:
return False
def __add__(self, record): #重载 + 号运算符
return MyClass(self.name, self.age+record.age)
myc = MyClass("Anna", 42) #实例化一个对象 Anna，并为其初始化
mycl = MyClass("Gary", 23) #实例化一个对象 Gary，并为其初始化
print(repr(myc)) #格式化对象 myc，
print(myc) #解释器读取对象 myc，调用 repr
print (str (myc)) #格式化对象 myc ，输出"name:Anna;age:42"
print(myc < mycl) #比较 myc<mycl 的结果，输出 False
print (myc+mycl) #进行两个 MyClass 对象的相加运算，输出 "name:Anna;age:65"
输出结果为：
name:Anna;age:42
name:Anna;age:42
name:Anna;age:42
False
name:Anna;age:65
这个例子中，MyClass 类中重载了 repr、str、<、+ 运算符，并用MyClass实例化了两个对象myc和 mycl。
通过将myc进行 repr、str 运算，从输出结果中可以看到，程序调用了重载的操作符方法__repr__和 __str__。而令 myc和mycl进行<号的比较运算以及加法运算，从输出结果中可以看出，程序调用了重载<号的方法__lt__和 __add__方法。
那么，Python 类支持对哪些方法进行重载呢？这个给大家提供一个表格（表 1），列出了Python中常用的可重载的运算符，以及各自的含义。
| 重载运算符 | 含义 |
|---|---|
__new__ |
创建类，在__init__之前创建对象 |
__init__ |
类的构造函数，其功能是创建类对象时做初始化工作。 |
__del__ |
析构函数，其功能是销毁对象时进行回收资源的操作 |
__add__ |
加法运算符 +，当类对象X做例如X+Y或者X+=Y等操作，内部会调用此方法。但如果类中对__iadd__方法进行了重载，则类对象X在做X+=Y类似操作时，会优先选择调用__iadd__方法。 |
__radd__ |
当类对象X做类似Y+X的运算时，会调用此方法。 |
__iadd__ |
重载+=运算符，也就是说，当类对象X做类似X+=Y的操作时，会调用此方法。 |
__or__ |
“或”运算符` |
__repr__，__str__ |
格式转换方法，分别对应函数 repr(X)、str(X) |
__call__ |
函数调用，类似于X(*args, **kwargs)语句 |
__getattr__ |
点号运算，用来获取类属性 |
__setattr__ |
属性赋值语句，类似于 X.any=value |
__delattr__ |
删除属性，类似于 del X.any |
__getattribute__ |
获取属性，类似于 X.any |
__getitem__ |
索引运算，类似于 X[key]，X[i:j] |
__setitem__ |
索引赋值语句，类似于 X[key], X[i:j]=sequence |
__delitem__ |
索引和分片删除 |
__get__, __set__, __delete__ |
描述符属性，类似于 X.attr，X.attr=value，del X.attr |
__len__ |
计算长度，类似于 len(X) |
__lt__，__gt__，__le__，__ge__，__eq__，__ne__ |
比较，分别对应于 <、>、<=、>=、=、!= 运算符。 |
__iter__，__next__ |
迭代环境下，生成迭代器与取下一条，类似于I=iter(X)和 next() |
__contains__ |
成员关系测试，类似于 item in X |
__index__ |
整数值，类似于 hex(X)，bin(X)，oct(X) |
__enter__，__exit__ |
在对类对象执行类似with obj as var的操作之前，会先调用__enter__方法，其结果会传给 var；在最终结束该操作之前，会调用__exit__方法（常用于做一些清理、扫尾的工作） |
重载运算符实现自定义序列
除了前面章节介绍的几个类特殊方法（方法名以双下划线（__）开头和结尾），在Python类中，我们还可以通过重写几个特殊方法，实现自定义一个序列类。表 1 列出了和自定义序列类有关的几个特殊方法。
| 方法名 | 功能 |
|---|---|
__len__(self) |
返回序列类中存储元素的个数。 |
__contains__(self, value) |
判断当前序列中是否包含value这个指定元素。 |
__getitem__(self, key) |
通过指定的 key（键），返回对应的 value（值）。 |
__setitem__(self, key) |
修改指定 key（键）对应的 value（值）。 |
__delitem__(self, key) |
删除指定键值对。 |
注意，在对表1中的这些特殊方法进行重写时，在实现其基础功能的基础上，还可以根据实际情况，对各个方法的具体实现进行适当调整。以 __setitem__()方法为例，当在序列中未找到指定key的情况下，该方法可以报错，当然也可以将此键值对添加到当前序列中。
另外值得一提的是，在实现自定义序列类时，并不是必须重写表1 中全部的特殊方法。如果该自定义序列是一个不可变序列（即序列中的元素不能做修改），则无需重写__setitem__()和 __delitem__()方法；反之，如果该自定义序列是一个可变序列，可以重写以上5个特殊方法。
下面程序实现了一个比较简单的序列类，这是一个字典类，其特点是只能存储int类型的元素：
class IntDic:
def __init__(self):
# 用于存储数据的字典
self.__date = {}
def __len__(self):
return len(list(self.__date.values()))
def __getitem__(self, key):
# 如果在self.__changed中找到已经修改后的数据
if key in self.__date :
return self.__date[key]
return None
def __setitem__(self, key, value):
#判断value是否为整数
if not isinstance(value, int):
raise TypeError('必须是整数')
#修改现有 key 对应的 value 值，或者直接添加
self.__date[key] = value
def __delitem__(self, key):
if key in self.__date : del self.__date[key]
dic = IntDic()
#输出序列中元素的个数，调用 __len__() 方法
print(len(dic))
#向序列中添加元素，调用 __setitem__() 方法
dic['a'] = 1
dic['b'] = 2
print(len(dic))
dic['a'] = 3
dic['c'] = 4
print(dic['a'])
#删除指定元素，调用 __delitem__() 方法
del dic['a']
print(dic['a'])
print(len(dic))
程序执行结果为：
0
2
3
None
2
迭代器
前面章节中，已经对列表（list）、元组（tuple）、字典（dict）、集合（set）这些序列式容器做了详细的介绍。值得一提的是，这些序列式容器有一个共同的特性，它们都支持使用for循环遍历存储的元素，都是可迭代的，因此它们又有一个别称，即迭代器。
从字面来理解，迭代器指的就是支持迭代的容器，更确切的说，是支持迭代的容器类对象，这里的容器可以是列表、元组等这些Python提供的基础容器，也可以是自定义的容器类对象，只要该容器支持迭代即可。
《Python实现自定义序列》一节中，已经学会了如何自定义一个序列类，但该序列类对象并不支持迭代，因此还不能称之为迭代器。如果要自定义实现一个迭代器，则类中必须实现如下 2 个方法：
__next__(self)：返回容器的下一个元素。__iter__(self)：该方法返回一个迭代器（iterator）。
例如，下面程序自定义了一个简易的列表容器迭代器，支持迭代：
class listDemo:
def __init__(self):
self.__date=[]
self.__step = 0
def __next__(self):
if self.__step <= 0:
raise StopIteration
self.__step -= 1
#返回下一个元素
return self.__date[self.__step]
def __iter__(self):
#实例对象本身就是迭代器对象，因此直接返回 self 即可
return self
#添加元素
def __setitem__(self,key,value):
self.__date.insert(key,value)
self.__step += 1
mylist = listDemo()
mylist[0]=1
mylist[1]=2
for i in mylist:
print (i)
程序执行结果为：
2
1
除此之外，Python 内置的iter()函数也会返回一个迭代器，该函数的语法格式如下：
iter(obj[, sentinel])
其中，obj 必须是一个可迭代的容器对象，而sentinel作为可选参数，如果使用此参数，要求obj必须是一个可调用对象，具体功能后面会讲。
可调用对象，指的是该类的实例对象可以像函数那样，直接以“对象名()”的形式被使用。通过在类中添加
__call__()方法，就可以将该类的实例对象编程可调用对象。有关__call__()方法，可Python __call__()做详细了解。
我们常用的是仅有1个参数的iter()函数，通过传入一个可迭代的容器对象，我们可以获得一个迭代器，通过调用该迭代器中的__next__()方法即可实现迭代。例如；
# 将列表转换为迭代器
myIter = iter([1, 2, 3])
# 依次获取迭代器的下一个元素
print(myIter.__next__())
print(myIter.__next__())
print(myIter.__next__())
print(myIter.__next__())
运行结果为：
1
2
3
Traceback (most recent call last):
File " ", line 7, in <module>
print(myIter.__next__())
StopIteration
另外，也可以使用
next()内置函数来迭代，即next(myIter)，和__next__()方法是完全一样的。
从程序的执行结果可以看出，当迭代完存储的所有元素之后，如果继续迭代，则__next__()方法会抛出StopIteration异常。
这里介绍iter()函数第2个参数的作用，如果使用该参数，则要求第一个obj 参数必须传入可调用对象（可以不支持迭代），这样当使用返回的迭代器调用__next__()方法时，它会通过执行obj()调用 __call__()方法，如果该方法的返回值和第2个参数值相同，则输出StopInteration异常；反之，则输出 __call__()方法的返回值。
例如，修改listDemo类如下所示：
class listDemo:
def __init__(self):
self.__date=[]
self.__step = 0
def __setitem__(self,key,value):
self.__date.insert(key,value)
self.__step += 1
#是该类实例对象成为可调用对象
def __call__(self):
self.__step-=1
return self.__date[self.__step]
mylist = listDemo()
mylist[0]=1
mylist[1]=2
#将 mylist 变为迭代器
a = iter(mylist,1)
print(a.__next__())
print(a.__next__())
程序执行结果为：
2
Traceback (most recent call last):
File "D:\python3.6\1.py", line 20, in <module>
print(a.__next__())
StopIteration
输出结果中，之所以最终抛出StopIteration异常，是因为这里原本要输出的元素1和iter()函数的第2个参数相同。
项目实战之迭代器实现字符串的逆序输出
Python迭代器已经对如何创建迭代器做了详细的介绍，本节将利用迭代器完成对字符串的逆序操作。项目要求是这样的，定义一个类，要求在实现迭代器功能的基础上，能够对用户输入的字符串做逆序输出操作。
实现思路是这样的，自定义一个类并重载其__init__()初始化方法，实现为自身私有成员赋值。同时重载__iter__()和 __next__()方法，使其具有迭代器功能。在此基础上，如果想实现对用户输入的字符串进行逆序输出，就需要在__next__() 方法中实现从后往前返回字符。
实现代码如下：
class Reverse:
def __init__(self, string):
self.__string = string
self.__index = len(string)
def __iter__(self):
return self
def __next__(self):
self.__index -= 1
return self.__string[self.__index]
revstr = Reverse('Python')
for c in revstr:
print(c,end=" ")
运行结果为：
n o h t y P n o h t y P Traceback (most recent call last):
File " ", line 11, in <module>
for c in revstr:
File " ", line 9, in __next__
return self.__string[self.__index]
IndexError: string index out of range
可以看到，上面程序在逆序输出两遍"python"的同时，Python解释器报出IndexError错误，这是什么原因呢？
很简单，因为程序没有设置遍历的终止条件，换句话说，没有对__index私有变量的值对限制，这里__index的取值范围应为（-len(self.__index), len(self.__index)），这也是导致上面程序运行结果的根本原因。
编写迭代器最容易忽视的一个环节，就是在自定义类中加入对循环结束的判断，并抛出StopIteration异常，只有这么做了，for 循环才会接收到StopIteration异常，并当做终止信号来结束循环。
所以，我们需要对上面程序做适当的调整，如下所示：
class Reverse:
def __init__(self, string):
self.__string = string
self.__index = len(string)
def __iter__(self):
return self
def __next__(self):
if self.__index == 0:
raise(StopIteration)
self.__index -= 1
return self.__string[self.__index]
revstr = Reverse('Python')
for c in revstr:
print(c,end=" ")
运行结果为：
n o h t y P
生成器
前面章节中，已经详细介绍了什么是迭代器。生成器本质上也是迭代器，不过它比较特殊。
以list容器为例，在使用该容器迭代一组数据时，必须事先将所有数据存储到容器中，才能开始迭代；而生成器却不同，它可以实现在迭代的同时生成元素。
也就是说，对于可以用某种算法推算得到的多个数据，生成器并不会一次性生成它们，而是什么时候需要，才什么时候生成。
不仅如此，生成器的创建方式也比迭代器简单很多，大体分为以下2步：
- 定义一个以
yield关键字标识返回值的函数； - 调用刚刚创建的函数，即可创建一个生成器。
举个例子：
def intNum():
print("开始执行")
for i in range(5):
yield i
print("继续执行")
num = intNum()
由此，我们就成功创建了一个num生成器对象。显然，和普通函数不同，number() 函数的返回值用的是yield关键字，而不是return关键字，此类函数又成为生成器函数。
和return相比，yield 除了可以返回相应的值，还有一个更重要的功能，即每当程序执行完该语句时，程序就会暂停执行。不仅如此，即便调用生成器函数，Python解释器也不会执行函数中的代码，它只会返回一个生成器（对象）。
要想使生成器函数得以执行，或者想使执行完yield语句立即暂停的程序得以继续执行，有以下2种方式：
- 通过生成器（上面程序中的
num）调用next()内置函数或者__next__()方法； - 通过
for循环遍历生成器。
例如，在上面程序的基础上，添加如下语句：
#调用 next() 内置函数
print(next(num))
#调用 __next__() 方法
print(num.__next__())
#通过for循环遍历生成器
for i in num:
print(i)
程序执行结果为：
开始执行
0
继续执行
1
继续执行
2
继续执行
3
继续执行
4
继续执行
这里有必要给读者分析一个程序的执行流程：
-
首先，在创建有
num生成器的前提下，通过其调用next()内置函数，会使Python解释器开始执行intNum()生成器函数中的代码，因此会输出“开始执行”，程序会一直执行到yield i，而此时的i==0，因此Python解释器输出“0”。由于受到yield的影响，程序会在此处暂停。 -
然后，我们使用
num生成器调用__next__()方法，该方法的作用和next()函数完全相同（事实上，next()函数的底层执行的也是__next__()方法），它会是程序继续执行，即输出“继续执行”，程序又会执行到yield i，此时i==1，因此输出“1”，然后程序暂停。 -
最后，我们使用
for循环遍历num 生成器，之所以能这么做，是因为for循环底层会不断地调用next() `函数，使暂停的程序继续执行，因此会输出后续的结果。
注意，在
Python 2.x版本中不能使用__next__()方法，可以使用next()内置函数，另外生成器还有next()方法（即以num.next()的方式调用）。
除此之外，还可以使用list()函数和tuple()函数，直接将生成器能生成的所有值存储成列表或者元组的形式。例如：
num = intNum()
print(list(num))
num = intNum()
print(tuple(num))
程序执行结果为：
开始执行
继续执行
继续执行
继续执行
继续执行
继续执行
[0, 1, 2, 3, 4]
开始执行
继续执行
继续执行
继续执行
继续执行
继续执行
(0, 1, 2, 3, 4)
通过输出结果可以判断出，list() 和tuple()底层实现和for循环的遍历过程是类似的。
生成器send()方法
我们知道，通过调用next()或者__next__()方法，可以实现从外界控制生成器的执行。除此之外，通过send()方法，还可以向生成器中传值。
值得一提的是，send() 方法可带一个参数，也可以不带任何参数（用None表示）。其中，当使用不带参数的send()方法时，它和next()函数的功能完全相同。例如：
def intNum():
print("开始执行")
for i in range(5):
yield i
print("继续执行")
num = intNum()
print(num.send(None))
print(num.send(None))
程序执行结果为：
开始执行
0
继续执行
1
注意，虽然
send(None)的功能是next()完全相同，但更推荐使用next()，不推荐使用send(None)。
这里重点讲解一些带参数的send(value)的用法，其具备next()函数的部分功能，即将暂停在yield语句出的程序继续执行，但与此同时，该函数还会将value值作为yield语句返回值赋值给接收者。
注意，带参数的send(value)无法启动执行生成器函数。也就是说，程序中第一次使用生成器调用next()或者send()函数时，不能使用带参数的send()函数。
举个例子：
def foo():
bar_a = yield "hello"
bar_b = yield bar_a
yield bar_b
f = foo()
print(f.send(None))
print(f.send("我的世界"))
print(f.send("http://wodeshijie.com"))
分析一下此程序的执行流程：
-
首先，构建生成器函数，并利用器创建生成器（对象）
f。 -
使用生成器
f调用无参的send()函数，其功能和next()函数完全相同，因此开始执行生成器函数，即执行到第一个yield "hello"语句，该语句会返回"hello"字符串，然后程序停止到此处（注意，此时还未执行对bar_a的赋值操作）。 -
下面开始使用生成器
f调用有参的send()函数，首先它会将暂停的程序开启，同时还会将其参数“我的世界”赋值给当前yield语句的接收者，也就是bar_a变量。程序一直执行完yield bar_a再次暂停，因此会输出“我的世界”。
4） 最后依旧是调用有参的send()函数，同样它会启动餐厅的程序，同时将参数“http://wodeshijie.com”传给 bar_b，然后执行完yield bar_b后（输出 http://wodeshijie.com），程序执行再次暂停。
因此，该程序的执行结果为：
hello
我的世界
http://wodeshijie.com
生成器close()方法
当程序在生成器函数中遇到yield语句暂停运行时，此时如果调用close()方法，会阻止生成器函数继续执行，该函数会在程序停止运行的位置抛出GeneratorExit异常。
举个例子：
def foo():
try:
yield 1
except GeneratorExit:
print('捕获到 GeneratorExit')
f = foo()
print(next(f))
f.close()
程序执行结果为：
1
捕获到 GeneratorExit
注意，虽然通过捕获GeneratorExit异常，可以继续执行生成器函数中剩余的代码，带这部分代码中不能再包含yield语句，否则程序会抛出RuntimeError异常。例如：
def foo():
try:
yield 1
except GeneratorExit:
print('捕获到 GeneratorExit')
yield 2 #抛出 RuntimeError 异常
f = foo()
print(next(f))
f.close()
程序执行结果为：
1
捕获到 GeneratorExit Traceback (most recent call last):
File "D:\python3.6\1.py", line 10, in <module>
f.close()
RuntimeError: generator ignored GeneratorExit
另外，生成器函数一旦使用close()函数停止运行，后续将无法再调用next()函数或者__next__()方法启动执行，否则会抛出StopIteration异常。例如：
def foo():
yield "c.biancheng.net"
print("生成器停止执行")
f = foo()
print(next(f)) #输出 "c.biancheng.net"
f.close()
next(f) #原本应输出"生成器停止执行"
程序执行结果为：
c.biancheng.net
Traceback (most recent call last):
File "D:\python3.6\1.py", line 8, in <module>
next(f) #原本应输出"生成器停止执行"
StopIteration
生成器throw()方法
生成器throw()方法的功能是，在生成器函数执行暂停处，抛出一个指定的异常，之后程序会继续执行生成器函数中后续的代码，直到遇到下一个yield语句。需要注意的是，如果到剩余代码执行完毕没有遇到下一个yield语句，则程序会抛出StopIteration异常。
举个例子：
def foo():
try:
yield 1
except ValueError:
print('捕获到 ValueError')
f = foo()
print(next(f))
f.throw(ValueError)
程序执行结果为：
1
捕获到 ValueError
Traceback (most recent call last):
File "D:\python3.6\1.py", line 9, in <module>
f.throw(ValueError)
StopIteration
显然，一开始生成器函数在yield 1处暂停执行，当执行throw()方法时，它会先抛出ValueError异常，然后继续执行后续代码找到下一个yield语句，该程序中由于后续不再有yield语句，因此程序执行到最后，会抛出一个StopIteration异常。
@函数装饰器及用法
前面章节中，我们已经讲解了Python内置的3种函数装饰器，分别是＠staticmethod、＠classmethod和@property，其中staticmethod()、classmethod()和property()都是Python的内置函数。
那么，函数装饰器的工作原理是怎样的呢？假设用funA()函数装饰器去装饰funB()函数，如下所示：
#funA 作为装饰器函数
def funA(fn):
#...
fn() # 执行传入的fn参数
#...
return '...'
@funA
def funB():
#...
实际上，上面程序完全等价于下面的程序：
def funA(fn):
#...
fn() # 执行传入的fn参数
#...
return '...'
def funB():
#...
funB = funA(funB)
通过比对以上2段程序不难发现，使用函数装饰器A()去装饰另一个函数B()，其底层执行了如下2步操作：
- 将
B作为参数传给A()函数； - 将
A()函数执行完成的返回值反馈回B。
举个实例：
#funA 作为装饰器函数
def funA(fn):
print("我的世界")
fn() # 执行传入的fn参数
print("http://wodeshijie.com")
return "装饰器函数的返回值"
@funA
def funB():
print("学习 Python")
程序执行流程为：
我的世界
学习 Python
http://wodeshijie.com
在此基础上，如果在程序末尾添加如下语句：
print(funB)
其输出结果为：
装饰器函数的返回值
显然，被“＠函数”修饰的函数不再是原来的函数，而是被替换成一个新的东西（取决于装饰器的返回值），即如果装饰器函数的返回值为普通变量，那么被修饰的函数名就变成了变量名；同样，如果装饰器返回的是一个函数的名称，怎么被修饰的函数名依然表示一个函数。
实际上，所谓函数装饰器，就是通过装饰器函数，在不修改原函数的前提下，来对函数的功能进行合理的扩充。
带参数的函数装饰器
在分析 funA() 函数装饰器和funB()函数的关系时，细心的读者可能会发现一个问题，即当funB()函数无参数时，可以直接将funB作为funA()的参数传入。但是，如果被修饰的函数本身带有参数，那应该如何传值呢？
比较简单的解决方法就是在函数装饰器中嵌套一个函数，该函数带有的参数个数和被装饰器修饰的函数相同。例如：
def funA(fn):
# 定义一个嵌套函数
def say(arc):
print("你的世界:",arc)
return say
@funA
def funB(arc):
print("funB():", a)
funB("http://nideshijie.com")
程序执行结果为：
你的世界: http://nideshijie.com
这里有必要给读者分析一下这个程序，其实，它和如下程序是等价的：
def funA(fn):
# 定义一个嵌套函数
def say(arc):
print("你的世界:",arc)
return say
def funB(arc):
print("funB():", a)
funB = funA(funB)
funB("http://nideshijie.com")
如果运行此程序会发现，它的输出结果和上面程序相同。
显然，通过funB()函数被装饰器funA()修饰，funB就被赋值为say。这意味着，虽然我们在程序显式调用的是funB()函数，但其实执行的是装饰器嵌套的say()函数。
但还有一个问题需要解决，即如果当前程序中，有多个（≥ 2）函数被同一个装饰器函数修饰，这些函数带有的参数个数并不相等，怎么办呢？
最简单的解决方式是用*args 和 **kwargs作为装饰器内部嵌套函数的参数，*args 和**kwargs表示接受任意数量和类型的参数。举个例子：
def funA(fn):
# 定义一个嵌套函数
def say(*args,**kwargs):
fn(*args,**kwargs)
return say
@funA
def funB(arc):
print("我的世界：",arc)
@funA
def other_funB(name,arc):
print(name,arc)
funB("http://wodeshijie.com")
other_funB("你的世界：","http://nideshijie.com")
运行结果为：
我的世界： http://wodeshijie.com
你的世界： http://nideshijie.com
函数装饰器可以嵌套
上面示例中，都是使用一个装饰器的情况，但实际上，Python也支持多个装饰器，比如：
@funA
@funB
@funC
def fun():
#...
上面程序的执行顺序是里到外，所以它等效于下面这行代码：
fun = funA( funB ( funC (fun) ) )
函数装饰器用途
装饰器用于身份认证
首先是最常见的身份认证的应用。这个很容易理解，举个最常见的例子，大家登录微信，需要输入用户名密码，然后点击确认，这样服务器端便会查询你的用户名是否存在、是否和密码匹配等等。如果认证通过，就可以顺利登录；反之，则提示你登录失败。
再比如一些网站，你不登录也可以浏览内容，但如果你想要发布文章或留言，在点击发布时，服务器端便会查询你是否登录。如果没有登录，就不允许这项操作等等。
如下是一个实现身份认证的简单示例：
import functools
def authenticate(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
request = args[0]
# 如果用户处于登录状态
if check_user_logged_in(request):
# 执行函数 post_comment()
return func(*args, **kwargs)
else:
raise Exception('Authentication failed')
return wrapper
@authenticate
def post_comment(request, ...)
...
注意，对于函数来说，它也有自己的一些属性，例如__name__属性，代码中@functools.wraps(func)也是一个装饰器，如果不使用它，则 post_comment.__name__的值为wrapper。而使用它之后，则post_comment.__name__的值依然为post_comment。
上面这段代码中，定义了装饰器authenticate，函数post_comment()则表示发表用户对某篇文章的评论，每次调用这个函数前，都会先检查用户是否处于登录状态，如果是登录状态，则允许这项操作；如果没有登录，则不允许。
装饰器用于日志记录
日志记录同样是很常见的一个案例。在实际工作中，如果你怀疑某些函数的耗时过长，导致整个系统的延迟增加，想在线上测试某些函数的执行时间，那么，装饰器就是一种很常用的手段。
我们通常用下面的方法来表示：
import time
import functools
def log_execution_time(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start = time.perf_counter()
res = func(*args, **kwargs)
end = time.perf_counter()
print('{} took {} ms'.format(func.__name__, (end - start) * 1000))
return res
return wrapper
@log_execution_time
def calculate_similarity(items):
...
这里，装饰器log_execution_time记录某个函数的运行时间，并返回其执行结果。如果你想计算任何函数的执行时间，在这个函数上方加上@log_execution_time即可。
装饰器用于输入合理性检查
在大型公司的机器学习框架中，调用机器集群进行模型训练前，往往会用装饰器对其输入（往往是很长的json文件）进行合理性检查。这样就可以大大避免输入不正确对机器造成的巨大开销。
它的写法往往是下面的格式：
import functools
def validation_check(input):
@functools.wraps(func)
def wrapper(*args, **kwargs):
... # 检查输入是否合法
@validation_check
def neural_network_training(param1, param2, ...):
...
其实在工作中，很多情况下都会出现输入不合理的现象。因为我们调用的训练模型往往很复杂，输入的文件有成千上万行，很多时候确实也很难发现。
试想一下，如果没有输入的合理性检查，很容易出现“模型训练了好几个小时后，系统却报错说输入的一个参数不对，成果付之一炬”的现象。这样的“惨案”，大大减缓了开发效率，也对机器资源造成了巨大浪费。
缓存装饰器
关于缓存装饰器的用法，其实十分常见，这里以Python内置的LRU cache为例来说明。
LRU cache，在Python中的表示形式是@lru_cache。@lru_cache会缓存进程中的函数参数和结果，当缓存满了以后，会删除最近最久未使用的数据。
正确使用缓存装饰器，往往能极大地提高程序运行效率。举个例子，大型公司服务器端的代码中往往存在很多关于设备的检查，比如使用的设备是安卓还是iPhone，版本号是多少。这其中的一个原因，就是一些新的功能，往往只在某些特定的手机系统或版本上才有（比如Android v200+）。
这样一来，我们通常使用缓存装饰器来包裹这些检查函数，避免其被反复调用，进而提高程序运行效率，比如写成下面这样：
@lru_cache
def check(param1, param2, ...) # 检查用户设备类型，版本号等等
...