第九章 Python类特殊成员（属性和方法）
9.1 Python 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 = attributetest1 = 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() 不限于返回同一个类的实例，所以很容易被滥用，不负责任地使用这种方法可能会对代码有害，所以要谨慎使用。一般来说，对于特定问题，最好搜索其他可用的解决方案，最好不要影响对象的创建过程，使其违背程序员的预期。比如说，前面提到的覆写不可变类型初始化的例子，完全可以用工厂方法（一种设计模式）来替代。
Python中大量使用 new() 方法且合理的，就是 MetaClass 元类。有关元类的介绍，可阅读《Python MetaClass元类》一节。
9.2 Python repr()方法：显示属性
前面章节中，我们经常会直接输出类的实例化对象，例如：
class CLanguage: passclangs = 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 = "C语言中文网" self.add = "http://c.biancheng.net" def __repr__(self): return "CLanguage[name="+ self.name +",add=" + self.add +"]"clangs = CLanguage()print(clangs)
程序运行结果为：
CLanguage[name=C语言中文网,add=http://c.biancheng.net]
由此可见，repr() 方法是类的实例化对象用来做“自我介绍”的方法，默认情况下，它会返回当前对象的“类名+object at+内存地址”，而如果对该方法进行重写，可以为其制作自定义的自我描述信息。
9.3 Python __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 = clangsdel clangsprint("***********")
程序运行结果为：
调用 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 clprint("-----------")
则程序的执行结果为：
调用 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() 方法
9.4 Python dir()用法：列出对象的所有属性（方法）名
前面在介绍 Python 内置函数时，提到了 dir() 函数，通过此函数可以某个对象拥有的所有的属性名和方法名，该函数会返回一个包含有所有属性名和方法名的有序列表。
举个例子：
class CLanguage: def __init__ (self,): self.name = "C语言中文网" self.add = "http://c.biancheng.net" def say(): passclangs = 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 = "C语言中文网" self.add = "http://c.biancheng.net" def say(): passclangs = 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() 函数输出的数据是相同，仅仅顺序不同。
9.5 Python dict属性：查看对象内部所有属性名和属性值组成的字典
在 Python 类的内部，无论是类属性还是实例属性，都是以字典的形式进行存储的，其中属性名作为键，而值作为该键对应的值。
为了方便用户查看类中包含哪些属性，Python 类提供了 dict 属性。需要注意的一点是，该属性可以用类名或者类的实例对象来调用，用类名直接调用 dict，会输出该由类中所有类属性组成的字典；而使用类的实例对象调用 dict，会输出由类中所有实例属性组成的字典。
举个例子：
class CLanguage: a = 1 b = 2 def __init__ (self): self.name = "C语言中文网" self.add = "http://c.biancheng.net"#通过类名调用__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': 'C语言中文网', 'add': 'http://c.biancheng.net'}
不仅如此，对于具有继承关系的父类和子类来说，父类有自己的 dict，同样子类也有自己的 dict，它不会包含父类的 dict。例如：
class CLanguage: a = 1 b = 2 def __init__ (self): self.name = "C语言中文网" self.add = "http://c.biancheng.net" class CL(CLanguage): c = 1 d = 2 def __init__ (self): self.na = "Python教程" self.ad = "http://c.biancheng.net/python"#父类名调用__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': 'C语言中文网', 'add': 'http://c.biancheng.net'} {'na': 'Python教程', 'ad': 'http://c.biancheng.net/python'}
显然，通过子类直接调用的 dict 中，并没有包含父类中的 a 和 b 类属性；同样，通过子类对象调用的 dict，也没有包含父类对象拥有的 name 和 add 实例属性。
除此之外，借助由类实例对象调用 dict 属性获取的字典，可以使用字典的方式对其中实例属性的值进行修改，例如：
class CLanguage: a = "aaa" b = 2 def __init__ (self): self.name = "C语言中文网" self.add = "http://c.biancheng.net"#通过类实例对象调用 __dict__clangs = CLanguage()print(clangs.__dict__)clangs.__dict__['name'] = "Python教程"print(clangs.name)
程序运行结果为：
{'name': 'C语言中文网', 'add': 'http://c.biancheng.net'} Python教程
注意，无法通过类似的方式修改类变量的值。
9.6 Python setattr()、getattr()、hasattr()函数用法详解
除了前面介绍的几个类中的特殊方法外，本节再介绍 3 个常用的函数，分别是 hasattr()、getattr() 以及 setattr。
Python hasattr()函数
hasattr() 函数用来判断某个类实例对象是否包含指定名称的属性或方法。该函数的语法格式如下：
hasattr(obj, name)
其中 obj 指的是某个类的实例对象，name 表示指定的属性名或方法名。同时，该函数会将判断的结果（True 或者 False）作为返回值反馈回来。
举个例子：
class CLanguage: def __init__ (self): self.name = "C语言中文网" self.add = "http://c.biancheng.net" def say(self): print("我正在学Python")clangs = CLanguage()print(hasattr(clangs,"name"))print(hasattr(clangs,"add"))print(hasattr(clangs,"say"))
程序输出结果为： True True True
显然，无论是属性名还是方法名，都在 hasattr() 函数的匹配范围内。因此，我们只能通过该函数判断实例对象是否包含该名称的属性或方法，但不能精确判断，该名称代表的是属性还是方法。
Python getattr() 函数
getattr() 函数获取某个类实例对象中指定属性的值。没错，和 hasattr() 函数不同，该函数只会从类对象包含的所有属性中进行查找。
getattr() 函数的语法格式如下：
getattr(obj, name[, default])
其中，obj 表示指定的类实例对象，name 表示指定的属性名，而 default 是可选参数，用于设定该函数的默认返回值，即当函数查找失败时，如果不指定 default 参数，则程序将直接报 AttributeError 错误，反之该函数将返回 default 指定的值。
举个例子：
class CLanguage: def __init__ (self): self.name = "C语言中文网" self.add = "http://c.biancheng.net" def say(self): print("我正在学Python")clangs = CLanguage()print(getattr(clangs,"name"))print(getattr(clangs,"add"))print(getattr(clangs,"say"))print(getattr(clangs,"display",'nodisplay'))
程序执行结果为：
C语言中文网 http://c.biancheng.net <bound method CLanguage.say of <main.CLanguage object at 0x000001FC2F2E3198>> nodisplay
可以看到，对于类中已有的属性，getattr() 会返回它们的值，而如果该名称为方法名，则返回该方法的状态信息；反之，如果该明白不为类对象所有，要么返回默认的参数，要么程序报 AttributeError 错误。
Python setattr()函数
setattr() 函数的功能相对比较复杂，它最基础的功能是修改类实例对象中的属性值。其次，它还可以实现为实例对象动态添加属性或者方法。
setattr() 函数的语法格式如下：
setattr(obj, name, value)
首先，下面例子演示如何通过该函数修改某个类实例对象的属性值：
class CLanguage: def __init__ (self): self.name = "C语言中文网" self.add = "http://c.biancheng.net" def say(self): print("我正在学Python")clangs = CLanguage()print(clangs.name)print(clangs.add)setattr(clangs,"name","Python教程")setattr(clangs,"add","http://c.biancheng.net/python")print(clangs.name)print(clangs.add)
程序运行结果为：
C语言中文网 http://c.biancheng.net Python教程 http://c.biancheng.net/python
甚至利用 setattr() 函数，还可以将类属性修改为一个类方法，同样也可以将类方法修改成一个类属性。例如：
def say(self): print("我正在学Python")class CLanguage: def __init__ (self): self.name = "C语言中文网" self.add = "http://c.biancheng.net"clangs = CLanguage()print(clangs.name)print(clangs.add)setattr(clangs,"name",say)clangs.name(clangs)
程序运行结果为：
C语言中文网 http://c.biancheng.net 我正在学Python
显然，通过修改 name 属性的值为 say（这是一个外部定义的函数），原来的 name 属性就变成了一个 name() 方法。
使用 setattr() 函数对实例对象中执行名称的属性或方法进行修改时，如果该名称查找失败，Python 解释器不会报错，而是会给该实例对象动态添加一个指定名称的属性或方法。例如：
def say(self): print("我正在学Python")class CLanguage: passclangs = CLanguage()setattr(clangs,"name","C语言中文网")setattr(clangs,"say",say)print(clangs.name)clangs.say(clangs)
程序执行结果为：
C语言中文网 我正在学Python
可以看到，虽然 CLanguage 为空类，但通过 setattr() 函数，我们为 clangs 对象动态添加了一个 name 属性和一个 say() 方法。
9.7 Python issubclass和isinstance函数：检查类型
Python 提供了如下两个函数来检查类型：
-
issubclass(cls, class_or_tuple)：检查 cls 是否为后一个类或元组包含的多个类中任意类的子类。
-
isinstance(obj, class_or_tuple)：检查 obj 是否为后一个类或元组包含的多个类中任意类的对象。
通过使用上面两个函数，程序可以方便地先执行检查，然后才调用方法，这样可以保证程序不会出现意外情况。
如下程序示范了通过这两个函数来检查类型：
# 定义一个字符串hello = "Hello";# "Hello"是str类的实例，输出Trueprint('"Hello"是否是str类的实例: ', isinstance(hello, str))# "Hello"是object类的子类的实例，输出Trueprint('"Hello"是否是object类的实例: ', isinstance(hello, object))# str是object类的子类，输出Trueprint('str是否是object类的子类: ', issubclass(str, object))# "Hello"不是tuple类及其子类的实例，输出Falseprint('"Hello"是否是tuple类的实例: ', isinstance(hello, tuple))# str不是tuple类的子类，输出Falseprint('str是否是tuple类的子类: ', issubclass(str, tuple))# 定义一个列表my_list = [2, 4]# [2, 4]是list类的实例，输出Trueprint('[2, 4]是否是list类的实例: ', isinstance(my_list, list))# [2, 4]是object类的子类的实例，输出Trueprint('[2, 4]是否是object类及其子类的实例: ', isinstance(my_list, object))# list是object类的子类，输出Trueprint('list是否是object类的子类: ', issubclass(list, object))# [2, 4]不是tuple类及其子类的实例，输出Falseprint('[2, 4]是否是tuple类及其子类的实例: ', isinstance([2, 4], tuple))# list不是tuple类的子类，输出Falseprint('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的子类，输出Falseprint('str是否为list或tuple的子类: ', issubclass(str, (list, tuple)))# str是list或tuple或object的子类，输出Trueprint('str是否为list或tuple或object的子类 ', issubclass(str, (list, tuple, object)))
此外，Python 为所有类都提供了一个 bases 属性，通过该属性可以查看该类的所有直接父类，该属性返回所有直接父类组成的元组。例如如下代码：
class A: passclass B: passclass C(A, B): passprint('类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'>]
9.8 Python call()方法（详解版）
本节再介绍 Python 类中一个非常特殊的实例方法，即 call()。该方法的功能类似于在类中重载 () 运算符，使得类实例对象可以像调用普通函数那样，以“对象名()”的形式使用。
举个例子：
class CLanguage: # 定义__call__方法 def __call__(self,name,add): print("调用__call__()方法",name,add)clangs = CLanguage()clangs("C语言中文网","http://c.biancheng.net")
程序执行结果为：
调用call()方法 C语言中文网 http://c.biancheng.net
可以看到，通过在 CLanguage 类中实现 call() 方法，使的 clangs 实例对象变为了可调用对象。
Python 中，凡是可以将 () 直接应用到自身并执行，都称为可调用对象。可调用对象包括自定义的函数、Python 内置函数以及本节所讲的类实例对象。
对于可调用对象，实际上“名称()”可以理解为是“名称.call()”的简写。仍以上面程序中定义的 clangs 实例对象为例，其最后一行代码还可以改写为如下形式：
clangs.__call__("C语言中文网","http://c.biancheng.net")
运行程序会发现，其运行结果和之前完全相同。
这里再举一个自定义函数的例子，例如：
def say(): print("Python教程：http://c.biancheng.net/python")say()say.__call__()
程序执行结果为：
Python教程：http://c.biancheng.net/python Python教程：http://c.biancheng.net/python
不仅如此，类中的实例方法也有以上 2 种调用方式，这里不再举例，有兴趣的读者可自行编写代码尝试。
用 call() 弥补 hasattr() 函数的短板
前面章节介绍了 hasattr() 函数的用法，该函数的功能是查找类的实例对象中是否包含指定名称的属性或者方法，但该函数有一个缺陷，即它无法判断该指定的名称，到底是类属性还是类方法。
要解决这个问题，我们可以借助可调用对象的概念。要知道，类实例对象包含的方法，其实也属于可调用对象，但类属性却不是。举个例子：
class CLanguage: def __init__ (self): self.name = "C语言中文网" self.add = "http://c.biancheng.net" 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() 方法。
9.9 什么是运算符重载，Python可重载运算符有哪些？
前面章节介绍了 Python 中的各个序列类型，每个类型都有其独特的操作方法，例如列表类型支持直接做加法操作实现添加元素的功能，字符串类型支持直接做加法实现字符串的拼接功能，也就是说，同样的运算符对于不同序列类型的意义是不一样的，这是怎么做到的呢？
其实在 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，调用 reprprint (str (myc)) #格式化对象 myc ，输出"name:Anna;age:42"print(myc < mycl) #比较 myc<mycl 的结果，输出 Falseprint (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 | “或”运算符 |，如果没有重载 ior，则在类似 X|Y、X|=Y 这样的语句中，“或”符号生效 |
| 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 方法（常用于做一些清理、扫尾的工作） |
9.10 Python重载运算符实现自定义序列
除了前面章节介绍的几个类特殊方法（方法名以双下划线（__）开头和结尾），在 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'] = 1dic['b'] = 2print(len(dic))dic['a'] = 3dic['c'] = 4print(dic['a'])#删除指定元素，调用 __delitem__() 方法del dic['a']print(dic['a'])print(len(dic))
程序执行结果为：
0 2 3 None 2
9.11 什么是迭代器，Python迭代器及其用法
前面章节中，已经对列表（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 += 1mylist = listDemo()mylist[0]=1mylist[1]=2for 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 "C:\Users\mengma\Desktop\demo.py", 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]=1mylist[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 个参数相同。
迭代器本身是一个底层的特性和概念，在程序中并不常用，但它为生成器这一更有趣的特性提供了基础。有关生成器的相关知识，会在后续章节中介绍。
9.12 Python项目实战之迭代器实现字符串的逆序输出
《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 "C:\Users\mengma\Desktop\demo.py", line 11, in <module> for c in revstr: File "C:\Users\mengma\Desktop\demo.py", 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
9.13 Python生成器详解
前面章节中，已经详细介绍了什么是迭代器。生成器本质上也是迭代器，不过它比较特殊。
以 list 容器为例，在使用该容器迭代一组数据时，必须事先将所有数据存储到容器中，才能开始迭代；而生成器却不同，它可以实现在迭代的同时生成元素。
也就是说，对于可以用某种算法推算得到的多个数据，生成器并不会一次性生成它们，而是什么时候需要，才什么时候生成。
不仅如此，生成器的创建方式也比迭代器简单很多，大体分为以下 2 步：
-
定义一个以 yield 关键字标识返回值的函数；
-
调用刚刚创建的函数，即可创建一个生成器。
举个例子：
def intNum(): print("开始执行") for i in range(5): yield i print("继续执行")num = intNum()
由此，我们就成功创建了一个 num 生成器对象。显然，和普通函数不同，intNum() 函数的返回值用的是 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 继续执行
这里有必要给读者分析一个程序的执行流程： 1) 首先，在创建有 num 生成器的前提下，通过其调用 next() 内置函数，会使 Python 解释器开始执行 intNum() 生成器函数中的代码，因此会输出“开始执行”，程序会一直执行到yield i，而此时的 i==0，因此 Python 解释器输出“0”。由于受到 yield 的影响，程序会在此处暂停。
2) 然后，我们使用 num 生成器调用 next() 方法，该方法的作用和 next() 函数完全相同（事实上，next() 函数的底层执行的也是 next() 方法），它会是程序继续执行，即输出“继续执行”，程序又会执行到yield i，此时 i==1，因此输出“1”，然后程序暂停。
3) 最后，我们使用 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 循环的遍历过程是类似的。
相比迭代器，生成器最明显的优势就是节省内存空间，即它不会一次性生成所有的数据，而是什么时候需要，什么时候生成。
9.14 Python生成器（send，close，throw）方法详解
《Python生成器》一节中，详细介绍了如何创建一个生成器，以及生成器的基础用法。本节将在其基础上，继续讲解和生成器有关的一些方法。
Python生成器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_bf = foo()print(f.send(None))print(f.send("C语言中文网"))print(f.send("http://c.biancheng.net"))
分析一下此程序的执行流程： 1) 首先，构建生成器函数，并利用器创建生成器（对象）f 。
2) 使用生成器 f 调用无参的 send() 函数，其功能和 next() 函数完全相同，因此开始执行生成器函数，即执行到第一个 yield "hello" 语句，该语句会返回 "hello" 字符串，然后程序停止到此处（注意，此时还未执行对 bar_a 的赋值操作）。
3) 下面开始使用生成器 f 调用有参的 send() 函数，首先它会将暂停的程序开启，同时还会将其参数“C语言中文网”赋值给当前 yield 语句的接收者，也就是 bar_a 变量。程序一直执行完 yield bar_a 再次暂停，因此会输出“C语言中文网”。
4） 最后依旧是调用有参的 send() 函数，同样它会启动餐厅的程序，同时将参数“http://c.biancheng.net”传给 bar_b，然后执行完 yield bar_b 后（输出 http://c.biancheng.net），程序执行再次暂停。
因此，该程序的执行结果为：
hello C语言中文网 http://c.biancheng.net
Python生成器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
Python生成器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 异常。
9.15 Python @函数装饰器及用法（超级详细）
前面章节中，我们已经讲解了 Python 内置的 3 种函数装饰器，分别是 ＠staticmethod、＠classmethod 和 @property，其中 staticmethod()、classmethod() 和 property() 都是 Python 的内置函数。
那么，函数装饰器的工作原理是怎样的呢？假设用 funA() 函数装饰器去装饰 funB() 函数，如下所示：
#funA 作为装饰器函数def funA(fn): #... fn() # 执行传入的fn参数 #... return '...'@funAdef 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("C语言中文网") fn() # 执行传入的fn参数 print("http://c.biancheng.net") return "装饰器函数的返回值"@funAdef funB(): print("学习 Python")
程序执行流程为：
C语言中文网 学习 Python http://c.biancheng.net
在此基础上，如果在程序末尾添加如下语句：
print(funB)
其输出结果为：
装饰器函数的返回值
显然，被“＠函数”修饰的函数不再是原来的函数，而是被替换成一个新的东西（取决于装饰器的返回值），即如果装饰器函数的返回值为普通变量，那么被修饰的函数名就变成了变量名；同样，如果装饰器返回的是一个函数的名称，那么被修饰的函数名依然表示一个函数。
实际上，所谓函数装饰器，就是通过装饰器函数，在不修改原函数的前提下，来对函数的功能进行合理的扩充。
带参数的函数装饰器
在分析 funA() 函数装饰器和 funB() 函数的关系时，细心的读者可能会发现一个问题，即当 funB() 函数无参数时，可以直接将 funB 作为 funA() 的参数传入。但是，如果被修饰的函数本身带有参数，那应该如何传值呢？
比较简单的解决方法就是在函数装饰器中嵌套一个函数，该函数带有的参数个数和被装饰器修饰的函数相同。例如：
def funA(fn): # 定义一个嵌套函数 def say(arc): print("Python教程:",arc) return say@funAdef funB(arc): print("funB():", a)funB("http://c.biancheng.net/python")
程序执行结果为：
Python教程: http://c.biancheng.net/python
这里有必要给读者分析一下这个程序，其实，它和如下程序是等价的：
def funA(fn):
# 定义一个嵌套函数
def say(arc):
print("Python教程:",arc)
return saydef funB(arc):
print("funB():", a)
funB = funA(funB)funB("http://c.biancheng.net/python")
如果运行此程序会发现，它的输出结果和上面程序相同。
显然，通过 funB() 函数被装饰器 funA() 修饰，funB 就被赋值为 say。这意味着，虽然我们在程序显式调用的是 funB() 函数，但其实执行的是装饰器嵌套的 say() 函数。
但还有一个问题需要解决，即如果当前程序中，有多个（≥ 2）函数被同一个装饰器函数修饰，这些函数带有的参数个数并不相等，怎么办呢？
最简单的解决方式是用 args 和 **kwargs 作为装饰器内部嵌套函数的参数，args 和 **kwargs 表示接受任意数量和类型的参数。举个例子：
def funA(fn): # 定义一个嵌套函数 def say(*args,**kwargs): fn(*args,**kwargs) return say@funAdef funB(arc): print("C语言中文网：",arc)@funAdef other_funB(name,arc): print(name,arc)funB("http://c.biancheng.net")other_funB("Python教程：","http://c.biancheng.net/python")
运行结果为：
C语言中文网： http://c.biancheng.net Python教程： http://c.biancheng.net/python
函数装饰器可以嵌套
上面示例中，都是使用一个装饰器的情况，但实际上，Python 也支持多个装饰器，比如：
@funA@funB@funCdef fun(): #...
上面程序的执行顺序是里到外，所以它等效于下面这行代码：
fun = funA( funB ( funC (fun) ) )
这里不再给出具体实例，有兴趣的读者可自行编写程序进行测试。
9.16 Python装饰器的应用场景
前面章节已经讲解了装饰器的基本概念及用法，本节将结合实际工作中的几个例子，带读者加深对它的理解。
装饰器用于身份认证
首先是最常见的身份认证的应用。这个很容易理解，举个最常见的例子，大家登录微信，需要输入用户名密码，然后点击确认，这样服务器端便会查询你的用户名是否存在、是否和密码匹配等等。如果认证通过，就可以顺利登录；反之，则提示你登录失败。
再比如一些网站，你不登录也可以浏览内容，但如果你想要发布文章或留言，在点击发布时，服务器端便会查询你是否登录。如果没有登录，就不允许这项操作等等。
如下是一个实现身份认证的简单示例：
import functoolsdef 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 @authenticatedef post_comment(request, ...) ...
注意，对于函数来说，它也有自己的一些属性，例如 name 属性，代码中 @functools.wraps(func) 也是一个装饰器，如果不使用它，则 post_comment.name 的值为 wrapper。而使用它之后，则 post_comment.name 的值依然为 post_comment。
上面这段代码中，定义了装饰器 authenticate，函数 post_comment() 则表示发表用户对某篇文章的评论，每次调用这个函数前，都会先检查用户是否处于登录状态，如果是登录状态，则允许这项操作；如果没有登录，则不允许。
装饰器用于日志记录
日志记录同样是很常见的一个案例。在实际工作中，如果你怀疑某些函数的耗时过长，导致整个系统的延迟增加，想在线上测试某些函数的执行时间，那么，装饰器就是一种很常用的手段。
我们通常用下面的方法来表示：
import timeimport functoolsdef 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_timedef calculate_similarity(items): ...
这里，装饰器 log_execution_time 记录某个函数的运行时间，并返回其执行结果。如果你想计算任何函数的执行时间，在这个函数上方加上@log_execution_time即可。
装饰器用于输入合理性检查
在大型公司的机器学习框架中，调用机器集群进行模型训练前，往往会用装饰器对其输入（往往是很长的 json 文件）进行合理性检查。这样就可以大大避免输入不正确对机器造成的巨大开销。
它的写法往往是下面的格式：
import functoolsdef validation_check(input): @functools.wraps(func) def wrapper(*args, **kwargs): ... # 检查输入是否合法 @validation_checkdef neural_network_training(param1, param2, ...): ...
其实在工作中，很多情况下都会出现输入不合理的现象。因为我们调用的训练模型往往很复杂，输入的文件有成千上万行，很多时候确实也很难发现。
试想一下，如果没有输入的合理性检查，很容易出现“模型训练了好几个小时后，系统却报错说输入的一个参数不对，成果付之一炬”的现象。这样的“惨案”，大大减缓了开发效率，也对机器资源造成了巨大浪费。
缓存装饰器
关于缓存装饰器的用法，其实十分常见，这里以 Python 内置的 LRU cache 为例来说明。
LRU cache，在 Python 中的表示形式是 @lru_cache。@lru_cache 会缓存进程中的函数参数和结果，当缓存满了以后，会删除最近最久未使用的数据。
正确使用缓存装饰器，往往能极大地提高程序运行效率。举个例子，大型公司服务器端的代码中往往存在很多关于设备的检查，比如使用的设备是安卓还是 iPhone，版本号是多少。这其中的一个原因，就是一些新的功能，往往只在某些特定的手机系统或版本上才有（比如 Android v200+）。
这样一来，我们通常使用缓存装饰器来包裹这些检查函数，避免其被反复调用，进而提高程序运行效率，比如写成下面这样：
纯文本复制
@lru_cachedef check(param1, param2, ...) # 检查用户设备类型，版本号等等 ...
浙公网安备 33010602011771号