python 闭包@装饰器

1、装饰器　　
　　装饰器（Decorator）相对简单，咱们先介绍它：“装饰器的功能是将被装饰的函数当作参数传递给与装饰器对应的函数（名称相同的函数），并返回
包装后的被装饰的函数”，听起来有点绕，没关系，直接看示意图,其中 a 为与装饰器 @a 对应的函数， b 为装饰器修饰的函数，装饰器@a的作用是：

　简而言之：@a 就是将 b 传递给 a()，并返回新的 b = a(b)

　举例:

1 #装饰器
2 
3 def a(x): #与装饰器对应的函数
4     return x()
5 @a       #装饰器
6 def b(): # 被装饰的函数
7     print('装饰器')
运行上段代码的结果为：
装饰器
[Finished in 0.1s]

上面使用@a来表示装饰器，其等同于：b = a(b) 

　因此装饰器本质上就是个语法糖，其作用为简化代码，以提高代码可读性
　解析过程是这样子的：
　　1.python 解释器发现@a，就去调用与其对应的函数（ a函数）
　　2.a函数调用前要指定一个参数，传入的就是@a下面修饰的函数，也就是 b()
　　3.a() 函数执行，调用 b()，b() 打印“装饰器”
二、 闭包　
　首先还得从基本概念说起，什么是闭包呢？来看下维基上的解释:
 在计算机科学中，闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。
 ....
 上面提到了两个关键的地方： 自由变量 和 函数, 这两个关键稍后再说。还是得在赘述下“闭包”的意思，望文知意，可以形象的把它理解为一个封闭的包裹，这个包裹就是一个函数，当然还有函数内部对应的逻辑，包裹里面的东西就是自由变量，自由变量可以在随着包裹到处游荡。当然还得有个前提，这个包裹是被创建出来的。

　　　在通过Python的语言介绍一下，一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。你在调用函数A的时候传递的参数就是自由变量。
　　　举个栗子：

def func(name):
    def inner_func(age):
        print('name:', name, 'age:', age)
    return inner_func

bb = func('the5fire')
bb(26)

结果
name: the5fire age: 26
[Finished in 0.1s]

　　

　　　这里面调用func的时候就产生了一个闭包——inner_func,并且该闭包持有自由变量——name，因此这也意味着，当函数func的生命周期结束之后，name这个变量依然存在，因为它被闭包引用了，所以不会被回收。

　　另外再说一点，闭包并不是Python中特有的概念，所有把函数做为一等公民的语言均有闭包的概念。不过像Java这样以class为一等公民的语言中也可以使用闭包，只是它得用类或接口来实现。

　　

三、nonlocal 语句

　　在 python 的函数内，可以直接引用外部变量，但不能改写外部变量，因此如果在闭包中直接改写父函数的变量，就会发生错误,example：

def cnt(pararm):
    count=0
    def counter():
        count+=1
        print("I'm",pararm,'No.',str(count))
    return counter
name=cnt('Andy')
name()

results:
　　count+=1
　　UnboundLocalError: local variable 'count' referenced before assignment

　　在 python 2 中可以在函数内使用 global 语句，但全局变量在任何语言中都不被提倡，因为它很难控制，python 3 中引入了 nonlocal 语句解决了这个问题：

　　def cnt(pararm):

    count=0
    def counter():
        nonlocal count
        count+=1
        print("I'm",pararm,'No.',str(count))
    return counter
name=cnt('Andy')
name()
result:
　　I'm Andy No. 1
　　[Finished in 0.1s]

　　Nonlocal 与 global 的区别在于 nonlocal 语句会去搜寻本地变量与全局变量之间的变量，其会优先寻找层级关系与闭包作用域最近的外部变量。

　　

四、闭包与装饰器

　　上面已经简单演示了装饰器的功能，事实上，装饰器就是一种的闭包的应用，只不过其传递的是函数：

 1 def func(fn):
 2     def wrapped():
 3         return "<b>" + fn() + "</b>"
 4     return wrapped
 5 
 6 
 7 def func2(fn):
 8     def wrapped():
 9         return "<i>" + fn() + "</i>"
10     return wrapped
11 
12 
13 @func  # 等同于执行hello = func(func2(hello))
14 @func2  # 等同于执行hello=func2(hello)
15 def hello():
16     return "hello world"
17 
18 print(hello())  # 执行的并非15行的hello() 而是13行的hello()

result:
　　<b><i>hello world</i></b>
　　[Finished in 0.1s]

@func2装饰器将函数 hello 传递给函数 func2，函数 func2执行完毕后返回被包装后的 hello 函数，而这个过程其实就是通过闭包实现的。@func也是如此，只不过其传递的是 @func2装饰过的 hello 函数，因此最后的执行结果 <b> 在 <i> 外层，这个功能如果不用装饰器，其实就是显式的使用闭包：

　　

五、闭包的作用

　　闭包的最大特点是可以将父函数的变量与内部函数绑定，并返回绑定变量后的函数（也即闭包），此时即便生成闭包的环境（父函数）已经释放，闭包仍然存在，这个过程很像类（父函数）生成实例（闭包），不同的是父函数只在调用时执行，执行完毕后其环境就会释放，而类则在文件执行时创建，一般程序执行完毕后作用域才释放，因此对一些需要重用的功能且不足以定义为类的行为，使用闭包会比使用类占用更少的资源，且更轻巧灵活，现举一例：假设我们仅仅想打印出各类动物的叫声，分别以类和闭包来实现：

 1 class Animal():#类
 2     def __init__(self,animal):
 3         self.animal=animal
 4     def sound(self,voice):
 5         print(self.animal,':',voice,'....')
 6 
 7 dog=Animal('dog')
 8 Cat=Animal('Cat')
 9 dog.sound('汪汪汪')
10 Cat.sound('喵喵喵')
11 
12 dog : 汪汪汪 ....
13 Cat : 喵喵喵 ....
14 [Finished in 0.1s]
15 
16 
17 def Animal(animal):#闭包
18     def sound(voc):
19         print(animal,":",voc,"...")
20     return sound
21 dog=Animal('dog')
22 Cat=Animal('Cat')
23 dog("汪汪汪")
24 Cat("喵喵喵")
25 
26 dog : 汪汪汪 ...
27 Cat : 喵喵喵 ...
28 [Finished in 0.1s]

可以看到输出结果是完全一样的，但显然类的实现相对繁琐，且这里只是想输出一下动物的叫声，定义一个 Animal 类未免小题大做，而且 voice 函数在执行完毕后，其作用域就已经释放，但 Animal 类及其实例 dog 的相应属性却一直贮存在内存中：

　　而这种占用对于实现该功能后，则是没有必要的。

　　除此之外，闭包还有很多其他功能，比如用于封装等，另外，闭包有效的减少了函数参数的数目，这对并行计算非常有价值，比如可以让每台电脑负责一个函数，然后串起来，实现流水化的作业等。