最近学到了一个有趣的装饰器写法，就记录一下。
装饰器是一个返回函数的函数。写一个装饰器，除了最常见的在函数中定义函数以外，Python还允许使用类来定义一个装饰器。
1、用类写装饰器
下面用常见的写法实现了一个缓存装饰器。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
def cache(func): data = {} def wrapper(*args, **kwargs): key = f'{func.__name__}-{str(args)}-{str(kwargs)})' if key in data: result = data.get(key) print('cached') else: result = func(*args, **kwargs) data[key] = result print('calculated') return result return wrapper |
看看缓存的效果。
|
1
2
3
4
5
6
7
8
9
|
@cachedef rectangle_area(length, width): return length * widthrectangle_area(2, 3)# calculated# 6rectangle_area(2, 3)# cached# 6 |
装饰器的@cache是一个语法糖，相当于func = cache(func)，如果这里的cache不是一个函数，而是一个类又会怎样呢？定义一个类class Cache， 那么调用func = Cache(func)会得到一个对象，这时返回的func其实是Cache的对象。定义__call__方法可以将类的实例变成可调用对象，可以像调用函数一样调用对象。然后在__call__方法里调用原本的func函数就能实现装饰器了。所以Cache类也能当作装饰器使用，并且能以@Cache的形式使用。
接下来把cache函数改写为Cache类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class Cache: def __init__(self, func): self.func = func self.data = {} def __call__(self, *args, **kwargs): func = self.func data = self.data key = f'{func.__name__}-{str(args)}-{str(kwargs)})' if key in data: result = data.get(key) print('cached') else: result = func(*args, **kwargs) data[key] = result print('calculated') return result |
再看看缓存结果，效果一样。
|
1
2
3
4
5
6
7
8
9
|
@Cachedef rectangle_area(length, width): return length * widthrectangle_area(2, 3)# calculated# 6rectangle_area(2, 3)# cached# 6 |
2、装饰类的方法
装饰器不止能装饰函数，也经常用来装饰类的方法，但是我发现用类写的装饰器不能直接用在装饰类的方法上。（有点绕…）
先看看函数写的装饰器如何装饰类的方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Rectangle: def __init__(self, length, width): self.length = length self.width = width @cache def area(self): return self.length * self.widthr = Rectangle(2, 3)r.area()# calculated# 6r.area()# cached# 6 |
但是如果直接换成Cache类会报错，这个错误的原因是area被装饰后变成了类的一个属性，而不是方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Rectangle: def __init__(self, length, width): self.length = length self.width = width @Cache def area(self): return self.length * self.widthr = Rectangle(2, 3)r.area()# TypeError: area() missing 1 required positional argument: 'self'Rectangle.area# <__main__.Cache object at 0x0000012D8E7A6D30>r.area# <__main__.Cache object at 0x0000012D8E7A6D30> |
回头再来看看没有装饰器的情况，Python在实例化对象后把函数变成了方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class Rectangle: def __init__(self, length, width): self.length = length self.width = width def area(self): return self.length * self.widthRectangle.area# <function Rectangle.area at 0x0000012D8E7B28C8>r = Rectangle(2, 3)r.area# <bound method Rectangle.area of <__main__.Rectangle object |
因此解决办法很简单，要用类写的装饰器来装饰类的方法，只需要把可调用对象包装成函数就行。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
# 定义一个简单的装饰器，什么也不做，仅仅是把可调用对象包装成函数def method(call): def wrapper(*args, **kwargs): return call(*args, **kwargs) return wrapperclass Rectangle: def __init__(self, length, width): self.length = length self.width = width @method @Cache def area(self): return self.length * self.widthr = Rectangle(2, 3)r.area()# calculated# 6r.area()# cached# 6 |
或者用@property还能直接把方法变成属性。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class Rectangle: def __init__(self, length, width): self.length = length self.width = width @property @Cache def area(self): return self.length * self.widthr = Rectangle(2, 3)r.area# calculated# 6r.area# cached# 6 |
总结
用类写装饰器并非什么特别的技巧，一般情况下确实没必要这么写，不过这样就可以用一些类的特性来写装饰器，比如类的继承，也算是提供了另一种思路吧。
