一、闭包

如果在一个函数的内部定义另一个函数，外部的函数叫外函数，内部的函数叫内函数。

１．闭包条件

1. 在一个外函数中定义一个内函数。
2. 内函数里运用了外函数的临时变量。
3. 并且外函数的返回值是内函数的引用

一般情况下，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。
先看这一段代码：

 1 # 闭包函数的实例
 2 # outer是外部函数 a和b都是外函数的临时变量
 3 def outer( a ):
 4     b = 10
 5     # inner是内函数
 6     def inner():
 7         #在内函数中 用到了外函数的临时变量
 8         print(a+b)
 9     # 外函数的返回值是内函数的引用
10     return inner
11 
12 if __name__ == '__main__':
13     #　在这里我们调用外函数传入参数5
14     #　此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了demo
15     #　外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数
16     demo = outer(5)
17     # 我们调用内部函数，看一看内部函数是不是能使用外部函数的临时变量
18     # demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
19     demo() # 15
20 
21     demo2 = outer(7)
22     demo2() #17

上面例子是一个最简单的闭包函数。

Ａ.外函数返回了内函数的引用

引用是什么？在python中一切都是对象，包括整型数据1，1.23，函数，都是对象。
当我们进行a=1的时候，实际上在内存当中有一个地方存了值1，然后用a这个变量名存了1所在内存位置的引用。引用就类似于c语言里的指针，引用也可以理解成地址。a只不过是一个变量名字，a里面存的是1这个数值所在的地址，就是a里面存了数值1的引用。

返回内函数，对于闭包，外函数outer中，最后return inner，在调用外函数 demo = outer() 的时候，out返回inner，inner是一个函数的引用，这个引用被存入了demo中，所以接下来在使用demo()的时候，相当于使用了inner函数。

一个函数，如果函数名后紧跟一对括号，说明现在就要调用这个函数，如果不跟括号，只是一个函数的名字，里面存了函数所在位置的引用。

Ｂ.外函数把临时变量绑定给内函数

　一个函数结束的时候，会把自己的临时变量都释放给内存，之后变量都不存在了。一般情况下，确实是这样的。但是闭包是一个特别的情况。外部函数发现，自己的临时变量会在将来的内部函数中用到，自己在结束的时候，返回内函数的同时，会把外函数的临时变量和内函数绑定在一起。所以外函数已经结束了，调用内函数的时候仍然能够使用外函数的临时变量。

　在以上实际例子中，两次调用外部函数outer,分别传入的值是5和7。内部函数只定义了一次，我们发现调用的时候，内部函数是能识别外函数的临时变量是不一样的。python中一切都是对象，虽然函数我们只定义了一次，但是外函数在运行的时候，实际上是按照里面代码执行的，外函数里创建了一个函数，我们每次调用外函数，它都创建一个内函数，虽然代码一样，但是却创建了不同的对象，并且把每次传入的临时变量数值绑定给内函数，再把内函数引用返回。虽然内函数代码是一样的，但其实，我们每次调用外函数，都返回不同的实例对象的引用，他们的功能是一样的，但是它们实际上不是同一个函数对象。
　

２．闭包中内函数修改外函数局部变量

　在闭包内函数中，可以随意使用外函数绑定来的临时变量，但是如果想修改外函数临时变量数值的时候发现出问题了！

在基本的python语法当中，一个函数可以随意读取全局数据，但是要修改全局数据的时候有两种方法:

1. global 声明全局变量
2. 全局变量是可变类型数据的时候可以修改

在闭包内函数也是类似的情况。在内函数中想修改闭包变量（外函数绑定给内函数的局部变量）的时候，在python3中，可以用nonlocal 关键字声明 一个变量， 表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量。

 #修改闭包变量的实例
 # outer是外部函数 a和b都是外函数的临时变量
 def outer( a ):
     b = 10  # a和b都是闭包变量
     c = [a] #这里对应修改闭包变量的方法2
     # inner是内函数
     def inner():
         #内函数中想修改闭包变量
         # 方法1 nonlocal关键字声明
         nonlocal  b
         b+=1
         # 方法二，把闭包变量修改成可变数据类型 比如列表
         c[0] += 1
         print(c[0])
         print(b)
　    # 外函数的返回值是内函数的引用
     return inner
 if __name__ == '__main__':
     demo = outer(5)
     demo() # 6  11

从上面代码中能看出来，在内函数中，分别对闭包变量进行了修改，打印出来的结果也确实是修改之后的结果。以上两种方法就是内函数修改闭包变量的方法。
还有一点需要注意：使用闭包的过程中，一旦外函数被调用一次返回了内函数的引用，虽然每次调用内函数，是开启一个函数执行过后消亡，但是闭包变量实际上只有一份，每次开启内函数都在使用同一份闭包变量

举例如下：**

 #coding:utf8
 def outer(x):
     def inner(y):
         nonlocal x
         x+=y
         return x
     return inner
 a = outer(10)
 print(a(1)) //11
 print(a(3)) //14

两次分别打印出11和14，由此可见，每次调用inner的时候，使用的闭包变量x实际上是同一个。
**

二、装饰器

１．无参装饰器

有如下实例，我们需要计算一下代码执行的时间：

import time, random
def index():
    time.sleep(random.randrange(1, 5))
    print("welcome to index page")

根据装饰器的特点，我们不能对index()进行任何修改,而且调用方式也不能变。这时候，我们就可以使用装饰器来完成如上功能.

import time, random
def outer(func):  # 将index的地址传递给func
    def inner():
        start_time = time.time()
        func()   # fun = index  即func保存了外部index函数的地址
        end_time = time.time()
        print("运行时间为%s"%(end_time - start_time))
    return inner  # 返回inner的地址
def index():
    time.sleep(random.randrange(1, 5))
    print("welcome to index page")
index = outer(index)  # 这里返回的是inner的地址，并重新赋值给index
index()

但是，有些情况，被装饰的函数需要传递参数进去，有些函数又不需要参数，那么如何来处理这种变参数函数呢？下面来看看有参数装饰器的使用情况.

２．有参装饰器

def outer(func):  # 将index的地址传递给func
    def inner(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)   # fun = index  即func保存了外部index函数的地址
        end_time = time.time()
        print("运行时间为%s"%(end_time - start_time))
    return inner  # 返回inner的地址