标准库中最值得关注的两个 装饰器是 lru_cache 和全新的 singledispatch(Python 3.4 新增)
clock 装饰器
def clock(func): @functools.wraps(func) def clocked(*args, **kwargs): t0 = time.perf_counter() result = func(*args, **kwargs) elapsed = time.perf_counter() - t0 name = func.__name__ arg_lst = [] if args: arg_lst = ', '.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
functools.lru_cache 是非常实用的装饰器,它实现了备忘 (memoization)功能。这是一项优化技术,它把耗时的函数的结果保存 起来,避免传入相同的参数时重复计算。LRU 三个字母是“Least Recently Used”的缩写,表明缓存不会无限制增长,一段时间不用的缓存 条目会被扔掉。
生成第 n 个斐波纳契数这种慢速递归函数适合使用 lru_cache,如示例 7-18 所示。
示例 7-18 生成第 n 个斐波纳契数,递归方式非常耗时
@clock def fibonacci(n): if n < 2: return n return fibonacci(n-2) + fibonacci(n-1) if __name__ == '__main__': print(fibonacci(6))
运行 fibo_demo.py 得到的结果如下。除了最后一行,其余输出都是 clock 装饰器生成的。
$ python3 fibo_demo.py [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,性能会显 著改善,如示例 7-19 所示。
示例 7-19 使用缓存实现,速度更快
@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))
❶ 注意,必须像常规函数那样调用 lru_cache。这一行中有一对括 号:@functools.lru_cache()。这么做的原因是,lru_cache 可以 接受配置参数,稍后说明
❷ 这里叠放了装饰器:@lru_cache() 应用到 @clock 返回的函数上。
这样一来,执行时间减半了,而且 n 的每个值只调用一次函数:
$ python3 fibo_demo_lru.py [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
在计算 fibonacci(30) 的另一个测试中,示例 7-19 中的版本在 0.0005 秒内调用了 31 次 fibonacci 函数,而示例 7-18 中未缓存的版本调用 fibonacci 函数 2 692 537 次,在使用 Intel Core i7 处理器的笔记本电脑 中耗时 17.7 秒。
除了优化递归算法之外,lru_cache 在从 Web 中获取信息的应用中也 能发挥巨大作用。
特别要注意,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)
这个函数适用于任何 Python 类型,但是现在我们想做个扩展,让它使用 特别的方式显示某些类型str:
- str:把内部的换行符替换为 '<br>\n';不使用 <pre>,而是使用<p>。
- int:以十进制和十六进制显示数字。
- list:输出一个 HTML列表,根据各个元素的类型进行格式化。
我们想要的行为如示例 7-20 所示。
示例 7-20 生成 HTML的 htmlize 函数,调整了几种对象的输出
>>> htmlize({1, 2, 3}) ➊ '<pre>{1, 2, 3}</pre>' >>> htmlize(abs) '<pre><built-in function abs></pre>' >>> htmlize('Heimlich & Co.\n- a game') ➋ '<p>Heimlich & Co.<br>\n- a game</p>' >>> htmlize(42) ➌ '<pre>42 (0x2a)</pre>' >>> 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 创建一个自定义的htmlize.register 装饰器,把多个函数绑在一起组成一个泛函数
from functools import singledispatch from collections import abc import numbers import html @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 '<pre>{0} (0x{0:x})</pre>'.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>'
singledispatch 机制的一个显著特征是,你可以在系统的任何地方和 任何模块中注册专门函数。如果后来在新的模块中定义了新的类型,可 以轻松地添加一个新的专门函数来处理那个类型。此外,你还可以为不 是自己编写的或者不能修改的类添加自定义函数。
人生就是要不断折腾