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 = 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 = "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+内存地址”，而如果对该方法进行重写，可以为其制作自定义的自我描述信息。

__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 = "C语言中文网"
        self.add = "http://c.biancheng.net"
    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 = "C语言中文网"
        self.add = "http://c.biancheng.net"
    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 = "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教程

注意，无法通过类似的方式修改类变量的值。

setattr()、getattr()、hasattr()函数用法详解

除了前面介绍的几个类中的特殊方法外，本节再介绍 3 个常用的函数，分别是hasattr()、getattr()以及setattr()。

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()函数的匹配范围内。因此，我们只能通过该函数判断实例对象是否包含该名称的属性或方法，但不能精确判断，该名称代表的是属性还是方法。

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错误。

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:
    pass

clangs = CLanguage()
setattr(clangs,"name","C语言中文网")
setattr(clangs,"say",say)
print(clangs.name)
clangs.say(clangs)

程序执行结果为：

C语言中文网
我正在学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("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__()方法。

可重载运算符

其实在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 个方法：

1. __next__(self)：返回容器的下一个元素。
2. __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 "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]=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 "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

生成器

前面章节中，已经详细介绍了什么是迭代器。生成器本质上也是迭代器，不过它比较特殊。

以list容器为例，在使用该容器迭代一组数据时，必须事先将所有数据存储到容器中，才能开始迭代；而生成器却不同，它可以实现在迭代的同时生成元素。

也就是说，对于可以用某种算法推算得到的多个数据，生成器并不会一次性生成它们，而是什么时候需要，才什么时候生成。

不仅如此，生成器的创建方式也比迭代器简单很多，大体分为以下2步：

1. 定义一个以yield关键字标识返回值的函数；
2. 调用刚刚创建的函数，即可创建一个生成器。

举个例子：

def intNum():
    print("开始执行")
    for i in range(5):
        yield i
        print("继续执行")
num = intNum()

由此，我们就成功创建了一个num生成器对象。显然，和普通函数不同，number() 函数的返回值用的是yield关键字，而不是return关键字，此类函数又成为生成器函数。

和return相比，yield 除了可以返回相应的值，还有一个更重要的功能，即每当程序执行完该语句时，程序就会暂停执行。不仅如此，即便调用生成器函数，Python解释器也不会执行函数中的代码，它只会返回一个生成器（对象）。

要想使生成器函数得以执行，或者想使执行完yield语句立即暂停的程序得以继续执行，有以下2种方式：

1. 通过生成器（上面程序中的 num）调用next()内置函数或者__next__()方法；
2. 通过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循环的遍历过程是类似的。

生成器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("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

生成器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步操作：

1. 将B作为参数传给A()函数；
2. 将A()函数执行完成的返回值反馈回B。

举个实例：

#funA 作为装饰器函数
def funA(fn):
    print("C语言中文网")
    fn() # 执行传入的fn参数
    print("http://c.biancheng.net")
    return "装饰器函数的返回值"

@funA
def 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

@funA
def 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 say

def 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

@funA
def funB(arc):
    print("C语言中文网：",arc)

@funA
def 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
@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, ...) # 检查用户设备类型，版本号等等
    ...