流畅的python——7 函数装饰器和闭包

七、函数装饰器和闭包

nonlocal

@decorate
def target():
    print('running target()')
等同于
def target():
    print('running target()')
target = decorate(target)

综上，装饰器的一大特性是，能把被装饰的函数替换成其他函数。第二个特性是，装饰器

在加载模块时立即执行。

装饰器什么时候执行

装饰器的一个关键特性是，它们在被装饰的函数定义之后立即运行。这通常是在导入时（即 Python 加载模块时）

函数装饰器在导入模块时立即执行，而被装饰的函数只在明确调用时运行。这突出了 Python 程序员所说的导入时和运行时之间的区别。

一层装饰器：将函数原封不动的返回，例子：策略装饰器。

def register(func):
    print('running register(%s)' % func)
    registry.append(func)
    return func

使用装饰器改进策略模式

注册装饰器：将策略注册到策略列表中。

promos = []  # 策略列表

def promotion(promo_func):  # 策略装饰器，一层装饰器。用于添加策略到 策略列表
    promos.append(promo_func)
    return promo_func

@promotion
def fidelity(order):
    """为积分为1000或以上的顾客提供5%折扣"""
    return order.total() * .05 if order.customer.fidelity >= 1000 else 0

@promotion
def bulk_item(order):
    """单个商品为20个或以上时提供10%折扣"""
    discount = 0
    for item in order.cart:
        if item.quantity >= 20:
            discount += item.total() * .1
            return discount
@promotion
def large_order(order):
    """订单中的不同商品达到10个或以上时提供7%折扣"""
    distinct_items = {item.product for item in order.cart}
    if len(distinct_items) >= 10:
        return order.total() * .07
    return 0

def best_promo(order):
     """选择可用的最佳折扣"""
     return max(promo(order) for promo in promos)

1 促销策略函数无需使用特殊的名称（即不用以 _promo 结尾）。

2 @promotion 装饰器突出了被装饰的函数的作用，还便于临时禁用某个促销策略：只

需把装饰器注释掉。

3 促销折扣策略可以在其他模块中定义，在系统中的任何地方都行，只要使用 @promotion 装饰即可。

变量作用域规则

>>> b = 6
>>> def f2(a):
... 	print(a)
... 	print(b)
... 	b = 9
...
>>> f2(3)
3
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 File "<stdin>", line 3, in f2
UnboundLocalError: local variable 'b' referenced before assignment

python 编译函数的定义体时，它判断 b 是局部变量，因为在函数中给它赋值了，所以，print(b) 会从局部环境获取 b 。所以，报错：在绑定值之前调用。

如果让 b 为全局变量：global b 即可

>>> b = 6
>>> def f3(a):
... 	global b
... 	print(a)
... 	print(b)
... 	b = 9
...
>>> f3(3)
36
>>> b
9
>>> f3(3)
39
>>> b = 30
>>> b
30
>>>

闭包

在博客圈，人们有时会把闭包和匿名函数弄混。这是有历史原因的：在函数内部定义函数不常见，直到开始使用匿名函数才会这样做。而且，只有涉及嵌套函数时才有闭包问题。因此，很多人是同时知道这两个概念的。

闭包指延伸了作用域的函数，其中包含函数定义体中引用、但是不在定义体中定义的非全局变量。函数是不是匿名的没有关系，关键是它能访问定义体之外定义的非全局变量。

注意，只有嵌套在其他函数中的函数才可能需要处理不在全局作用域中的外部变量。

计算一系列数的累计的平局值：

方式一：类

class Averager():
    def __init__(self):
        self.series = []
    def __call__(self, new_value):
        self.series.append(new_value)
        total = sum(self.series)
        return total/len(self.series)

方式二：高阶函数

def make_averager():
    series = []
    def averager(new_value):
        series.append(new_value)
        total = sum(series)
        return total/len(series)
    return averager

在 averager 函数中，series 是自由变量（free variable）。这是一个技术术语，指未在本地作用域中绑定的变量

审查 返回的 averager 对象：在 __code__ 属性（表示编译后的函数定义体）

In [32]: def make_averager():
    ...:     series = []
    ...:     def avg(new_value):
    ...:         series.append(new_value)
    ...:         total = sum(series)
    ...:         return total / len(series)
    ...:     return avg
    ...:

In [33]: avg = make_averager()

In [34]: avg.__code__.co_varnames
Out[34]: ('new_value', 'total')

In [35]: avg.__code__.co_freevars
Out[35]: ('series',)

series 的绑定在返回的 avg 函数的 __closure__ 属性中。avg.__closure__ 中的各个元素对应于 avg.__code__.co_freevars 中的一个名称。这些元素是 cell 对象，有个 cell_contents 属性，保存着真正的值。

In [36]: avg.__closure__
Out[36]: (<cell at 0x00000230A826B5E8: list object at 0x00000230A7F7B488>,)

In [37]: avg.__closure__[0].cell_contents
Out[37]: []

In [38]: for i in avg.__closure__:
    ...:     print(i)

<cell at 0x00000230A826B5E8: list object at 0x00000230A7F7B488>

In [40]: for i in avg.__closure__:
    ...:     print(dir(i))

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'cell_contents']

综上，闭包是一种函数，它会保留定义函数时存在的自由变量的绑定，这样调用函数时，虽然定义作用域不可用了，但是仍能使用那些绑定。

nonlocal 声明

avg 更好的思路：保存总值和总个数。而不是每次 sum 求和。

def make_averager():
    count = 0
    total = 0
    def averager(new_value):
        count += 1
        total += new_value
        return total / count
    return averager

但是貌似没错误，其实，count ，total 会被识别为局部变量。

>>> avg = make_averager()
>>> avg(10)
Traceback (most recent call last):
 ...
UnboundLocalError: local variable 'count' referenced before assignment

问题是，当 count 是数字或任何不可变类型时，count += 1 语句的作用其实与 count = count + 1 一样。因此，我们在 averager 的定义体中为 count 赋值了，这会把 count 变成局部变量，隐式创建局部变量 count。total 变量也受这个问题影响。

之前的 series 是列表，append 操作，不是重新赋值。

为了解决这个问题，Python 3 引入了 nonlocal 声明。它的作用是把变量标记为自由变量，即使在函数中为变量赋予新值了，也会变成自由变量。如果为 nonlocal 声明的变量赋予新值，闭包中保存的绑定会更新。

正确实现

def make_averager():
    count = 0
    total = 0
    def averager(new_value):
        nonlocal count, total
        count += 1
        total += new_value
        return total / count
    return averager

python2 没有 nonlocal ，怎么解决？

处理方式是把内部函数需要修改的变量（如 count 和 total）存储为可变对象（如字典或简单的实例）的元素或属性，并且把那个对象绑定给一个自由变量。

实现一个简单的装饰器

装饰器的典型行为：把被装饰的函数替换成新函数，二者接受相同的参数，而且（通常）返回被装饰的函数本该返回的值，同时还会做些额外操作。

“动态地给一个对象添加一些额外的职责。”

import time
def clock(func):
    def clocked(*args):
        t0 = time.perf_counter()
        result = func(*args)
        elapsed = time.perf_counter() - t0
        name = func.__name__
        arg_str = ', '.join(repr(arg) for arg in args)
        print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
        return result
    return clocked

clock 装饰器有几个缺点：不支持关键字参数，而且遮盖了被装饰函数的 __name__ 和 __doc__ 属性。

使用 functools.wraps 装饰器把相关的属性从 func 复制到 clocked 中。此外，这个新版还能正确处理关键字参数。functools.wraps 只是标准库中拿来即用的装饰器之一。

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

标准库中的装饰器

property、classmethod 和 staticmethod。

functools.wraps，它的作用是协助构建行为良好的装饰器。

functools.lru_cache 是非常实用的装饰器，它实现了备忘（memoization）功能。这是一项优化技术，它把耗时的函数的结果保存起来，避免传入相同的参数时重复计算。LRU三个字母是“Least Recently Used”的缩写，表明缓存不会无限制增长，一段时间不用的缓存条目会被扔掉。

递归斐波那契耗时，使用该装饰器装饰，执行时间减半，n的每个值只调用一次函数。

import functools
from clockdeco import clock

@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))

在计算 fibonacci(30) 的另一个测试中，示例 7-19 中的版本在 0.0005 秒内调用了 31 次fibonacci 函数，而示例 7-18 中未缓存的版本调用 fibonacci 函数 2 692 537 次，在使用 Intel Core i7 处理器的笔记本电脑中耗时 17.7 秒。

除了优化递归算法， lru_cache 在从 Web 中获取信息的应用中也能发挥巨大作用。

参数：

functools.lru_cache(maxsize=128, typed=False)

maxsize 参数指定存储多少个调用的结果。缓存满了之后，旧的结果会被扔掉，腾出空间。为了得到最佳性能，maxsize 应该设为 2 的幂。typed 参数如果设为 True，把不同参数类型得到的结果分开保存，即把通常认为相等的浮点数和整数参数（如 1 和 1.0）区分开。顺便说一下，因为 lru_cache 使用字典存储结果，而且键根据调用时传入的定位参数和关键字参数创建，所以被 lru_cache 装饰的函数，它的所有参数都必须是可散列的。

单分派泛函数

例子：根据数据类型的不同，进行类似的处理，htmlize_int , htmlize_str

因为 Python 不支持重载方法或函数，所以我们不能使用不同的签名定义 htmlize 的变体，也无法使用不同的方式处理不同的数据类型。在 Python 中，一种常见的做法是把htmlize 变成一个分派函数，使用一串 if/elif/elif，调用专门的函数，这样不便于模块的用户扩展，还显得笨拙：时间一长，分派函数 htmlize 会变得很大，而且它与各个专门函数之间的耦合也很紧密。

Python 3.4 新增的 functools.singledispatch 装饰器可以把整体方案拆分成多个模块，甚至可以为你无法修改的类提供专门的函数。使用 @singledispatch 装饰的普通函数会变成泛函数（generic function）：根据第一个参数的类型，以不同方式执行相同操作的一组函数。这才称得上是单分派。如果根据多个参数选择专门的函数，那就是多分派了。

from functools import singledispatch
from collections import abc
import numbers
import html

@singledispatch  # 标记为处理obj类型的基函数
def htmlize(obj):
    content = html.escape(repr(obj))
    return '<pre>{}</pre>'.format(content)

@htmlize.register(str)  # 各个专门函数使用 @«base_function».register(«type») 装饰
def _(text):
    content = html.escape(text).replace('
', '<br>
')
    return '<p>{0}</p>'.format(content)

@htmlize.register(numbers.Integral)  # 为每个需要特殊处理的类型注册一个函数。numbers.Integral 是 int 的虚拟超类
def _(n):  # 函数名称无关紧要
    return '<pre>{0} (0x{0:x})</pre>'.format(n)

@htmlize.register(tuple)  # 可以叠放多个 register 装饰器，让同一个函数支持不同类型。
@htmlize.register(abc.MutableSequence)
def _(seq):
    inner = '</li>
<li>'.join(htmlize(item) for item in seq)
    return '<ul>
<li>' + inner + '</li>
</ul>'

只要可能，注册的专门函数应该处理抽象基类（如 numbers.Integral 和 abc.MutableSequence），不要处理具体实现（如 int 和 list）。这样，代码支持的兼容类型更广泛。例如，Python 扩展可以子类化 numbers.Integral，使用固定的位数实现 int 类型。

singledispatch 机制的一个显著特征是，你可以在系统的任何地方和任何模块中注册专门函数。如果后来在新的模块中定义了新的类型，可以轻松地添加一个新的专门函数来处理那个类型。此外，你还可以为不是自己编写的或者不能修改的类添加自定义函数。

@singledispatch 不是为了把 Java 的那种方法重载带入 Python。在一个类中为同一个方法定义多个重载变体，比在一个函数中使用一长串 if/elif/elif/elif块要更好。但是这两种方案都有缺陷，因为它们让代码单元（类或函数）承担的职责太多。@singledispath 的优点是支持模块化扩展：各个模块可以为它支持的各个类型注册一个专门函数。

装饰器是函数。

registry = set()

def register(active=True):
    def decorate(func):  # decorate 这个内部函数是真正的装饰器；注意，它的参数是一个函数。
        print('running register(active=%s)->decorate(%s)'
              % (active, func))
        if active:
            registry.add(func)
        else:
             registry.discard(func)
        return func  # decorate 是装饰器，必须返回一个函数。
     return decorate  # register 是装饰器工厂函数，因此返回 decorate。

@register(active=False)  # @register 工厂函数必须作为函数调用，并且传入所需的参数。
def f1():
    print('running f1()')
    
@register()
def f2():
    print('running f2()')
    def f3():
        print('running f3()')

参数化 clock

import time

DEFAULT_FMT = '[{elapsed:0.8f}s] {name}({args}) -> {result}'

def clock(fmt=DEFAULT_FMT):  # clock 是参数化装饰器工厂函数。
    def decorate(func):  # decorate 是真正的装饰器。
        def clocked(*_args):  # clocked 包装被装饰的函数。
            t0 = time.time()
            _result = func(*_args)
            elapsed = time.time() - t0
            name = func.__name__
            args = ', '.join(repr(arg) for arg in _args)
            result = repr(_result)  # 字符串形式的返回结果
            print(fmt.format(**locals()))  # clocked 局部变量
            return _result
        return clocked
    return decorate

if __name__ == '__main__':
    @clock()
    def snooze(seconds):
        time.sleep(seconds)
    for i in range(3):
        snooze(.123)

Python 装饰器和装饰器设计模式

Python 函数装饰器符合 Gamma 等人在《设计模式：可复用面向对象软件的基础》一书中对“装饰器”模式的一般描述：“动态地给一个对象添加一些额外的职责。就扩展功能而言，装饰器模式比子类化更灵活。”