第 6 章 使用一等函数实现设计模式

本章小结
很多情况下， 在 Python 中使用函数或可调用对象实现回调更自然， 这比模仿 Gamma、 Helm、 Johnson 和 Vlissides 在书中所述的“策略”或“命令”模式要好。 本章对“策略”模式的重构和对“命令”模式的讨论是为了通过示例说明一个更为常见的做法： 有时， 设计模式或 API 要求组件实现单方法接口， 而那个方法的名称很宽泛， 例如“execute”“run”或“doIt”。 在 Python 中， 这些模式或 API 通常可以使用一等函数或其他可调用的对象实现， 从而减少样板代码.

第 7 章 函数装饰器和闭包

函数装饰器用于在源码中“标记”函数， 以某种方式增强函数的行为。 这
是一项强大的功能， 但是若想掌握， 必须理解闭包。
除了在装饰器中有用处之外， 闭包还是回调式异步编程和函数式编程风格的基础。

7.1 装饰器基础知识

装饰器是可调用的对象， 其参数是另一个函数（ 被装饰的函数） 。 装饰器可能会处理被装饰的函数， 然后把它返回， 或者将其替换成另一个函数或可调用对象。

7.4 变量作用域规则

>>> def f1(a):
... print(a)
... print(b)
...
>>> f1(3)     # 很好理解，因为a有了，而b没有说明
3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in f1
NameError: global name 'b' is not defined   # 全局变量b未定义

>>> b = 6   # 我们接着添加一句b
>>> f1(3)
3
6     # b 作为全局变量就会被识别

>>> b = 6           # 全局变量 b
>>> def f2(a):
... print(a)
... print(b)   # 自己测试时，把这条删除，结果就是3,6；因为这条，无法识别 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 是局部变量， 因为在函数中给它赋值了。 生成的字节码证实了这种判断， Python 会尝试从本地环境获取 b。 后面调用 f2(3) 时， f2 的定义体会获取并打印局部变量 a 的值， 但是尝试获取局部变量 b 的值时， 发现 b 没有绑定值。
这不是缺陷， 而是设计选择： Python 不要求声明变量， 但是假定在函数定义体中赋值的变量是局部变量。 这比 JavaScript 的行为好多了，JavaScript 也不要求声明变量， 但是如果忘记把变量声明为局部变量（ 使用 var） ， 可能会在不知情的情况下获取全局变量。

>>> b = 6
>>> def f3(a):
... global b
... print(a)
... print(b)
... b = 9
...
>>> f3(3)
3
6       # 第一次运行，b本身就是全局变量，所以b = 6,这次执行完后，内部b 已经是9了
>>> b   # 函数是按顺序执行的，此时b被再次赋值， b = 9了
9 
>>> f3(3)   # 再次调用函数时，此时不经过b = 6,直接内部获取b = 9
3
9
>>> b = 30
>>> b
30
>>> f3(3)
3            # b = 30 又再一次成为全局变量
30           # ⚠️这次的变量的作用域判断为闭包学习打基础  

7.5 闭包

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

我们来实现一个平均求值的功能：
面向对象的做法

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)

>>> avg = Averager()      # Averager 的实例是可调用对象：
>>> avg(10)
10.0
>>> avg(11)
10.5
>>> avg(12)
11.0

函数式编程的做法：

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

>>> avg = make_averager()
>>> avg(10)
10.0
>>> avg(11)
10.5
>>> avg(12)

global 关键字用来在函数或其他局部作用域中使用全局变量。但是如果不修改全局变量也可以不使用global关键字, nonlocal 关键字用来在函数或其他作用域中使用外层(非全局)变量。

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

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

7.6 nonlocal声明

一个有问题的函数：

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

>>> 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变成局部变量。total 变量也受这个问题影响。

对数字、 字符串、 元组等不可变类型来说， 只能读取， 不能更新。如果尝试重新绑定， 例如count = count + 1， 其实会隐式创建局部变量 count。 这样， count 就不是自由变量了， 因此不会保存在闭包中。

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

7.11 本章小结

本章介绍了很多基础知识， 虽然学习之路崎岖不平， 我还是尽可能让路途平坦顺畅。 毕竟， 我们已经进入元编程领域了。

开始， 我们先编写了一个没有内部函数的@register 装饰器； 最后，
我们实现了有两层嵌套函数的参数化装饰器@clock()

尽管注册装饰器在多数情况下都很简单， 但是在高级的 Python 框架中却有用武之地。 我们使用注册方式对第 6 章的“策略”模式做了重构。
参数化装饰器基本上都涉及至少两层嵌套函数， 如果想使用@functools.wraps生成装饰器， 为高级技术提供更好的支持， 嵌套层级可能还会更深， 比如前面简要介绍过的叠放装饰器。

我们还讨论了标准库中 functools 模块提供的两个出色的函数装饰
器： @lru_cache() 和 @singledispatch。

若想真正理解装饰器， 需要区分导入时和运行时， 还要知道变量作用域、 闭包和新增的nonlocal 声明。 掌握闭包和 nonlocal不仅对构建装饰器有帮助， 还能协助你在构建 GUI 程序时面向事件编程， 或者使用回调处理异步 I/O。

杂谈

任何把函数当作一等对象的语言， 它的设计者都要面对一个问题：作为一等对象的函数在某个作用域中定义， 但是可能会在其他作用域中调用。 问题是， 如何计算自由变量？ 首先出现的最简单的处理方式是使用“动态作用域”。 也就是说， 根据函数调用所在的环境计算自由变量。

在 Python 中， 装饰器函数相当于 Decorator 的具体子类， 而装饰器返回的内部函数相当于装饰器实例。 返回的函数包装了被装饰的函数， 这相当于“装饰器”设计模式中的组件。 返回的函数是透明的， 因为它接受相同的参数， 符合组件的接口。 返回的函数把调用转发给组件， 可以在转发前后执行额外的操作。 因此， 前面引用那段话的最后一句可以改成： “透明性使得你可以递归嵌套多个装饰器， 从而可以添加任意多的行为。 ”这就是叠放装饰器的理论基础。

注意， 我不是建议在 Python 程序中使用函数装饰器实现“装饰器”模式。 在特定情况下确实可以这么做， 但是一般来说， 实现“装饰器”模式时最好使用类表示装饰器和要包装的组件.