目录
用 __call__() 弥补 hasattr() 函数的短板
Python 类中，凡是以双下划线 "__" 开头和结尾命名的成员（属性和方法），都被称为类的特殊成员（特殊属性和特殊方法）。例如，类的 __init__(self) 构造方法就是典型的特殊方法。
Python 类中的特殊成员，其特殊性类似 C++ 类的 private 私有成员，即不能在类的外部直接调用，但允许借助类中的普通方法调用甚至修改它们。如果需要，还可以对类的特殊方法进行重写，从而实现一些特殊的功能。
__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 0x000001EBA17E3D88> abc
__new__(): <class '__main__.demoClass'> ('xyz',) {}
__init__(): <__main__.demoClass object at 0x000001EBA17E3C88> 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'>一般，在 __init__() 不够用的时候用 __new__() 。
__repr__()方法：显示属性
通常情况下，直接输出某个实例化对象，本意往往是想了解该对象的基本信息，例如该对象有哪些属性，它们的值各是多少等等。
默认情况下，我们得到的信息只会是“类名+object at+内存地址”
class Test:
pass
test = Test()
print(test)
print(test.__repr__())
结果：
<__main__.Test object at 0x000002A086619E08>
<__main__.Test object at 0x000002A086619E08>通过重写类的 __repr__() 方法即可。事实上，当我们输出某个实例化对象时，其调用的就是该对象的 __repr__() 方法，输出的是该方法的返回值。
class Test:
def __init__(self):
self.name = "Mr.Hu"
self.age = "18"
def __repr__(self):
return "你好，我是"+self.name+"我今年"+self.age+"了"
test = Test()
print(test)
结果：
你好，我是Mr.Hu我今年18了由此可见，__repr__() 方法是类的实例化对象用来做“自我介绍”的方法，默认情况下，它会返回当前对象的“类名+object at+内存地址”，而如果对该方法进行重写，可以为其制作自定义的自我描述信息。
即如果没有返回值，可通过__repr__()来给出。
__del__()方法：销毁对象
如果之前创建的类实例化对象后续不再使用，最好在适当位置手动将其销毁，释放其占用的内存空间（整个过程称为垃圾回收（简称GC））。
无论是手动销毁，还是 Python 自动帮我们销毁，都会调用 __del__() 方法。举个例子：
class Test:
def __init__(self):
print("调用 __init__() 方法构造对象")
def __del__(self):
print("调用__del__() 销毁对象，释放其空间")
test = Test()
del test
结果：
调用 __init__() 方法构造对象
调用__del__() 销毁对象，释放其空间但是，不要误认为，只要为该实例对象调用 __del__() 方法，该对象所占用的内存空间就会被释放。举个例子：
class Test:
def __init__(self):
print("调用 __init__() 方法构造对象")
def __del__(self):
print("调用__del__() 销毁对象，释放其空间")
test = Test()
t1 = test
del test
print("-----------")
结果：
调用 __init__() 方法构造对象
-----------
调用__del__() 销毁对象，释放其空间可以看到，当程序中有其它变量（比如这里的 t1）引用该实例对象时，即便手动调用 __del__() 方法，该方法也不会立即执行。这和 Python 的垃圾回收机制的实现有关。
Python 采用自动引用计数（简称 ARC）的方式实现垃圾回收机制。该方法的核心思想是：每个 Python 对象都会配置一个计数器，初始 Python 实例对象的计数器值都为 0，如果有变量引用该实例对象，其计数器的值会加 1，依次类推；反之，每当一个变量取消对该实例对象的引用，计数器会减 1。如果一个 Python 对象的的计数器值为 0，则表明没有变量引用该 Python 对象，即证明程序不再需要它，此时 Python 就会自动调用 __del__() 方法将其回收。
class Test:
def __init__(self):
print("调用 __init__() 方法构造对象")
def __del__(self):
print("调用__del__() 销毁对象，释放其空间")
test = Test()
t1 = test
del test
del t1
print("-----------")
结果：
调用 __init__() 方法构造对象
调用__del__() 销毁对象，释放其空间
-----------可以看到，当执行 del t1 语句时，其应用的对象实例对象 C 的计数器继续 -1（变为 0），对于计数器为 0 的实例对象，Python 会自动将其视为垃圾进行回收。
需要额外说明的是，如果我们重写子类的 __del__() 方法（父类为非 object 的类），则必须显式调用父类的 __del__() 方法，这样才能保证在回收子类对象时，其占用的资源（可能包含继承自父类的部分资源）能被彻底释放。为了说明这一点，这里举一个反例：
class Test:
def __del__(self):
print("调用父类 __del__() 方法")
class T1(Test):
def __del__(self):
print("调用子类 __del__() 方法")
t = T1()
del t
结果:
调用子类 __del__() 方法__dir__()用法：列出对象的所有属性（方法）名
通过此函数可以获得某个对象拥有的所有的属性名和方法名，该函数会返回一个包含有所有属性名和方法名的有序列表。
class Test:
def __init__ (self,):
self.name = "Mr.Hu"
self.age = "18"
def say():
pass
t = Test()
print(dir(t))
结果：
['__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__', 'age', 'name', 'say']
通过 dir() 函数，不仅仅输出本类中新添加的属性名和方法（最后 3 个），还会输出从父类（这里为 object 类）继承得到的属性名和方法名。
除了使用 dir() 函数，我们完全可以自行调用该对象具有的 __dir__() 方法。
t.__dir__()使用 __dir__() 方法和 dir() 函数输出的数据是相同，仅仅顺序不同。
hasattr()函数
hasattr() 函数用来判断某个类实例对象是否包含指定名称的属性或方法。该函数的语法格式如下：
hasattr(obj, name)
其中 obj 指的是某个类的实例对象，name 表示指定的属性名或方法名。同时，该函数会将判断的结果（True 或者 False）作为返回值反馈回来。
class Test:
height = "178"
def __init__ (self,):
self.name = "Mr.Hu"
self.age = "18"
class NewClass(Test):
pass
t = Test()
print(hasattr(t,"name"))
print(hasattr(t,"height"))
结果：
True
True
t1 = NewClass()
print(hasattr(t1,"name"))
print(hasattr(t1,"height"))
结果：
True
True无论是属性名还是方法名，都在 hasattr() 函数的匹配范围内。因此，我们只能通过该函数判断实例对象是否包含该名称的属性或方法，但不能精确判断，该名称代表的是属性还是方法。
getattr() 函数
获取某个类实例对象中指定属性的值。没错，和 hasattr() 函数不同，该函数只会从类对象包含的所有属性中进行查找。
getattr() 函数的语法格式如下：
getattr(obj, name, default)
其中，obj 表示指定的类实例对象，name 表示指定的属性名，而 default 是可选参数，用于设定该函数的默认返回值，即当函数查找失败时，如果不指定 default 参数，则程序将直接报 AttributeError 错误，反之该函数将返回 default 指定的值。
class Test:
height = "178"
def __init__ (self,):
self.name = "Mr.Hu"
self.age = "18"
class NewClass(Test):
def say(self):
print("你好啊" )
t = Test()
t1 = NewClass()
print(getattr(t1,"say"))
print(getattr(t1,"name"))
print(getattr(t,"height","178"))
结果：
<bound method NewClass.say of <__main__.NewClass object at 0x000001DC6D2BA988>>
Mr.Hu
178setattr()函数
它最基础的功能是修改类实例对象中的属性值。其次，它还可以实现为实例对象动态添加属性或者方法。
setattr() 函数的语法格式如下：
setattr(obj, name, value)
首先，下面例子演示如何通过该函数修改某个类实例对象的属性值：
class Test:
height = "178"
def __init__ (self,):
self.name = "Mr.Hu"
self.age = "18"
class NewClass(Test):
def say(self):
print("你好啊" )
def Info(self):
print("我是方法")
t = Test()
t1 = NewClass()
print(t1.name)
setattr(t1,"name","Mr.Ming")
print(t1.name)
print(t.name)
结果：
Mr.Hu
Mr.Ming
Mr.Hu
setattr(t,"age","8")
print(t1.age)
print(t.age)
结果：
18
8
setattr(t1,"name",Info)
t1.name(t1)
结果：
我是方法显然，通过修改 name 属性的值为 Info（这是一个外部定义的函数），原来的 name 属性就变成了一个 name() 方法。
使用 setattr() 函数对实例对象中执行名称的属性或方法进行修改时，如果该名称查找失败，Python 解释器不会报错，而是会给该实例对象动态添加一个指定名称的属性或方法。
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"是否是str类的实例: True
# "Hello"是object类的子类的实例，输出True
print('"Hello"是否是object类的实例: ', isinstance(hello, object))
结果："Hello"是否是object类的实例: True
# str是object类的子类，输出True
print('str是否是object类的子类: ', issubclass(str, object))
结果：str是否是object类的子类: True
# "Hello"不是tuple类及其子类的实例，输出False
print('"Hello"是否是tuple类的实例: ', isinstance(hello, tuple))
结果："Hello"是否是tuple类的实例: False
# str不是tuple类的子类，输出False
print('str是否是tuple类的子类: ', issubclass(str, tuple))
结果：str是否是tuple类的子类: False
# 定义一个列表
my_list = [2, 4]
# [2, 4]是list类的实例，输出True
print('[2, 4]是否是list类的实例: ', isinstance(my_list, list))
结果：[2, 4]是否是list类的实例: True
# [2, 4]是object类的子类的实例，输出True
print('[2, 4]是否是object类及其子类的实例: ', isinstance(my_list, object))
结果：[2, 4]是否是object类及其子类的实例: True
# list是object类的子类，输出True
print('list是否是object类的子类: ', issubclass(list, object))
结果：list是否是object类的子类: True
# [2, 4]不是tuple类及其子类的实例，输出False
print('[2, 4]是否是tuple类及其子类的实例: ', isinstance([2, 4], tuple))
结果：[2, 4]是否是tuple类及其子类的实例: False
# list不是tuple类的子类，输出False
print('list是否是tuple类的子类: ', issubclass(list, tuple))
结果：list是否是tuple类的子类: False
通过上面程序可以看出，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__() 方法，通过该方法可以查看该类的所有直接子类，该方法返回该类的所有子类组成的列表。例如：
class A:
pass
class B:
pass
class C(A, B):
pass
print('类A的所有子类:', A.__subclasses__())
print('类B的所有子类:', B.__subclasses__())
结果:
类A的所有子类: [<class '__main__.C'>]
类B的所有子类: [<class '__main__.C'>]__call__()方法
该方法的功能类似于在类中重载 () 运算符，使得类实例对象可以像调用普通函数那样，以“对象名()”的形式使用。
class Test:
# 定义__call__方法
def __call__(self,name,add):
print("调用__call__()方法",name,add)
t = Test()
t("one","two")
结果:
调用__call__()方法 one two可以看到，通过在 Test类中实现 __call__() 方法，使的 t 实例对象变为了可调用对象。
Python 中，凡是可以将 () 直接应用到自身并执行，都称为可调用对象。可调用对象包括自定义的函数、Python 内置函数以及本节所讲的类实例对象。
对于可调用对象，实际上“名称()”可以理解为是“名称.__call__()”的简写。仍以上面程序中定义的 clangs 实例对象为例，其最后一行代码还可以改写为如下形式：
t.__call__("one","two")用 __call__() 弥补 hasattr() 函数的短板
hasattr() 函数的用法，该函数的功能是查找类的实例对象中是否包含指定名称的属性或者方法，但该函数有一个缺陷，即它无法判断该指定的名称，到底是类属性还是类方法。
要解决这个问题，我们可以借助可调用对象的概念。要知道，类实例对象包含的方法，其实也属于可调用对象，但类属性却不是。举个例子：
class Test:
def __init__ (self):
self.name = "namae"
self.age = "18"
def say(self):
print("你好啊")
test = Test()
if hasattr(test,"name"):
print(hasattr(test.name,"__call__"))
print("**********")
if hasattr(test,"say"):
print(hasattr(test.say,"__call__"))
结果:
False
**********
True重载运算符
| 重载运算符 | 含义 |
|---|---|
| __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__ 方法（常用于做一些清理、扫尾的工作） |
迭代器及其用法
列表（list）、元组（tuple）、字典（dict）、集合（set）这些序列式容器有一个共同的特性，它们都支持使用 for 循环遍历存储的元素，都是可迭代的，因此它们又有一个别称，即迭代器。
自定义一个序列类，但该序列类对象并不支持迭代，因此还不能称之为迭代器。如果要自定义实现一个迭代器，则类中必须实现如下 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 必须是一个可调用对象，具体功能后面会讲。
# 将列表转换为迭代器
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__() 方法的返回值。
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 个参数相同。
生成器详解
生成器本质上也是迭代器，不过它比较特殊。
以 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 循环遍历生成器。
def intNum():
print("开始执行")
for i in range(5):
yield i
print("继续执行")
num = intNum()
print(num.__next__())
print(num.__next__())
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() 的方式调用）。
def intNum():
print("开始执行")
for i in range(5):
yield i
print("继续执行")
num = intNum()
print(list(num))
num = intNum()
print(tuple(num))
结果：
开始执行
继续执行
继续执行
继续执行
继续执行
继续执行
[0, 1, 2, 3, 4]
开始执行
继续执行
继续执行
继续执行
继续执行
继续执行
(0, 1, 2, 3, 4)通过输出结果可以判断出，list() 和 tuple() 底层实现和 for 循环的遍历过程是类似的。
相比迭代器，生成器最明显的优势就是节省内存空间，即它不会一次性生成所有的数据，而是什么时候需要，什么时候生成。
@函数装饰器及用法
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("funA")
fn() # 执行传入的fn参数
print("fn()")
return "装饰器函数的返回值"
@funA
def funB():
print("funB")
print(funB)
结果：
funA
funB
fn()
装饰器函数的返回值显然，被“＠函数”修饰的函数不再是原来的函数，而是被替换成一个新的东西（取决于装饰器的返回值），即如果装饰器函数的返回值为普通变量，那么被修饰的函数名就变成了变量名；同样，如果装饰器返回的是一个函数的名称，那么被修饰的函数名依然表示一个函数。
实际上，所谓函数装饰器，就是通过装饰器函数，在不修改原函数的前提下，来对函数的功能进行合理的扩充。
带参数的函数装饰器
在分析 funA() 函数装饰器和 funB() 函数的关系时，可能会发现一个问题，即当 funB() 函数无参数时，可以直接将 funB 作为 funA() 的参数传入。但是，如果被修饰的函数本身带有参数，那应该如何传值呢？
比较简单的解决方法就是在函数装饰器中嵌套一个函数，该函数带有的参数个数和被装饰器修饰的函数相同。例如：
def funA(fn):
# 定义一个嵌套函数
def say(arc):
print("say:",arc)
return say
@funA
def funB(arc):
print("funB():", arc)
funB("test")
结果：
say: test其实，它和如下程序是等价的：
def funA(fn):
# 定义一个嵌套函数
def say(arc):
print("say:", arc)
return say
def funB(arc):
print("funB():", arc)
funB = funA(funB)
funB("test")
结果：
say: test显然，通过 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("funB：",arc)
@funA
def other_funB(name,arc):
print(name,arc)
funB("funB:test")
other_funB("other_funB：","tests")
结果：
funB： funB:test
other_funB： tests函数装饰器可以嵌套
上面示例中，都是使用一个装饰器的情况，但实际上，Python 也支持多个装饰器，比如：
@funA
@funB
@funC
def fun():
#...上面程序的执行顺序是里到外，所以它等效于下面这行代码：
fun = funA( funB ( funC (fun) ) )
942
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
