闭包
在学习装饰器前，我先遇上了这样的写法
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闭包
- 这个过程在导入的时候已经完成
多个带参数的函数装饰器，其实，他自身并不是一个装饰器，而是它需要返回一个装饰器，情况和嵌套的一样。
