装饰器和闭包

装饰器用来在不修改原函数代码的情况下，增强该函数的功能。要想熟练掌握装饰器，必须理解闭包。

闭包粗略的讲就是保存有状态的函数，它除了在装饰器中有作用之外，还是回调式异步编程和函数式编程的基础。所以闭包的重要性可想而知。

装饰器基础知识

装饰器就本质而言依然是一个函数，他接收一个函数作为参数，然后返回它，或者返回另一个函数。

import functools
def deco(func):
    #@functools.wraps(func) 
    def inner():
        print("running inner()")
    return inner

@deco
def target():
    print("running target()")
"""
target = deco(target) 与
@deco
def target():
    ...
是一样的，@只是python的语法糖而已
"""
target()
print(target)

使用python的@语法，虽然函数名称还是target，但是函数指针已经发生了改变，不再指向自身，而是指向deco里面的inner函数。

print(target)打印的结果是：<function deco.<locals>.inner at 0x0000000003590378>

@functools.wraps(func)的作用是把inner的函数名__name__替换成target

加上之后print(target)打印的结果就是:<function target at 0x0000000003590378>.

使用装饰器改进策略模式

promos = []

#装饰器
def deco(func):
    promos.append(func)
    return func

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

@deco
def bulkitem_promotion(order):
    """
    单个商品为20个及以上提供10%的折扣
    """
    discount = 0
    for item in order.cart:
        if item.quantity >= 20:
            discount += item.total()*0.1
    return discount

@deco
def largeorder_promotion(order):
    """
    订单中的不同商品达到10个及以上时提供7%折扣
    """
    itemset = set(item.product for item in order.cart)
    #print(itemset)
    return order.total()*0.07 if len(itemset) >= 10 else 0

#最佳的折扣方案
def best_promotion(order):
    return max(promo(order) for promo in promos)

print("------------------------")
joe = Customer('John Doe', 0)
ann = Customer('Ann Smith', 1100)
cart = [
    LineItem('banana', 4, .5),
    LineItem('apple', 10, 1.5),
    LineItem('watermellon', 5, 5.0)
]

print(Order(joe, cart, best_promotion))
print(Order(ann, cart, best_promotion))

使用装饰器修饰几个promotion函数，装饰器接收函数作为参数，然后把函数名追加到promos列表中，在把袁术原封不动的返回，这样做有几个好处。

* 折扣函数可以随意定义，只有在定义前加上@deco即可加入促销策略

* 方便禁用某种策略，只需注释掉@deco

不过，多数装饰器都是会被装饰的函数。通常，装饰器会在内部定义一个内部函数，然后将他返回，替换原来的函数。使用内部函数的代码几乎都要靠闭包才能正确运行，为了理解闭包，我们先来看一下python的变量作用域。

变量的作用域

先来看一个例子

def f(x):
    print(x)
    print(y)

f(3)

毫无疑问，程序会抛出NameError: global name 'y' is not defined。出现错误不奇怪，因为我们没给b赋值。

如果先给全局变量y赋值，在调用f就不会出现任何问题。

y = 4
def f(x):
    print(x)
    print(y)

f(3)

以为懂了？再来看一个可能会让你吃惊的例子。

y = 4
def f(x):
    print(x)
    print(y)
    y += 1
    
f(3)

运行结果表明，程序会抛出NameError: global name 'y' is not defined。一开始我也觉得很吃惊，我本以为程序会引用全局变量y，打印出4，可事实却不是这样。

python解释器会认为y是局部变量，因为 y+=1,也就相当于y=y+1，给y赋值了，那么python就会在局部作用域找y，发现y没有值，因此会报错。如果想要使用全局变量y，可以使用global关键字。

y = 4
def f(x):
    print(x)
        global y
    print(y)
    y += 1
    
f(3)
print(y) #y的值变为5

闭包

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

闭包，也就是延伸了作用域的函数，包括函数体中的引用、不在函数体也不是全局变量的引用。关键是他能访问函数体之外的非全局变量。

学术性的话通常言简意赅、清晰准确，但不容易理解。

假设我们现在有一个avg函数，他要计算平均值，每次都有新的值加进来，因此每次的平均值可能都不一样。我们想，所以得保存之前的历史数据。

用类实现的代码如下：

class Average(object):
    def __init__(self):
        self.series = []

    def __call__(self, val):
        self.series.append(val)
        return sum(self.series)/len(self.series)

avg = Average()
print(avg(1))
print(avg(2))
print(avg(3))
print(avg(4))

但是今天我们要学习的是闭包，所以用高级函数实现如下：

def make_average():
    series = []
    def average(val):
        series.append(val)
        return sum(series)/len(series)
    return average


avg = make_average()
print(avg(1))
print(avg(2))
print(avg(3))
print(avg(4))

函数make_average内部定义了一个空列表series，和一个内部函数average，average接收一个参数，然后把参数放进列表中，计算平均值，make_average最后返回average函数。

现在，我们来比较一下两者实现的差别。

类的方式实现很明显，他把所有的历史数据都放在实例的series列表中，但是高阶函数里的average到哪里去找series列表呢？

注意，series定义在make_average函数中，那么在average函数中，series被称为自由变量(free variable)。指的是未在本地作用域中绑定的变量。

series参数被绑定在average函数的__closure__属性中，它是个列表，每个元素是cell对象，数据保存在cell_contents中。

avg = make_average()
print(avg(1))
print(avg(2))
print(avg(3))
print(avg(4))
print(avg.__closure__)
for item in avg.__closure__:
    print(item.cell_contents)

运行结果如下：

综上，闭包本质就是函数，只是他会保留定义时在函数外部存在的自由变量的绑定，这样调用函数时，虽然定义作用域不可用，但是保留的那些自由变量依然可以使用。

nonlocal声明

前面的make_average实现效率并不高，因为每次添加一个值进去，都得重新编列一遍series列表求和，如果我们能绑定历史的求和值跟元素个数，显然效率更高。

方法一：

def make_average():
    s = 0
    n = 0
    def average(val):
        n += 1
        s += val
        return s/n
    return average

avg = make_average()
avg(1)

一运行，咦？怎么报错了呢

别急，我们换种方法试一下：

方法二：

def make_average():
    s_n = {'sum':0, 'n':0}
    def average(val):
        s_n['n'] += 1
        s_n['sum'] += val
        return s_n['sum']/s_n['n']
    return average

avg = make_average()
print(avg(1))
print(avg(2))
print(avg(3))
print(avg(4))

一运行，终于没问题了。这是为什么？

在一开始，我们讨论过变量作用域的话题，方法一中， s+=val等价于 s = s+val，也就是给变量s赋值，这时，python就不再把s当成自由变量，而是当成局部变量看待，因此会报错，告诉你s是局部变量在没有赋值前被引用。再来看下为什么方法二没问题，方法二定义了一个字典，尽管在average函数里修改字典里键对应的值，但是并没有对字典本身做什么赋值操作，因此s_n绑定的还是自由变量，同理，你换成列表用append的方式也是一样的。

为了解决方法一中存在的问题，python3引入了nonlocal声明。它的作用就是把变量标记为自由变量，明确的告诉python解释器，这个变量是自由变量而非局部变量，即使在给它赋值，那也是自由变量。

正确的代码如下：

def make_average():
    s, n = 0, 0
    def average(val):
        nonlocal s, n #标记为自由变量
        s += val
        n += 1
        return s/n
    return average


avg = make_average()
print(avg(1))
print(avg(2))
print(avg(3))
print(avg(4))