[Python] 函数装饰器和闭包

《流畅的Python》卢西亚诺·拉马略 第7章 函数装饰器和闭包  读书笔记

目录

7.1 装饰器基础知识

7.2 Python何时执行装饰器

7.3 使用装饰器改进“策略”模式

7.4 变量作用域规则

7.5 闭包

7.6 nonlocal声明

7.7 实现一个简单的装饰器

7.8 标准库中的装饰器

7.8.1 使用functools.lru_cache做备忘

7.9 叠放装饰器

7.10 参数化装饰器

7.10.1 一个参数化的注册装饰器

7.10.2 参数化clock装饰器


本章首先要讨论下述话题:
Python 装饰器句法
Python 如何判断变量是不是局部的 Ch7.4
闭包存在的原因和工作原理 Ch7.5
nonlocal 能解决什么问题 Ch7.6

掌握这些基础知识后,我们可以进一步探讨装饰器(有点难,先把能明白的部分简单记录):
实现行为良好的装饰器
标准库中有用的装饰器
实现一个参数化装饰器

7.1 装饰器基础知识

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

假如有个名为 decorate 的装饰器:

@decorate
def target():
    print('running target()')

上述代码的效果与下述写法一样:

def target():
    print('running target()')
target = decorate(target)

装饰器的两大特性:
-能把被装饰的函数替换成其他函数
-装饰器在加载模块时立即执行

7.2 Python何时执行装饰器

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

示例 7-2 registration.py 模块

以下示例主要想强调,函数装饰器在导入模块时立即执行,而被装饰的函数只在明确调用时运行。这突出了 导入时和运行时之间的区别。

registry = []     #1
def register(func):     #2
    print('running register(%s)' % func)     #3
    registry.append(func)     #4
    return func     #5

@register     #6
def f1():
    print('running f1()')

@register
def f2():
    print('running f2()')

def f3():     #7
    print('running f3()')

def main():     #8
    print('running main()')
    print('registry ->', registry)
    f1()
    f2()
    f3()

if __name__=='__main__':
    main()     #9

(1)把 registration.py 当作脚本运行得到的输出如下:

# python3 registration.py
running register(<function f1 at 0x7ff58ca96310>)
running register(<function f2 at 0x7ff58ca963a0>)
running main()
registry -> [<function f1 at 0x7ff58ca96310>, <function f2 at 0x7ff58ca963a0>]
running f1()
running f2()
running f3()

注意,register 在模块中其他函数之前运行(两次)。调用register 时,传给它的参数是被装饰的函数,例如 <function f1 at 0x7ff58ca96310>。

加载模块后,registry 中有两个被装饰函数的引用:f1 和 f2。这两个函数,以及 f3,只在 main 明确调用它们时才执行。

(2)如果导入 registration.py 模块(不作为脚本运行),输出如下:

>>> import registration
running register(<function f1 at 0x7f802bba35e0>)
running register(<function f2 at 0x7f802bba3670>)
>>>

此时查看 registry 的值,得到的输出如下:

>>> registration.registry
[<function f1 at 0x7f802bba35e0>, <function f2 at 0x7f802bba3670>]
>>>

说明:上例中,
装饰器函数与被装饰的函数在同一个模块中定义。实际上,装饰器通常在一个模块中定义,然后应用到其他模块中的函数上。
register 装饰器返回的函数与通过参数传入的相同。实际上,大多数装饰器会在内部定义一个函数,然后将其返回。装饰器原封不动地返回被装饰的函数,但是这种技术并非没有用处。很多 Python Web 框架使用这样的装饰器把函数添加到某种中央注册处,例如把 URL模式映射到生成 HTTP 响应的函数上的注册处。这种注册装饰器可能会也可能不会修改被装饰的函数。

7.3 使用装饰器改进“策略”模式

使用注册装饰器可以改进 6.1 节中的电商促销折扣示例。
示例 6-6 的主要问题是,定义体中有函数的名称,但是best_promo 列表中也有函数名称。新增策略函数后可能会忘记把它添加到promos 列表中,导致 best_promo 忽略新策略,而且不报错,为系统引入了不易察觉的缺陷。

示例 7-3 promos 列表中的值使用 promotion 装饰器填充

promos = []      #1

def promotion(promo_func):      #2
    promos.append(promo_func)
    return promo_func

@promotion      #3
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):      #4
    """选择可用的最佳折扣"""
    return max(promo(order) for promo in promos)

说明:

#1 promos 列表起初是空的。
#2 promotion 把 promo_func 添加到 promos 列表中,然后原封不动地将其返回。
#3 被 @promotion 装饰的函数都会添加到 promos 列表中。
#4 best_promos 无需修改,因为它依赖 promos 列表。

与 6.1 节给出的方案相比,这个方案有几个优点:
促销策略函数无需使用特殊的名称(即不用以 _promo 结尾)。
@promotion 装饰器突出了被装饰函数的作用,还便于禁用某个促销策略:只需把装饰器注释掉。
促销折扣策略可以在其他模块中定义,只要使用 @promotion 装饰即可。

7.4 变量作用域规则

示例 7-5 b 是局部变量,因为在函数的定义体中给它赋值了

>>> def f1(a):
...     print(a)
...     print(b)
...
>>> b = 6
>>> f1(3)
3
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
>>>

首先输出了 3,这表明 print(a) 语句执行了。
虽然有个全局变量 b,第二个语句print(b) 执行不了,局部变量 b是在 print(b) 之后赋值的。
可事实是,Python 编译函数的定义体时,它判断 b 是局部变量,因为在函数中给它赋值了。生成的字节码证实了这种判断,Python 会尝试从本地环境获取 b。后面调用 f2(3) 时, f2 的定义体会获取并打印局部变量 a 的值,但是尝试获取局部变量 b 的值时,发现 b 没有绑定值。

这是设计选择:Python 不要求声明变量,但是假定在函数定义体中赋值的变量是局部变量。
如果在函数中赋值时想让解释器把 b 当成全局变量,要使用 global 声明

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

7.5 闭包

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

举例说明 --> 假如有个名为 avg 的函数,它的作用是计算不断增加的系列值的均值;
例如,整个历史中某个商品的平均收盘价。每天都会增加新价格,因此平均值要考虑至目前为止所有的价格。
起初,avg 是这样使用的:
>>> avg(10)
10.0
>>> avg(11)
10.5
>>> avg(12)
11.0

示例 7-8 average0.py:计算移动平均值的类

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)

Averager 的实例是可调用对象:

>>> from average0 import Averager
>>> avg = Averager()
>>> avg(10)
10.0
>>> avg(11)
10.5
>>> avg(12)
11.0
>>>

示例 7-9 average.py:计算移动平均值的高阶函数

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

调用 make_averager 时,返回一个 averager 函数对象。每次调用averager 时,它会把参数添加到系列值中,然后计算当前平均值。

>>> from average import make_averager
>>> avg = make_averager()
>>> avg(10)
10.0
>>> avg(11)
10.5
>>> avg(12)
11.0
>>>

说明:这两个示例有共通之处:调用 Averager() 或make_averager() 得到一个可调用对象 avg,它会更新历史值,然后计算当前均值。在示例 7-8 中,avg 是 Averager 的实例;在示例 7-9
中是内部函数 averager。

比较

示例 7-8示例 7-9
共同点:得到一个可调用对象 avg调用Averager()调用make_averager()
存储历史值Averager 类的实例 avg 在 self.series 实例属性存储历史值series 是 make_averager 函数的局部变量,因为该函数的定义体中初始化了,调用 avg(10)时,make_averager 函数已经返回了,而它的本地作用域也一去不复返了。
怎么存储的??详见后续 

在 averager 函数中,series 是自由变量(free variable)

自由变量:指未在本地作用域中绑定的变量

averager 的闭包延伸到那个函数的作用域之外,包含自由变量 series 的绑定

审查返回的 averager 对象,我们发现 Python 在 __code__ 属性(表示编译后的函数定义体)中保存局部变量和自由变量的名称

>>> avg.__code__.co_varnames
('new_value', 'total')
>>> avg.__code__.co_freevars
('series',)
>>>

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

>>> avg.__closure__
(<cell at 0x7f802c0ba1c0: list object at 0x7f802bdf3ec0>,)
>>> avg.__closure__[0].cell_contents
[10, 11, 12]
>>>

综上,闭包会保留定义函数时存在的自由变量的绑定,这样调用函数时,虽然定义作用域不可用了,但是仍能使用那些绑定。注意,只有嵌套在其它函数中的函数才可能需要处理不在全局作用域中的外部变量

7.6 nonlocal声明

前面实现 make_averager 函数的方法效率不高。更好的实现方式是,只存储目前的总值和元素个数,然后使用这两个数计算均值。

示例 7-13 计算移动平均值的高阶函数,不保存所有历史值(有缺陷)

>>> 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):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in averager
UnboundLocalError: local variable 'count' referenced before assignment
>>>

问题在于,当 count 是数字或任何不可变类型时,count += 1 <=>  count = count + 1 因此,我们在 averager 的定义体中为 count 赋值了,这会把 count 变成局部变量(和示例7-5一个道理)。

示例 7-9 没遇到这个问题,因为我们没有给 series 赋值,只是调用 series.append,并把它传给 sum 和 len。也就是利用了列表是可变的对象这一事实。

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

解决办法 --> nonlocal 声明

nonlocal 声明的作用是把变量标记为自由变量。如果为 nonlocal 声明的变量赋予新值,闭包中保存的绑定会更新。

示例 7-14 计算移动平均值,不保存所有历史(使用 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
...
>>> avg = make_averager()
>>> avg(10)
10.0
>>> avg(8)
9.0
>>>

7.7 实现一个简单的装饰器

示例 7-15 输出函数的运行时间、传入的参数和调用的结果

定义一个装饰器 clockdeco.py

import time
def clock(func):
    def clocked(*args):     #1
        t0 = time.perf_counter()
        result = func(*args)     #2
        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     #3

说明:     
#1 定义内部函数 clocked,它接受任意个定位参数。
#2 这行代码可用,是因为 clocked 的闭包中包含自由变量 func。
#3 返回内部函数,取代被装饰的函数。

clockdeco_demo.py

import time
from clockdeco import clock
@clock
def snooze(seconds):
    time.sleep(seconds)
@clock
def factorial(n):
    return 1 if n < 2 else n*factorial(n-1)
if __name__=='__main__':
    print('*' * 40, 'Calling snooze(.123)')
    snooze(.123)
    print('*' * 40, 'Calling factorial(6)')
    print('6! =', factorial(6))

执行结果:

# python3 clockdeco_demo.py
**************************************** Calling snooze(.123)
[0.12405594s] snooze(0.123) -> None
**************************************** Calling factorial(6)
[0.00000079s] factorial(1) -> 1
[0.00001218s] factorial(2) -> 2
[0.00001909s] factorial(3) -> 6
[0.00002585s] factorial(4) -> 24
[0.00003433s] factorial(5) -> 120
[0.00004931s] factorial(6) -> 720
6! = 720

clocked 大致做了下面几件事
(1) 记录初始时间 t0。
(2) 调用原来的 factorial 函数,保存结果。
(3) 计算经过的时间。
(4) 格式化收集的数据,然后打印出来。
(5) 返回第 2 步保存的结果。
这是装饰器的典型行为:把被装饰的函数替换成新函数,二者接受相同的参数,而且(通常)返回被装饰的函数本该返回的值,同时还会做些额外操作。

示例 7-15 中实现的 clock 装饰器有几个缺点:不支持关键字参数,而且遮盖了被装饰函数的 __name__ 和 __doc__ 属性。示例 7-17 使用functools.wraps 装饰器把相关的属性从 func 复制到 clocked 中。此外,这个新版还能正确处理关键字参数
示例 7-17 改进后的 clock 装饰器

clockdeco.py

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

-----------------------------

(以下记录逐渐潦草)

7.8 标准库中的装饰器

标准库中最值得关注的两个装饰器是 lru_cache 和全新的 singledispatch(Python 3.4 新增)。
这两个装饰器都在 functools 模块中定义。

7.8.1 使用functools.lru_cache做备忘

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

示例 7-19 使用缓存实现,速度更快
 

import functools
from clockdeco import clock
@functools.lru_cache()      #1
@clock      #2
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-2) + fibonacci(n-1)
if __name__=='__main__':
    print(fibonacci(6))

运行结果:

# python3 test.py
[0.00000071s] fibonacci(0) -> 0
[0.00000112s] fibonacci(1) -> 1
[0.00009533s] fibonacci(2) -> 1
[0.00000108s] fibonacci(3) -> 2
[0.00010672s] fibonacci(4) -> 3
[0.00000094s] fibonacci(5) -> 5
[0.00011868s] fibonacci(6) -> 8
8

说明:
#1 注意,必须像常规函数那样调用 lru_cache。这一行中有一对括号:@functools.lru_cache(),lru_cache 可以接受配置参数
#2 这里叠放了装饰器:@lru_cache() 应用到 @clock 返回的函数上

7.9 叠放装饰器

把 @d1 和 @d2 两个装饰器按顺序应用到 f 函数上,作用相当于 f = d1(d2(f))。
下述代码:

@d1
@d2
def f():
    print('abcd')

等同于:

def f():
    print('abcd')
f = d1(d2(f))

7.10 参数化装饰器

Python 把被装饰的函数作为第一个参数传给装饰器函数。
那怎么让装饰器接受其他参数呢?
答案是:创建一个装饰器工厂函数,把参数传给它,返回一个装饰器,然后再把它应用到要装饰的函数上。

7.10.1 一个参数化的注册装饰器

为了便于启用或禁用 register 执行的函数注册功能,我们为它提供一个可选的 active 参数,设为 False 时,不注册被装饰的函数。
从概念上看,这个新的 register 函数不是装饰器,而是装饰器工厂函数。调用它会返回真正的装饰器,这才是应用到目标函数上的装饰器。
示例 7-23 为了接受参数,新的 register 装饰器必须作为函数调用

registration_param.py

registry = set()    #1
def register(active=True):    #2
    def decorate(func):    #3
        print('running register(active=%s)->decorate(%s)' % (active, func))
        if active:    #4
            registry.add(func)
        else:
            registry.discard(func)    #5
        return func     #6
    return decorate     #7
@register(active=False)     #8
def f1():
    print('running f1()')
@register()     #9
def f2():
    print('running f2()')
def f3():
    print('running f3()')

执行结果如下

>>> import registration_param
running register(active=False)->decorate(<function f1 at 0x7efc9f385ca0>)
running register(active=True)->decorate(<function f2 at 0x7efc9f385dc0>)
>>>
>>> registration_param.registry
{<function f2 at 0x7efc9f385dc0>}
>>>

说明:
#1 registry 现在是一个 set 对象,这样添加和删除函数的速度更快。
#2 register 接受一个可选的关键字参数。
#3 decorate 这个内部函数是真正的装饰器;注意,它的参数是一个函数。
#4 只有 active 参数的值(从闭包中获取)是 True 时才注册 func。
#5 如果 active 不为真,而且 func 在 registry 中,那么把它删除。
#6 decorate 是装饰器,必须返回一个函数。
#7 register 是装饰器工厂函数,因此返回 decorate。
#8 @register 工厂函数必须作为函数调用,并且传入所需的参数。
#9 即使不传入参数,register 也必须作为函数调用(@register()),即要返回真正的装饰器 decorate。
这里的关键是,register() 要返回 decorate,然后把它应用到被装饰的函数上。

7.10.2 参数化clock装饰器

为clock 装饰器添加一个功能:让用户传入一个格式字符串,控制被装饰函数的输出
简单起见,示例 7-25 基于示例 7-15 中最初实现的clock
示例 7-25 clockdeco_param.py 模块:参数化 clock 装饰器

clockdeco_param.py

import time
DEFAULT_FMT = '[{elapsed:0.8f}s] {name}({args}) -> {result}'
def clock(fmt=DEFAULT_FMT):    #1
    def decorate(func):    #2
        def clocked(*_args):    #3
            t0 = time.time()
            _result = func(*_args)    #4
            elapsed = time.time() - t0
            name = func.__name__
            args = ', '.join(repr(arg) for arg in _args)    #5
            result = repr(_result)    #6
            print(fmt.format(**locals()))    #7
            return _result    #8
        return clocked    #9
    return decorate    #10
if __name__ == '__main__':
    @clock()
    def snooze(seconds):
        time.sleep(seconds)
    for i in range(3):
        snooze(.123)

说明:

#1 clock 是参数化装饰器工厂函数。
#2 decorate 是真正的装饰器。
#3 clocked 包装被装饰的函数。
#4 _result 是被装饰的函数返回的真正结果。
#5 _args 是 clocked 的参数,args 是用于显示的字符串。
#6 result 是 _result 的字符串表示形式,用于显示。
#7 这里使用 **locals() 是为了在 fmt 中引用 clocked 的局部变量。(??)
#8 clocked 会取代被装饰的函数,因此它应该返回被装饰的函数返回的值。
#9 decorate 返回 clocked。
#10 clock 返回 decorate。
#11 在这个模块中测试,不传入参数调用 clock(),因此应用的装饰器使用默认的格式 str。

在 shell 中运行示例 7-25,会得到下述结果:

# python3 clockdeco_param.py
[0.12325597s] snooze(0.123) -> None
[0.12458444s] snooze(0.123) -> None
[0.12462711s] snooze(0.123) -> None

示例 7-26 clockdeco_param_demo1.py 传入了字符串输出格式

import time
from clockdeco_param import clock
@clock('{name}: {elapsed}s')
def snooze(seconds):
    time.sleep(seconds)
for i in range(3):
    snooze(.123)

执行结果如下:

# python3 clockdeco_param_demo1.py
snooze: 0.12509799003601074s
snooze: 0.12530088424682617s
snooze: 0.12441754341125488s

示例 7-26 clockdeco_param_demo2.py 传入了另一种字符串输出格式

import time
from clockdeco_param import clock
@clock('{name}({args}) dt={elapsed:0.3f}s')
def snooze(seconds):
    time.sleep(seconds)
for i in range(3):
    snooze(.123)

执行结果如下:

# python3 clockdeco_param_demo2.py
snooze(0.123) dt=0.125s
snooze(0.123) dt=0.124s
snooze(0.123) dt=0.124s

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值