Python 内置了三个用于装饰方法的函数：property、classmethod 和 staticmethod。
另一个常见的装饰器是 functools.wraps，它的作用是协助构建行为 良好的装饰器。标准库中最值得关注的两个装饰器是 lru_cache 和全新的 singledispatch（Python 3.4 新增）。 这两个装饰器都在 functools 模块中定义。接下来分别讨论它们。
functools.lru_cache 是非常实用的装饰器，它实现了备忘 （memoization）功能。这是一项优化技术，它把耗时的函数的结果保存 起来，避免传入相同的参数时重复计算。LRU 三个字母是“Least Recently Used”的缩写，表明缓存不会无限制增长，一段时间不用的缓存 条目会被扔掉。
# 写一个装饰器用来计算时间 import time import functools def clock(func): @functools.wraps(func) def clocked(*args, **kwargs): t0 = time.time() result = func(*args, **kwargs) elapsed = time.time() - t0 name = func.__name__ arg_lst = [] if args: arg_lst.append(‘, ‘.join(repr(arg) for arg in args)) if kwargs: pairs = [‘%s=%r‘ % (k, w) for k, w in sorted(kwargs.items())] arg_lst.append(‘, ‘.join(pairs)) arg_str = ‘, ‘.join(arg_lst) print(‘[%0.8fs] %s(%s) -> %r ‘ % (elapsed, name, arg_str, result)) return result return clocked
生成第 n 个斐波纳契数这种慢速递归函数适合使用 lru_cache
@clock def fibonacci(n): if n < 2: return n return fibonacci(n-2) + fibonacci(n-1)
if __name__==‘__main__‘:
print(fibonacci(6))
结果：
[0.00000095s] fibonacci(0) -> 0 [0.00000095s] fibonacci(1) -> 1 [0.00007892s] fibonacci(2) -> 1 [0.00000095s] fibonacci(1) -> 1 [0.00000095s] fibonacci(0) -> 0 [0.00000095s] fibonacci(1) -> 1 [0.00003815s] fibonacci(2) -> 1 [0.00007391s] fibonacci(3) -> 2 [0.00018883s] fibonacci(4) -> 3 [0.00000000s] fibonacci(1) -> 1 [0.00000095s] fibonacci(0) -> 0 [0.00000119s] fibonacci(1) -> 1 [0.00004911s] fibonacci(2) -> 1 [0.00009704s] fibonacci(3) -> 2 [0.00000000s] fibonacci(0) -> 0 [0.00000000s] fibonacci(1) -> 1 [0.00002694s] fibonacci(2) -> 1 [0.00000095s] fibonacci(1) -> 1 [0.00000095s] fibonacci(0) -> 0 [0.00000095s] fibonacci(1) -> 1 [0.00005102s] fibonacci(2) -> 1 [0.00008917s] fibonacci(3) -> 2 [0.00015593s] fibonacci(4) -> 3 [0.00029993s] fibonacci(5) -> 5 [0.00052810s] fibonacci(6) -> 8 8
浪费时间的地方很明显：fibonacci(1) 调用了 8 次，fibonacci(2) 调用了 5 次……但是，如果增加两行代码，使用 lru_cache，性能会显 著改善
@functools.lru_cache() @clock def fibonacci(n): if n < 2: return n return fibonacci(n-2) + fibonacci(n-1) if __name__==‘__main__‘: print(fibonacci(6))
结果：
[0.00000119s] fibonacci(0) -> 0 [0.00000119s] fibonacci(1) -> 1 [0.00010800s] fibonacci(2) -> 1 [0.00000787s] fibonacci(3) -> 2 [0.00016093s] fibonacci(4) -> 3 [0.00001216s] fibonacci(5) -> 5 [0.00025296s] fibonacci(6) -> 8 8
这样一来，执行时间减半了，而且 n 的每个值只调用一次函数。
特别要注意，lru_cache 可以使用两个可选的参数来配置。它的签名是：functools.lru_cache(maxsize=128, typed=False)
maxsize 参数指定存储多少个调用的结果。缓存满了之后，旧的结果会被扔掉，腾出空间。为了得到最佳性能，maxsize 应该设为 2 的 幂。typed 参数如果设为 True，把不同参数类型得到的结果分开保存，即把通常认为相等的浮点数和整数参数（如 1 和 1.0）区分开。顺便说一下，因为 lru_cache 使用字典存储结果，而且键根据调用时传入的定位参数和关键字参数创建，所以被 lru_cache 装饰的函数，它的所有参数都必须是可散列的。
假设我们在开发一个调试 Web 应用的工具，我们想生成 HTML，显示不 同类型的 Python 对象
import html def htmlize(obj): content = html.escape(repr(obj)) return ‘<pre>{}</pre>‘.format(content)
现在我们想做个扩展，让它根据不同的数据类型显示特定的格式。
import html
from functools import singledispatch
from collections import abc
import numbers
@singledispatch
def htmlize(obj):
content = html.escape(repr(obj))
return ‘<pre>{}</pre>‘.format(content)
@htmlize.register(str)
def _(text):
content = html.escape(text).replace(‘\n‘, ‘<br>\n‘)
return ‘<p>{0}</p>‘.format(content)
@htmlize.register(numbers.Integral)
def _(n):
return ‘<div>{0} (0x{0:x})</div>‘.format(n)
@htmlize.register(tuple)
@htmlize.register(abc.MutableSequence)
def _(seq):
inner = ‘</li>\n<li>‘.join(htmlize(item) for item in seq)
return ‘<ul>\n<li>‘ + inner + ‘</li>\n</ul>‘
注释：专门函数的名称无关紧要；_ 是个不错的选择，简单明了；可以叠放多个 register 装饰器，让同一个函数支持不同类型
print(htmlize({1, 2, 3})) ‘<pre>{1, 2, 3}</pre>‘ print(htmlize(abs)) ‘<pre><built-in function abs></pre>‘ print(htmlize(‘Heimlich & Co.\n- a game‘)) ‘<p>Heimlich & Co.<br> - a game</p>‘ print(htmlize(42)) ‘<div>42 (0x2a)</div>‘ print(htmlize([‘alpha‘, 66, {3, 2, 1}])) ‘‘‘ <ul> <li><p>alpha</p></li> <li><pre>66 (0x42)</pre></li> <li><pre>{1, 2, 3}</pre></li> </ul> ‘‘‘
singledispatch 机制的一个显著特征是，你可以在系统的任何地方和 任何模块中注册专门函数。如果后来在新的模块中定义了新的类型，可 以轻松地添加一个新的专门函数来处理那个类型
标准库中的装饰器 lru_cache和全新的 singledispatch
原文：https://www.cnblogs.com/feifeifeisir/p/11576510.html