闭包

在学习装饰器前，我先遇上了这样的写法

def  fun(name):
    def  inner(what):
        print("%s 说了 %s"  % (name,what))
    return inner
#返回值是个函数
tony=fun("塘泥")
John=fun("John")
tony("你好")
John("你好")

#一次性调用

上面这一小段代码，fun函数有以下特点

• fun函数内嵌套定义了个函数inner
• 在inner函数中使用到了fun函数的局部变量
• fun函数把inner函数返回

那么fun函数调用结束后，返回值的是一个函数。

以上这种写法称为闭包，闭包需要语法支持的，例如C语言就不支持闭包。JavaScript，python之类的都支持闭包的写法。

装饰器

python的装饰器，实际上是闭包的便捷写法，但是装饰器可以理解为特殊的闭包:

• 装饰器函数只有一个参数
• 被修饰的函数作为参数

我们先来看不用装饰器写的情况

def wrapper(getname):
    def inner(what):
        return "%s说了%d" % (getname(), what)
    return inner


def name():
    return "小明"


print(wrapper(name)(1))

wrapper这里有个特点

• wrapper只有一个参数

• 参数getname是个函数

• getname函数的原型已经确定了，因为getname可能在wrapper被调用，所以，函数的输入和输出，需要约定

• wrapper的返回值是一个函数，这个函数由于是在函数内定义

再看wrapper(name)，调用后返回了它嵌套定义的inner函数，所以可以进一步对这个函数对象进行调用。

wrapper(name)(1)这样的写法，可以装饰器的写法，简化，wrapper函数定义还是不变，但是name函数，使用了``wrapper`装饰

def wrapper(getname):
    def inner(what):
        return "%s说了%d" % (getname(), what)
    return inner

@wrapper
def name():
    return "小明"

print(name(1))

此时，直接name()调用的情况就变了

此时的名称name，不再是name函数了，而是inner！

装饰器什么时候被调用的？

name在定义的时候，wrapper已经被调用，名称name已经是inner闭包函数，至于定义的name什么时候被调用，那么就得看inner函数是如何操作的

我尝试用一段代码来确认，当name被定义的时候，到底发生了什么

def wrapper(getname):
    print("调用了wrapper")
    def inner(what):
        return "%s说了%d" % (getname(), what)
    return inner

@wrapper
def name():
    return "小明"

此时并没有调用name，只是生成了name函数对象。

调用了!
调用了!

查看结果，此时，已经调用了wrapper！name 实际上是调用wrapper函数后，返回的闭包函数。

当然，装饰器也可以带参数的，看起来像这样的写法（下面是bottle.py的路由）

from Bottle import route

@route("/")
def root():
    return "test!"

我们从这里先总结一个规律，@后面跟着的是一个装饰器（它一定算是个函数），但是这里route()，它是已经调用，而不是route，所以，route()返回的，肯定是个函数。

先调用了route函数，接着返回一个装饰器（原型和wrapper类似），这个@wrapper，再进一步修饰函数root，然后再重复之前的过程，把root函数作为参数，传递给wrapper，然后再返回一个inner闭包。root名称就是那个闭包

那么这种用法的装饰器，应该这样定义，下面是一个新的例子

def create_wrapper(action): #动作类别，例如吃、喝
    def wrapper(get_name):  #get_name返回人物名字
        # 人物 做 什么   例如张三吃苹果
        act = "%s" + action + "%s"
        def inner(thing):  # thins是人物动作的对象，例如苹果
            print(act % (get_name(), thing))
        return inner    # 返回闭包
    return wrapper      # 返回装饰器


@create_wrapper("吃")
def name():
    return "张三"

@create_wrapper("喷")
def name2():
    return "鲸鱼"

name("苹果")
name2("水")

首先create_wrapper 需要创建一个装饰器wrapper , wrapper由得返回一个闭包，这个闭包函数，有一个参数thing

这里create_wrapper，可以创建不同动作的装饰器wrapper，wrapper又可以根据不同的人、动物和不同的动作。例如吃、喝、拉，这个装饰器wrapper，参数是一个函数，返回值是个闭包函数innner，而inner，最终绑定了具体的动物，具体的动作，参数只需要指定动作的对象（例如吃的苹果）即可。输出结果：

张三吃苹果
鲸鱼喷水

多个装饰器装饰函数

我们可能遇上类似于这样的写法

@wrapper2
@wrapper1
def some_funtion():
    pass

#此处的some_function等价于
wrapper2(wrapper1(some_function))

这样嵌套的话，wrapper1修饰后返回的inner又会作为参数传递给wrapper2，然后wrapper1修饰后，再返回一个inner，这才是some_function名称的闭包函数。它可以写成这样的，它可一直这样嵌套，最终some_function只是wrapper返回的inner。

所以可以得到一个规律

• 嵌套的wrapper，从下往上，最先接受自定义函数作为参数的，修饰完毕后，返回inner闭包函数
• 然后inner闭包函数作为参数，又传递给上一个wrapper
• 最终的结果是some_function是个最上层装饰器wrapper返回的inner闭包
• 这个过程在导入的时候已经完成

多个带参数的函数装饰器，其实，他自身并不是一个装饰器，而是它需要返回一个装饰器，情况和嵌套的一样。