Python函数（三）：闭包、装饰器_下面定义了一个使用多个装饰器修饰的函数,具体如下: @wrap_three @wrap_two @w

闭包

如果在一个内部函数中对外部函数作用域（非全局作用域）的变量进行引用，那么内部函数就成为闭包。闭包需要满足以下三个条件：
（1）存在于嵌套关系的函数中
（2）嵌套的内部函数引用了外部函数的变量
（3）嵌套的外部函数会将内部函数名作为返回值返回
例：

def outer(start=0):  # 外部函数
    count = [start]

    def inner():     # 内部函数
        count[0] += 1  # 引用外部函数的变量
        return count[0]
    return inner     # 返回内部函数的名称


quote = outer(5)
print(quote())
1
2
3
4
5
6
7
8
9
10
11

装饰器

简介
装饰器的本质是一个python函数，它可以在不改动其他函数的前提下，对函数的功能进行扩充。
装饰器用于以下场景：
引入日志、函数执行时间统计、执行函数后清理功能、权限校验、缓存
以输出函数的执行日志为例：
比如：

def test_one():
    print('test_one')
    print("test_one is running")
test_one()
1
2
3
4

但是如果其他函数也需要输出日志呢，为了减少重复代码，我们可以专门创建一个函数，只需要把需要记录日志的函数作为参数传递即可

def test_one():
    print('test_one')

def print_log(func):
    print("函数在运行")
    func()

print_log(test_one)
1
2
3
4
5
6
7
8

虽然可以实现功能，但是却破坏了原有代码的逻辑结构，如果要求已经实现的函数，不能修改，只能扩展，即遵守“封闭开发”原则，那么是不能在函数test_one内部进行修改的
装饰器可以满足上述需求，在python中，装饰器的语法是以@开头

def wrap(func):
    print("正在装饰")
    def inner():
        print("正在读取权限")
        func()
    return inner

@wrap
def test():
    print("test")
test()
1
2
3
4
5
6
7
8
9
10
11

当程序执行test()时，会发现函数test上有装饰器@wrap，所以会先执行@wrap。@wrap等价于test=wrap(test)
当@wrap执行完后，此时调用test()相当于调用inner()函数

多个装饰器
多个装饰器可以应用在一个函数上，它们的调用顺序是自下而上

def wrap_one(func):
    print("--正在装饰1--")
    def inner():
        print("--正在验证权限1--")
        func()
    return inner

def wrap_two(func):
    print("--正在装饰2--")
    def inner():
        print("--正在验证权限2--")
        func()
    return inner

@wrap_one
@wrap_two
def test():
    print("--test--")

test()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

执行顺序：
（1）首先执行@wrqp_two，相当于test=wrap_one(test)，输出–正在装饰2–
（2）执行@wrqp_one，相当于test=wrap_one(test)，输出–正在装饰1–
(3) 执行test()，先输出–正在验证权限1–，再输出–正在验证权限2–

装饰器对有参数函数进行修饰

def wrap(func):
    def inner(a,b):
        print("开始验证权限")
        func(a,b)
    return inner

@wrap
def test(a,b):
    print("a=%d,b=%d,a+b=%d"%(a,b,a+b))

test(2,3)
1
2
3
4
5
6
7
8
9
10
11

对于无法确定函数的参数个数以及参数的类型时，最好使用不定参数来传递
1

装饰器对带有返回值的函数进行修饰

def wrap(func):
    def inner():
        return func()
    return inner

@wrap
def test():
    return "有点懵"

result=test()
print(result)
1
2
3
4
5
6
7
8
9
10
11

带有参数的装饰器
如果我们给装饰器添加参数，那么需要增加异常封装，先传递参数，然后再传递函数名

def func_arg(args):
    def wrap(func):
        def inner():
            print("--记录日志-args=%s" % args)
            func()
        return inner
    return wrap

@func_arg("真的懵逼了")
def test():
    print("--test--")

test()
1
2
3
4
5
6
7
8
9
10
11
12
13

注：

1. 修饰器的位置
2. 函数有参数，那么装饰器的内部函数也要有参数
3. 函数有返回值，那么装饰器的内部函数也要有返回值