Python 装饰器：优化嵌套函数计时输出的策略-Python教程-PHP中文网

Python 装饰器：优化嵌套函数计时输出的策略

DDD

发布： 2025-10-07 11:46:01

原创

511人浏览过

Python 装饰器：优化嵌套函数计时输出的策略

本文探讨了在Python中使用装饰器对嵌套函数进行计时时，如何避免因内部函数调用导致的重复输出问题。通过引入一个基于计数器的机制，本教程展示了如何精确控制计时信息的打印深度，确保只在指定调用层级进行输出，从而实现更清晰、更符合预期的日志行为。

装饰器在嵌套函数中的重复输出问题

在python开发中，装饰器是实现代码复用和功能增强的强大工具。例如，我们经常使用装饰器来测量函数的执行时间。然而，当一个被装饰的函数内部又调用了另一个同样被装饰的函数时，就可能出现计时信息重复打印的问题。

考虑以下场景：我们有一个简单的 time_elapsed 装饰器用于记录函数执行时间。

import time
from functools import wraps

def time_elapsed(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        elapsed_time = time.time() - start_time
        print(f'{func.__name__} took {elapsed_time:.2f} seconds.')
        return result
    return wrapper

@time_elapsed
def func1():
    time.sleep(0.1)

@time_elapsed
def func2():
    func1()  # func2 内部调用了 func1
    time.sleep(0.2)

登录后复制

当我们分别调用 func1() 和 func2() 时，会观察到以下输出：

# 调用 func1()
func1 took 0.10 seconds.

# 调用 func2()
func1 took 0.10 seconds.  # 内部 func1 的计时
func2 took 0.30 seconds.  # 外部 func2 的计时

登录后复制

可以看到，当 func2 被调用时，由于它内部调用了 func1，func1 的计时信息也被打印出来，导致了重复和冗余的输出。理想情况下，我们可能只希望看到最外层函数 func2 的计时，或者根据需求控制打印的深度。

解决方案：基于计数器的深度控制

为了解决这个问题，我们可以在装饰器内部引入一个全局或装饰器私有的计数器，来追踪当前函数调用的嵌套深度。通过设置一个阈值（DEPTH），我们可以决定在哪个深度层级进行计时信息的打印。当计数器超过 DEPTH 时，装饰器将只执行被装饰函数而不打印计时信息。

立即学习“Python免费学习笔记（深入）”；

以下是改进后的 time_elapsed 装饰器实现：

import time
from functools import wraps

def time_elapsed(func):
    # 定义计时信息打印的深度阈值。
    # DEPTH = 1 意味着只打印最外层函数的计时。
    # DEPTH = 2 意味着打印最外层及其直接子函数的计时。
    DEPTH = 1 

    # 使用装饰器函数本身的属性来存储计数器，确保每个装饰器实例共享同一个计数器。
    # 首次调用时初始化为0。
    if not hasattr(time_elapsed, '_timer_running'):
        time_elapsed._timer_running = 0

    @wraps(func)
    def wrapper(*args, **kwargs):
        # 如果当前调用深度大于或等于设定的阈值，则直接执行函数，不进行计时和打印。
        if time_elapsed._timer_running >= DEPTH:
            return func(*args, **kwargs)

        # 否则，递增计数器，表示进入了一个新的需要计时的层级。
        time_elapsed._timer_running += 1

        # 执行计时逻辑
        start_time = time.time()
        result = func(*args, **kwargs)
        elapsed_time = time.time() - start_time
        print(f'{func.__name__} took {elapsed_time:.2f} seconds.')

        # 计时完成后，递减计数器，表示退出当前层级。
        time_elapsed._timer_running -= 1

        return result
    return wrapper

登录后复制

工作原理分析

DEPTH 变量：这个变量定义了我们希望打印计时信息的最大嵌套深度。
- DEPTH = 1：只打印最外层被装饰函数的计时。
- DEPTH = 2：打印最外层函数及其直接调用的被装饰子函数的计时。
- 以此类推。
time_elapsed._timer_running 计数器：这是一个附着在 time_elapsed 装饰器函数对象上的属性，充当一个全局计数器。它在每次进入一个被装饰函数并决定计时时递增，在退出时递减。
条件判断 if time_elapsed._timer_running >= DEPTH:：
- 当一个被装饰函数被调用时，wrapper 函数首先检查当前的嵌套深度（由 _timer_running 表示）是否已经达到了 DEPTH。
- 如果 _timer_running 大于或等于 DEPTH，说明我们已经处于一个不需要打印计时信息的深层嵌套中，此时 wrapper 会直接调用原始函数 func(*args, **kwargs) 并返回结果，跳过计时和打印逻辑。
- 如果 _timer_running 小于 DEPTH，则表示当前层级需要进行计时。_timer_running 会递增，然后执行正常的计时和打印逻辑。
计数器维护：在执行完计时和打印后，_timer_running 会递减，确保在函数调用栈回溯时，计数器能正确反映当前的深度。

实际应用示例

让我们使用改进后的装饰器来定义一系列嵌套函数，并观察其输出：

@time_elapsed
def func1():
    time.sleep(0.1)

@time_elapsed
def func2():
    func1()
    time.sleep(0.2)

@time_elapsed
def func3():
    func1()
    func2()
    time.sleep(0.3)

@time_elapsed
def func4():
    func1()
    func2()
    func3()
    time.sleep(0.4)

if __name__ == "__main__":
    print("--- Testing with DEPTH = 1 ---")
    func1()
    print("---")
    func2()
    print("---")
    func3()
    print("---")
    func4()
    print("\n--- Testing with DEPTH = 2 ---")
    # 临时修改 DEPTH 来演示不同行为
    time_elapsed.DEPTH = 2 
    func1()
    print("---")
    func2()
    print("---")
    func3()
    print("---")
    func4()

登录后复制

当 DEPTH = 1 时，输出如下：

帮衣帮-AI服装设计

AI服装设计神器，AI生成印花、虚拟试衣、面料替换

106

查看详情

--- Testing with DEPTH = 1 ---
func1 took 0.10 seconds.
---
func2 took 0.30 seconds.
---
func3 took 0.70 seconds.
---
func4 took 1.50 seconds.

登录后复制

可以看到，无论 func2 内部调用了 func1，还是 func3 内部调用了 func1 和 func2，都只有最外层被调用的函数打印了计时信息。这正是我们期望的“只打印最外层调用”的行为。

当我们将 time_elapsed.DEPTH 修改为 2 后，输出变为：

--- Testing with DEPTH = 2 ---
func1 took 0.10 seconds.
---
func1 took 0.10 seconds.
func2 took 0.30 seconds.
---
func1 took 0.10 seconds.
func2 took 0.30 seconds.
func3 took 0.70 seconds.
---
func1 took 0.10 seconds.
func2 took 0.30 seconds.
func3 took 0.70 seconds.
func4 took 1.50 seconds.

登录后复制

此时，func1 独立调用时会打印，func2 调用时会打印自身及其直接子函数 func1 的计时。func3 调用时会打印自身、func1 和 func2 的计时，但 func2 内部的 func1 调用（即第三层嵌套）将不会打印，因为其深度已达到或超过 DEPTH=2。

总结与注意事项

通过在装饰器中引入一个基于计数器的深度控制机制，我们能够灵活地管理嵌套函数调用时的输出行为，避免不必要的重复信息。

关键点：

计数器 _timer_running：用于追踪当前函数调用的嵌套深度。
深度阈值 DEPTH：决定在哪个深度层级进行计时和打印。
装饰器属性：将计数器作为装饰器函数（而非 wrapper）的属性，可以使其在所有被装饰函数调用之间共享状态，从而正确追踪全局的调用深度。

注意事项：

线程安全：上述实现中的 _timer_running 计数器是全局的，如果你的应用是多线程的，不同的线程可能会同时修改这个计数器，导致计时深度判断不准确。在多线程环境中，需要使用 threading.local() 或 threading.Lock 来确保计数器的线程安全。
可配置性：DEPTH 变量目前是硬编码在装饰器内部的。在更复杂的场景中，你可能希望将 DEPTH 作为装饰器的参数传入，使其更具灵活性。
适用性：这种方法不仅限于计时装饰器，也可以应用于任何需要在嵌套函数调用中控制行为的场景，例如日志记录、性能监控等。

通过这种方式，我们可以在保持代码简洁性的同时，实现对复杂函数调用链中装饰器行为的精细控制。

以上就是Python 装饰器：优化嵌套函数计时输出的策略的详细内容，更多请关注php中文网其它相关文章！