def deco(func):
    def inner():
        print('running inner()')
    return inner()

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

#!/usr/bin/env python
# encoding: utf-8

registry = []

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

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

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

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

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

if __name__ == '__main__':
    main()

# 运行后答案如下
# running register(<function f1 at 0x7fbac67ca6a8>)
# running register(<function f2 at 0x7fbac67ca730>)
# running main()
# registry -> [<function f1 at 0x7fbac67ca6a8>, <function f2 at 0x7fbac67ca730>]
# running f1()
# running f2()
# running f3()

import register

register.registry

promos = []

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

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

@promotion
def bulk_item_promo(order):
    '''单个商品为 20 个或以上时提供 %10 折扣'''
    
    discount = 0
    for item in order.cart:
        if item.quantity >= 20:
            discount += item.total() * .1
    return discount

@promotion
def large_order_promo(order):
    '''订单中的不同商品达到 10 个或以上时提供 %7 折扣'''
    
def best_promo(order):
    return max(promo(order) for promo in promos)

def f1(a):
    print(a)
    print(b)

f1(3)

b = 6
f1(3)

b = 6
def f2(a):
    print(a)
    print(b)
    b = 9
f2(3)

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

f3(3)

b = 30
b

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()
avg(10)

avg(11)

avg(12)

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)

avg(11)

avg(12)

avg.__code__.co_varnames

avg.__code__.co_freevars

avg.__code__.co_freevars

avg.__closure__

avg.__closure__[0].cell_contents

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)

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)

avg(11)

import time

def clock(func):
    def clocked(*args): 
        #返回计时器的精准时间（系统的运行时间），包含整个系统的睡眠时间。系统起始运行时间不确定，所以一般只有两个时间差才有效
        t0 = time.perf_counter() 
        result = func(*args)
        elapsed = time.perf_counter() - t0
        name = func.__name__
        # repr 方法用得好，用的对象例如列表不能用 str()，但是可以用 repr() 获取对象的标准字符串表示形式
        arg_str = ', '.join(repr(arg) for arg in args) 
        # %r 把对象转成标准字符串形式，因为不知道返回值类型
        print('[%0.8fs]%s(%s) -> %r' % (elapsed, name, arg_str, result)) 
        return result
    return clocked

import time

@clock
def snooze(seconds):
    time.sleep(seconds)
    
@clock
def factorial(n):
    return 1 if n < 2 else n * factorial(n - 1) 

print('*' * 40, 'Calling snooze(.123)')
snooze(.123)
print('*' * 40, 'Calling factorial(6)')
factorial(6)

factorial.__name__

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

import time

@clock
def snooze(seconds):
    time.sleep(seconds)
    
@clock
def factorial(n):
    return 1 if n < 2 else n * factorial(n - 1) 

print('*' * 40, 'Calling snooze(.123)')
snooze(.123)
print('*' * 40, 'Calling factorial(6)')
factorial(6)

factorial.__name__

@clock
def fibonacci(n):
    if n < 2: 
        return n
    return fibonacci(n - 2) + fibonacci(n - 1)

print(fibonacci(6))

@functools.lru_cache() # note
@clock
def fibonacci(n):
    if n < 2: 
        return n
    return fibonacci(n - 2) + fibonacci(n - 1)

print(fibonacci(6))

import html
def htmlize(obj):
    content = html.escape(repr(obj)) # 对字符串进行转义，详情见注释说明
    return '<pre>{}</pre>'.format(content)

'''
html.escape(s, quote=True)
Convert the characters &, < and > in string s to HTML-safe sequences. 
Use this if you need to display text that might contain such characters in HTML.
If the optional flag quote is true, the characters (") and (') are also translated; 
this helps for inclusion in an HTML attribute value delimited by quotes, as in <a href="...">.
'''

htmlize({1, 2, 3}) # 默认情况下， 在 <pre> 标签内显示 HTML 转义后的字符串表示形式

htmlize(abs) 

htmlize('Heimlich & Co.\n- a game')# str 对象也是显示 HTML 转义后的形式，\n 换成 <br>\n 并且放到 <p> 标签内

htmlize(42) # 数字显示 10进制和 16进制形式

print(htmlize(['alpha', 66, {3, 2, 1}])) #列表根据各自的类型格式化显示

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) #各个函数用 @base_function.register(type) 装饰
def _(text): #专门函数的名称不重要， _ 是个不错的选择
    content = html.escape(text).replace('\n', '<br>\n')
    return '<p>{0}</p>'.format(content)

@htmlize.register(numbers.Integral) # Integral 是 int 的虚拟超类
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>'

registry = []

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

@register
def f1():
    print('running f1()')
    
print('running main()')
print('registry ->', registry)
f1()

registry = 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 是装饰器函数，所以返回 func
    return decorate # register 是装饰器工厂函数，返回 decorate

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

@register() # 如果不传入参数也要作为函数调用
def f2():
    print("running f2()")
    
def f3():
    print('running f3()')
    
registry

register()(f3)

registry

register(active=False)(f2)

registry

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)
            print(fmt.format(**locals())) #是为了在 fmt 中引用 clocked 的局部变量 --> 用得好！
            return result
        return clocked
    return decorate

@clock() #不传入参数调用 clock()，应用的装饰器默认格式的 str
def snooze(seconds):
    time.sleep(seconds)
    
for i in range(3):
    snooze(.123)

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

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