软件测试/测试开发丨Python闭包与装饰器 学习笔记

点此获取更多相关资料

本文为霍格沃兹测试开发学社学员学习笔记分享
原文链接：https://ceshiren.com/t/topic/27720

闭包与装饰器

1、函数引用

• Python 中定义的函数，也可以像变量一样，将一个函数名，赋值给另一个变量名，赋值后，此变量名就可以做为该函数的一个别名使用，进行调用函数，此功能列表操作的sort() 方法时使用过，sort()方法的 key 参数传入的就是一个函数名。

def show():
    print("Show Run ...")

show()
a = show
a()
1
2
3
4
5
6

• 注意：在将一个函数名（函数引用）赋值给一个变量时，函数名后不能添加括号。

2、闭包

（1）闭包定义

闭包（Closure）是指在一个嵌套的函数内部访问其外部函数中定义的变量或函数的能力。换句话说，闭包是一个函数对象，它可以记住并访问它创建时的上下文环境中的变量。

（2）闭包的基本组成部分

• 定义外部函数和内部函数：内部函数是在外部函数中定义的函数；
• 内部函数实现对外部函数中变量的操作：可以访问外部函数中的变量和参数，以及外部函数所在的作用域中的变量或其他函数对象，它被内部函数引用并记住，即使外部函数执行完成后仍然存在。
• 外部函数返回内部函数名供其他地方使用；

def out_func():
    out_n = 100
    def inner_func():
        print(out_n)
    return inner_func


if __name__ == '__main__':
    of1 = out_func()
    of2 = out_func()

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

（3）闭包的特点

1. 内部函数可以访问外部函数中定义的变量和参数，即使外部函数已经执行完毕。
2. 闭包(内函数)可以在外部函数的作用域之外被调用和执行–因为外部函数return了内部函数名出去。
3. 闭包(内函数)可以访问并修改外部函数中的局部变量，使其具有持久性。

（4）闭包的应用场景

1. 保护私有变量：可以使用闭包来创建私有变量和方法，通过内部函数的作用域和环境变量，可以实现对外部访问的限制。
2. 延迟执行：可以使用闭包来延迟某个函数的执行，即在函数外部创建一个闭包，将需要执行的函数作为内部函数，通过调用闭包来触发函数的执行。
3. 缓存数据：可以使用闭包来缓存一些昂贵的计算结果，以避免重复计算，提高程序的性能。

注意

• 需要注意的是，在使用闭包时，要注意管理内存，避免产生不必要的内存泄漏问题。

（5） nonlocal关键字

• 和全局变量一样，在函数内是不能直接修改函数外的变量的，如果修改全局变量需要使用 global 在函数内部声明变量为全局变量。 闭包中要修改变量也是一样，内函数是不能直接修改外函数中定义的变量的，如果需要修改，要在内函数中使用 nonlocal 关键字声明该变量为外函数的变量。

A、 不使用 nonlocal 修饰

def out_func():
    out_n = 100
    def inner_func():
        out_n = 200
        print("inner:",out_n)
    print("outer1:",out_n)
    inner_func()
    print("outer2:",out_n)
    return inner_func


if __name__ == '__main__':
    of1 = out_func()
    of1()
# 结果：
# outer1: 100
# inner: 200
# outer2: 100
# inner: 200
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

B、 使用 nonlocal 修饰

def out_func():
    out_n = 100
    def inner_func():
        nonlocal out_n
        out_n = 200
        print("inner:",out_n)
    print("outer1:",out_n)
    inner_func()
    print("outer2:",out_n)
    return inner_func


if __name__ == '__main__':
    of1 = out_func()
    of1()
# 结果：
# outer1: 100
# inner: 200
# outer2: 200
# inner: 200
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3、装饰器

（1）装饰器定义

• 装饰器是Python提供的一种语法糖，装饰器使用@ 符号加上装饰器名称，用于修改其他函数的行为，并且在不修改原始函数定义和调用的情况下添加额外的功能。
• 装饰器提供了一种简洁而优雅的方式来扩展和修改函数或类的功能。它本质上就是一个闭包函数。

（2）装饰器的功能特点

• 不修改已有函数的源代码；
• 不修改已有函数的调用方式；
• 给已有函数增加额外的功能；

（3）装饰器的使用和级别组成

1. 定义一个外部函数outer，并将原函数名func作为参数；
2. 定义一个内部函数inner，在内部函数中调用func函数，以及添加新增功能；
3. 外部函数返回内部函数名inner；
4. 将外部函数名使用@装饰到原函数，即@outer；

# 需求，在不改动原函数基础上给原函数增加统计运行时间功能
import time
def run_time(func):
    def inner():
        # 开始计时
        start_time = time.time()
        # 原函数执行
        func()
        # 结束计时
        end_time = time.time()
        print(f"程序运行时间为：{end_time - start_time}秒")
    return inner
@run_time
# 原函数
def show():
    for i in range(1,13):
        print(f"第{i}次打印")

if __name__ == '__main__':
    show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

（4）装饰器的本质

• 装饰器提供了一种简洁而优雅的方式（语法糖）来扩展和修改函数或类的功能。其本质就是函数的使用。

• 语法糖： 在计算机科学中，语法糖（Syntactic sugar）是指一种语法上的扩展，它并不改变编程语言的功能，只是提供了更便捷、更易读的写法，使得代码更加简洁和可理解。

  • 常见的语法糖:

    • 推导式
    • 装饰器
    • 切片
    • 上下文管理器

（5）装饰器执行的内部过程

1. Python解释器在遇到装饰器时，会将被装饰函数引用做为参数传递给闭包的外函数，外函数执行后，返回内函数的引用，此时，再将内函数引用赋值给被装饰器函数。
2. 当Python解释器执行完装饰过程后，被装饰函数的函数名就不在保存原函数的引用，而是保存的闭包函数inner的引用。
3. 而当执行被装饰函数时，实际执行的是闭包函数inner，由inner间接调用被装饰函数，完成整个调用过程。

@run_time
# 原函数
def show():
1
2
3

Python解释器解释过程：

show = run_time(show)
1

前面示例代码可修改为:

import time
def run_time(func):
    def inner():
        # 开始计时
        start_time = time.time()
        # 原函数执行
        func()
        # 结束计时
        end_time = time.time()
        print(f"程序运行时间为：{end_time - start_time}秒")
    return inner

# 原函数
def show():
    for i in range(1,20):
        print(f"第{i}次打印")

if __name__ == '__main__':
    show = run_time(show)# run_time返回inner
    show()# 这里执行的就是inner()函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

(6) 通用装饰器

• 如果需要装饰器可以装饰任何函数，那么就需要解决被装饰函数的参数及返回值的问题。
• 可以通过可变参数和在内函数中返回被装饰函数执行结果的形式解决此问题。

# 做为装饰器名的外函数，使用参数接收被装饰函数的引用
def decorator(func):
    # 内函数的可变参数用来接收被装饰函数使用的参数
    def inner(*args, **kwargs):
        # 装饰器新增功能代码
        # 调用被装饰函数，并将接收的参数传递给被装饰函数，保存被装饰函数执行结果
        result = func(*args, **kwargs)
        # 返回被装饰函数执行结果
        return result
    # 返回内函数引用
    return inner
1
2
3
4
5
6
7
8
9
10
11

（7）带参数装饰器

• 除了普通的装饰器使用方式外，在使用装饰器时，还需要向装饰器传递一些参数，比如测试框架 pytest 实现数据驱动时，可以将测试数据以装饰器参数形式传入，此时，前面定义的做为装饰器的闭包形式就不能满足需求了。
• 可以在通用装饰器外，再定义一层函数，用来接收装饰器的参数。

# 接收装饰器参数的函数
# 参数一：以字符串形式接收被装饰函数的参数列表，需要与被装饰函数参数名保持一致，例："a,b,c"
# 参数二：以[(),(),()] 形式传入驱动数据。
def decorator_args(vars, datas):
    def decorator(func):
        # 将字符串参数分割备用
        v_keys = vars.split(",")
        # 定义保存 [{},{},{}] 形式的数据
        new_datas = []
        # 遍历数据，取出一组元素数据
        for item in datas:
            # 定义一个新字典，用来保存 变量名与传入数据组成的字典
            d_item = {}
            # 使用 zip 函数，同时遍历两个元组，变量名做为key, 元素数据做为value
            for k, v in zip(v_keys, item):
                # 将 变量名和值对应保存到字典中
                d_item[k] = v
            # 将组合好的字典追加到新数据中备用
            new_datas.append(d_item)
        def inner(*args, **kwargs):
            return func(*args, **kwargs)
        # 遍历新数据，取出元素字典
        for item in new_datas:
            # 将字典中的数据解包传给内函数
            inner(**item)
        return inner
    return decorator

# 数据驱动数据
data = [(1,2,3),(4,5,6),(7,8,9)]

# 装饰器传参
@decorator_args("a,b,c", data)
def show(a,b,c):
    print(a,b,c)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

装饰器传参原理

装饰器传参的本质就是链式语法的多次函数调用；

@decorator_args("a,b,c", data) 解析：

1. 先执行 decorator_args("a,b,c", data)部分
2. 得到结果 decorator与@结合变成装饰器形式@decorator
3. 通过结果 @decorator 装饰器正常装饰被装饰函数

4、作业

• 作业要求：

  • 编写一个Python程序，实现一个计数器函数，该函数能够记录特定函数的调用次数。你需要使用闭包和装饰器来实现这个功能。

（1）使用闭包方式实现

"""
作业要求
编写一个Python程序，实现一个计数器函数，该函数能够记录特定函数的调用次数。你需要使用闭包和装饰器来实现这个功能。
"""
#给原函数增加统计调用次数功能
def count(func):
    n = 0
    def inner(number_1,operate,number_2):
        nonlocal n
        func(number_1,operate,number_2)
        n += 1
        print(f"函数被调用了{n}次")
    return inner

# 原函数：简单打印操作
def compute(number_1,operate,number_2):
    match operate:
        case "+":
            print(number_1 + number_2)
        case "-":
            print(number_1 - number_2)
        case "*":
            print(number_1 * number_2)
        case "/":
            print(number_1 / number_2)
        case _:
            print("对不起，您要求的计算我不会！")

if __name__ == '__main__':
    nwe_computer = count(compute)
    nwe_computer(5,"+",1)
    nwe_computer(5,"-",1)
    nwe_computer(5,"*",1)
    nwe_computer(5,"/",1)
    nwe_computer(5,"//",1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

（2）使用装饰器方式实现

"""
作业要求
编写一个Python程序，实现一个计数器函数，该函数能够记录特定函数的调用次数。你需要使用闭包和装饰器来实现这个功能。
"""
#给原函数增加统计调用次数功能
def count(func):
    n = 0
    def inner(number_1,operate,number_2):
        nonlocal n
        func(number_1,operate,number_2)
        n += 1
        print(f"函数被调用了{n}次")
    return inner

# 原函数：简单打印操作
@ count
def compute(number_1,operate,number_2):
    match operate:
        case "+":
            print(number_1 + number_2)
        case "-":
            print(number_1 - number_2)
        case "*":
            print(number_1 * number_2)
        case "/":
            print(number_1 / number_2)
        case _:
            print("对不起，您要求的计算我不会！")

if __name__ == '__main__':
    compute(5,"+",1)
    compute(5,"-",1)
    compute(5,"*",1)
    compute(5,"/",1)
    compute(5,"//",1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35