python中的闭包与装饰器（语法糖）

一、闭包

闭包相当于函数中，嵌套另一个函数，并返回。代码如下：

def func(name):  # 定义外层函数
    def inner_func(age):  # 内层函数
        print('name: ', name, ', age: ', age)
    return inner_func  # 注意此处要返回，才能体现闭包

bb = func('jayson')  # 将字符串传给func函数，返回inner_func并赋值给变量
bb(28)  # 通过变量调用func函数，传入参数，从而完成闭包
>>
name:  jayson , age:  28

二、装饰器

装饰器：把函数test当成变量传入装饰函数deco --> 执行了装饰操作后，变量传回给了函数test()。比如装饰器效果是test = test-1，test函数经过deco装饰后，调用test其实执行的是 test = test-1。

1、装饰器是利用闭包原理，区别是装饰器在闭包中传入的参数是函数，而不是变量。

注：其实在装饰器中，函数即变量

def deco(func):  # 传入func函数。
    print('decoration')
    return func

def test():
    print('test_func')

test = deco(test)  # 对函数进行装饰。执行了deco函数，并将返回值赋值给test
>>
# 输出deco的运行结果
decoration

test()  # 运行装饰后的函数
>>
test_func

2、以上代码等价于

def deco(func):  # 传入func函数。
    print('decoration')
    return func

@deco  # 等价于上一代码中test = deco(test)，不过上一代码需放在定义test之后
def test():
    print('test_func')

>>
# 输出deco的运行结果
decoration

test()  # 运行装饰后的函数
>>
test_func

3、装饰器（简版）

def deco(func):  # 装饰函数传入func
    print('decoration')
    return func

@deco  # 装饰函数。
def test():
    print('test_func')  
# 定义完函数后，会直接执行装饰器deco(test)
>>
decoration

# 调用test，执行test函数
test()
>> 
test_func

3、装饰器（升级版） 

在上一个版本中，由于在定义装饰器 + 函数时，就会执行装饰函数里面的语句。

为了使其在未被调用时候不执行，需要再嵌套一个函数，将函数进行包裹。

def deco(func):  
    print('decoration')  # 此处未调用func函数时，会直接执行
    def wrapper():  # 名称自定义，一般用wrapper
        print('execute')  # 此处未调用func函数时，不会执行
        func()  # 执行函数
    return wrapper  # 此处返回wrapper给func，通过外部func()执行

@deco  # 注意：此处不能有括号。有括号的形式是func未传入最外层deco()，传入deco的子函数中
def test():
    print('test_func')
>>
decoration
#调用test
test()
>>
execute
test_func

注意：如果func函数本身有返回值，同样需要在包裹函数中返回

def deco(func):  
    print('decoration')
    def wrapper():
        print('execute')
        a = func()  # 执行函数，并返回值
        print('done')
        return a  # 将func的返回值一并返回
    return wrapper

@deco
def test():
    print('test_func')
    return 5  #  增加返回值
>>
decoration

#调用test
test()
>>
execute
test_func
done

5  # 此处是test函数的返回值

3、装饰器（进阶版）

在包裹函数中，参数形式设置为*arg、**kwarg，会使得函数更加灵活。

当修改test函数参数形式时，不用在装饰器中同时修改。

import time

def deco(func):
    def inner(*arg, **kwarg):  # 此处传入参数
        begin_time = time.time()
        time.sleep(2)
        a = func(*arg, **kwarg)  # 调用函数，使用传入的参数
        end_time = time.time()
        print('运行时间：', end_time - begin_time)
        return a
    return inner

@deco
def test(a):
    print('test function:', a)
    return a

# 调用函数
test(5)
>>
test function: 5
运行时间： 2.0003252029418945

5  # 5是函数返回的值

4、高阶版

有时候我们会发现有的装饰器带括号，其原因是将上述的装饰器外面又套了一个函数

import time

def outer():  # 在原装饰器外套一层函数，将装饰器封装在函数里面。（outer自定义）
    def deco(func):  # 原装饰器，后面的代码一样
        def inner(*arg, **kwarg): 
            begin_time = time.time()
            time.sleep(2)
            a = func(*arg, **kwarg) 
            end_time = time.time()
            print('运行时间：', end_time - begin_time)
            return a
        return inner
    return deco  # 注意：此处需返回装饰函数

@outer()  # 此处就需要加括号，其实是调用了outer()函数，将test传进其子函数
def test(a):
    print('test function:', a)
    return a

test(4)
>>
test function: 4
运行时间： 2.000566005706787

4  # 返回4

5、高阶终结版

带参数的装饰器（装饰器加括号，带参数）

import time

def outer(choose):  # 在最外层函数中加入参数
    if choose==1:  # 通过choose参数，选择装饰器
        def deco(func):
            def inner(*arg, **kwarg):
                print('decoration1')
                begin_time = time.time()
                time.sleep(2)  # 睡眠2s
                a = func(*arg, **kwarg) 
                end_time = time.time()
                print('运行时间1：', end_time - begin_time)
                return a
            return inner
        return deco
    
    else:
        def deco(func):
            def inner(*arg, **kwarg): 
                print('decoration2')
                begin_time = time.time()
                time.sleep(5)  # 睡眠5s
                a = func(*arg, **kwarg) 
                end_time = time.time()
                print('运行时间2：', end_time - begin_time)
                return a
            return inner
        return deco

@outer(1)  # 由于outer中有参数，此处必须传入参数
def test1(a):
    print('test function1:', a)
    return a

@outer(5)  # 传入另一个参数
def test2(a):
    print('test function2:', a)
    return a


# 分别调用2个函数（2个函数装饰器相同，装饰器参数不同）
test1(2)  # 调用test1
>>
decoration1
test function1: 2
运行时间1： 2.000072717666626  # 2秒

2  # test1的返回值

test2(4)  # 调用test2
>>
decoration2
test function2: 4
运行时间2： 5.000797986984253  # 5秒

4  # test2的返回值