1、简单装饰器
说明：代码在下边。装饰前后，我们都打印一遍如下内容，做一下对比。
- print(foo) # 打印当前函数对象
- print(foo.__name__) # 打印foo函数的函数名
- print(foo.__doc__) # 打印foo函数的文档字符串(docString)
装饰之前：
- <function foo at 0x000002569AAB5620>
- foo
- this is foo
装饰之后：
- <function check_result.<locals>.wrapper at 0x00000250E11F56A8>
- wrapper
- this is wrapper
可以看出，foo的引用发生了变化。装饰的过程是这样的，python解释器会将foo作为参数传递给check_result函数，func就引用了foo函数，并将返回值给了foo，因为返回值wrapper引用了wrapper函数，所以foo的引用就变为了wrapper函数。这时再去执行foo，就等于是在执行wrapper函数了。需要注意的是在装饰之后，我我们的foo函数并没有销毁，而是被func引用着。不然执行的时候也不会有结果了。可是怎么查看呢？使用 print(foo.__closure__[0].cell_contents) 则会看到输出 <function foo at 0x000001F2C7465620> 。这样我就找到了最开始定义的foo函数了！
1 ‘‘‘ 2 简单装饰器: 3 实现装饰后函数的功能是如果x和y相乘为负数，则返回0 4 ‘‘‘ 5 6 def check_result(func): 7 ‘‘‘hahah‘‘‘ 8 def wrapper(*args, **kwargs): 9 ‘‘‘this is wrapper‘‘‘ 10 result = func(*args, **kwargs) 11 12 if result < 0: 13 return 0 14 else: 15 return result 16 return wrapper 17 18 19 @check_result 20 def foo(x, y): 21 ‘‘‘this is foo‘‘‘ 22 return x * y 23 24 25 26 27 # 装饰过程拆解 28 # wrapper = check_result(foo) 29 # foo = wrapper
2、多层装饰器
说明：在理解简单装饰器的基础上，再来看多层的装饰器，会很好理解。只需要关注一下多层装饰器的装饰顺序和执行顺序即可。
1 ‘‘‘ 2 多层装饰器 3 ‘‘‘ 4 5 def deco1(func): 6 def wrapper1(*args, **kwargs): 7 ‘‘‘this is wrapper1‘‘‘ 8 print(‘start 1‘) 9 result = func(*args, **kwargs) 10 print(‘end 1‘) 11 return result 12 return wrapper1 13 14 15 def deco2(func): 16 def wrapper2(*args, **kwargs): 17 ‘‘‘this is wrapper2‘‘‘ 18 print(‘start 2‘) 19 result = func(*args, **kwargs) 20 print(‘end 2‘) 21 return result 22 return wrapper2 23 24 25 def deco3(func): 26 def wrapper3(*args, **kwargs): 27 ‘‘‘this is wrapper3‘‘‘ 28 print(‘start 3‘) 29 result = func(*args, **kwargs) 30 print(‘end 3‘) 31 return result 32 return wrapper3 33 34 35 @deco1 36 @deco2 37 @deco3 38 def foo(x, y): 39 ‘‘‘this is foo‘‘‘ 40 return x * y 41 42 print(foo(8, 9)) 43 ‘‘‘ 44 输出结果： 45 start 1 46 start 2 47 start 3 48 end 3 49 end 2 50 end 1 51 72 52 ‘‘‘ 53 54 55 ‘‘‘ 56 装饰的过程： 57 wrapper3 = deco3(foo) 58 wrapper2 = deco2(wrapper3) 59 wrapper1 = deco1(wrapper2) 60 foo = wrapper1 61 62 63 执行的过程：正好和装饰的过程相反。 64 foo(8, 9)--->wrapper1(8, 9)--->deco1(wrapper2)(8, 9)---> 65 | 66 v 67 deco1( deco2( deco3(foo) ) )(8, 9)<---deco1( deco2(wrapper3) )(8, 9) 68 类比穿衣服，穿(装饰)的时候从里往外一层套一层，脱(执行)的时候从外到里一层一层脱。 69 ‘‘‘
3、带参装饰器
说明：传入函数执行的次数，统计执行完成的时间。
实现方法：使用工厂模式，定义一个工厂函数，它本身不是装饰器，但是返回值是一个装饰器，是用来"生产"装饰器的。如下所示：
1 ‘‘‘ 2 带参装饰器 3 ‘‘‘ 4 5 import time 6 7 def timer(count): 8 def deco(func): 9 def wrapper(*args, **kwargs): 10 ‘‘‘this is wrapper‘‘‘ 11 t1 = time.time() 12 for i in range(count): 13 result = func(*args, **kwargs) 14 t2 = time.time() 15 print(t2 - t1) 16 return result 17 return wrapper 18 return deco 19 20 21 @timer(10000000) # 获取foo执行10000000次的时间 22 def foo(x, y): 23 ‘‘‘this is foo‘‘‘ 24 return x * y
4、类装饰器
说明：想要明白类装饰器的原理，我们先要了解一下__call__这个方法。这个方法是python中所有能被调用的对象具有的内置方法，比如类，函数。调用类的过程就是得到一个类的实例的过程，如果要做类装饰器我们得让该类的实例可以被调用。装饰器的本质也是一个函数被调用执行的过程。先看下面一段代码：
1 class A: 2 pass 3 4 5 def foo(x, y): 6 return x, y 7 8 9 print(A.__call__) 10 print(foo.__call__) 11 12 print(foo.__call__(3, 5)) # 打印结果 15 13 print(foo(3, 5)) # 打印结果 15
打印结果为：可以看到，有__call__方法的才能被调用。还有一个方法判断一个对象是否能被调用 callable() ，传入对象，若返回True则表示能被调用，否则不能被调用。
<method-wrapper ‘__call__‘ of type object at 0x000002CE9522BF48>
<method-wrapper ‘__call__‘ of function object at 0x000002CE953B1E18>
根据这个特性，我们设计我们的类装饰器：
1 ‘‘‘ 2 类装饰器 3 ‘‘‘ 4 5 class Deco: 6 ‘‘‘this is Deco‘‘‘ 7 def __init__(self, func): 8 self.func = func 9 10 def __call__(self, *args, **kwargs): 11 result = self.func(*args, **kwargs) 12 if result < 0: 13 return 0 14 else: 15 return result 16 17 18 @Deco # 装饰后若结果为负数则返回0 19 def foo(x, y): 20 ‘‘‘this is foo‘‘‘ 21 return x * y 22 23 ‘‘‘ 24 装饰过程如下： 25 这个时候foo引用了Deco的一个实例，执行foo()也就是实例调用__call__方法的过程。 26 ‘‘‘ 27 foo = Deco(foo)
原文地址：https://www.cnblogs.com/reklen/p/9534941.html