函数装饰器和闭包

1
2
3
4
5
6
7
8

# 以下两种写法的最终结果一样
@decorate
def target():
    print('running target()')

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 示例 7-3 promos 列表中的值使用 promotion 装饰器填充
promos = []  # <1>

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

@promotion  # <3>
def fidelity(order):
    """5% discount for customers with 1000 or more fidelity points"""
    return order.total() * .05 if order.customer.fidelity >= 1000 else 0

@promotion
def bulk_item(order):
    """10% discount for each LineItem with 20 or more units"""
    discount = 0
    for item in order.cart:
        if item.quantity >= 20:
            discount += item.total() * .1
    return discount

def best_promo(order):   # <4>
    """Select best discount available
    """
    return max(promo(order) for promo in promos)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

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

>>> from dis import dis
>>> dis(f2) # 生成的字节码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

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)
Traceback (most recent call last):
...
UnboundLocalError:  local variable 'count' referenced before assignment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import functools

from clockdeco import clock

@functools.lru_cache() #  lru_cache 可以接受配置参数
@clock                 # @lru_cache() 应用到 @clock 返回的函数上
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-2) + fibonacci(n-1)

if __name__=='__main__':
    print(fibonacci(6))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

@singledispatch ➊  #  @singledispatch 标记处理 object 类型的基函数
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('\n', '<br>\n')
    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>\n<li>'.join(htmlize(item) for item in seq)
    return '<ul>\n<li>' + inner + '</li>\n</ul>'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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

#等同于
def f():
    print('f')

f = d1(d2(f))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 示例 7-23 为了接受参数，新的 register 装饰器必须作为函数调用
registry = set()  # set 对象，这样添加和删除函数的速度更快

def register(active=True):
    def decorate(func):   # 内部函数是真正的装饰器；注意，它的参数是一个函数
        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()  #  即使不传入参数， register 也必须作为函数调用
def f2():
    print('running f2()')

>>> from registration_param import *
>>> register()(f3)
>>> register(active=False)(f2)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import time

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

def clock(fmt=DEFAULT_FMT):   
    def decorate(func):       
        def clocked(*_args):
            t0 = time.time()
            _result = func(*_args)
            elapsed = time.time() - t0
            name = func.__name__
            args = ', '.join(repr(arg) for arg in _args)  
            result = repr(_result)
            # 使用 **locals() 是为了在 fmt 中引用 clocked 的局部变量
            print(fmt.format(**locals()))
            return _result  
        return clocked
    return decorate  

if __name__ == '__main__':

    @clock()  # <11>
    def snooze(seconds):
        time.sleep(seconds)

    for i in range(3):
        snooze(.123)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# BEGIN CLOCKDECO_CLS
import time

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

class clock:

    def __init__(self, fmt=DEFAULT_FMT):
        self.fmt = fmt

    def __call__(self, func):
        def clocked(*_args):
            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(self.fmt.format(**locals()))
            return _result
        return clocked