参考：

 Python 函数装饰器 | 菜鸟教程

一、什么是闭包

python中的闭包从表现形式上定义(解释)为：

如果在一个内部函数里，对在外部作用域(但不是在全局作用域)的变量进行引用，那么内部函数就被认为是闭包(closure).

python中函数名是一个特殊的变量，它可以作为另一个函数的返回值，而闭包就是一个函数返回另一个函数后，其内部的局部变量还被另一个函数引用。

闭包的作用就是让一个变量能够常驻内存。

def func(name): # 定义外层函数
    def inner_func(age):  # 内层函数
        print('name: ', name, ', age: ', age)
 
    return inner_func  # 注意此处要返回，才能体现闭包
 
if __name__ == '__main__':
    bb = func('jayson')  # 将字符串传给func函数，返回inner_func并赋值给变量
    bb(28)  # 通过变量调用func函数，传入参数，从而完成闭包

打印结果：

name:  jayson , age:  28

闭包的用途

两个用处：① 可以读取函数内部的变量，②让这些变量的值始终保持在内存中。

②让函数内部的局部变量始终保持在内存中：

怎么来理解这句话呢？一般来说，函数内部的局部变量在这个函数运行完以后，就会被Python的垃圾回收机制从内存中清除掉。如果我们希望这个局部变量能够长久的保存在内存中，那么就可以用闭包来实现这个功能。

这里借用
@千山飞雪
的例子（来自于：千山飞雪：深入浅出python闭包）。请看下面的代码。

以一个类似棋盘游戏的例子来说明。假设棋盘大小为50*50，左上角为坐标系原点(0,0)，我需要一个函数，接收2个参数，分别为方向(direction)，步长(step)，该函数控制棋子的运动。 这里需要说明的是，每次运动的起点都是上次运动结束的终点。

def create(pos=[0,0]):
    
    def go(direction, step):
        new_x = pos[0]+direction[0]*step
        new_y = pos[1]+direction[1]*step
        
        pos[0] = new_x
        pos[1] = new_y
        
        return pos
    
    
    return go
 
player = create()
print(player([1,0],10))
print(player([0,1],20))
print(player([-1,0],10))

在这段代码中，player实际上就是闭包go函数的一个实例对象。

它一共运行了三次，第一次是沿X轴前进了10来到[10,0]，第二次是沿Y轴前进了20来到 [10, 20],，第三次是反方向沿X轴退了10来到[0, 20]。

这证明了，函数create中的局部变量pos一直保存在内存中，并没有在create调用后被自动清除。

为什么会这样呢？原因就在于create是go的父函数，而go被赋给了一个全局变量，这导致go始终在内存中，而go的存在依赖于create，因此create也始终在内存中，不会在调用结束后，被垃圾回收机制（garbage collection）回收。

这个时候，闭包使得函数的实例对象的内部变量，变得很像一个类的实例对象的属性，可以一直保存在内存中，并不断的对其进行运算。

二、装饰器(decorator)

装饰器就是为了不修改原函数的定义，并使原函数在运行时动态增加功能的方式，一般来说装饰器是一个返回函数的高阶函数。

简单地说：他们是修改其他函数的功能的函数。

装饰器让你在一个函数的前后去执行代码。

def hi(name="yasoob"):
    def greet():
        return "now you are in the greet() function"
 
    def welcome():
        return "now you are in the welcome() function"
 
    if name == "yasoob":
        return greet
    else:
        return welcome
 
a = hi()
print(a)
#outputs: <function greet at 0x7f2143c01500>
 
#上面清晰地展示了`a`现在指向到hi()函数中的greet()函数
#现在试试这个
 
print(a())
#outputs: now you are in the greet() function

在 if/else 语句中我们返回 greet 和 welcome，而不是 greet() 和 welcome()。

当你把一对小括号放在函数后面，这个函数就会执行；然而如果你不放括号在它后面，那它可以被到处传递，并且可以赋值给别的变量而不去执行它。

蓝本规范:

from functools import wraps
def decorator_name(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        if not can_run:
            return "Function will not run"
        return f(*args, **kwargs)
    return decorated
 
@decorator_name
def func():
    return("Function is running")
 
can_run = True
print(func())
# Output: Function is running
 
can_run = False
print(func())
# Output: Function will not run

1、将被装饰的函数，作为一个变量，传入了装饰函数里

2、装饰函数，只有一个传参，那就是被装饰的函数

3、开始执行最外层return的这个函数，里面的变量就是被装饰的函数（传进来的函数） 

其实有用的代码就这一块，其他乱七八糟的都要忽略掉，里面的那个变量，就是被传入的函数

使用场景

授权(Authorization)

装饰器能有助于检查某个人是否被授权去使用一个web应用的端点(endpoint)。它们被大量使用于Flask和Django web框架中。这里是一个例子来使用基于装饰器的授权：

from functools import wraps
 
def requires_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            authenticate()
        return f(*args, **kwargs)
    return decorated

有用的就这一小块

日志(Logging)

日志是装饰器运用的另一个亮点。这是个例子：

from functools import wraps
 
def logit(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print(func.__name__ + " was called")
        return func(*args, **kwargs)
    return with_logging
 
@logit
def addition_func(x):
   """Do some math."""
   return x + x
 
 
result = addition_func(4)
# Output: addition_func was called

有用的就这一小块

带参数的装饰器

在函数中嵌入装饰器

我们回到日志的例子，并创建一个包裹函数，能让我们指定一个用于输出的日志文件。

from functools import wraps
 
def logit(logfile='out.log'):
    def logging_decorator(func):
        @wraps(func)
        def wrapped_function(*args, **kwargs):
            log_string = func.__name__ + " was called"
            print(log_string)
            # 打开logfile，并写入内容
            with open(logfile, 'a') as opened_file:
                # 现在将日志打到指定的logfile
                opened_file.write(log_string + '\n')
            return func(*args, **kwargs)
        return wrapped_function
    return logging_decorator
 
@logit()
def myfunc1():
    pass
 
myfunc1()
# Output: myfunc1 was called
# 现在一个叫做 out.log 的文件出现了，里面的内容就是上面的字符串
 
@logit(logfile='func2.log')
def myfunc2():
    pass
 
myfunc2()
# Output: myfunc2 was called
# 现在一个叫做 func2.log 的文件出现了，里面的内容就是上面的字符串

1、有用的只有这一块

 2、多包裹一层就是为了多传递一个参数