Python装饰器在嵌套函数中避免重复输出的策略-Python教程-PHP中文网

Python装饰器在嵌套函数中避免重复输出的策略

心靈之曲

发布： 2025-10-07 10:53:33

原创

367人浏览过

Python装饰器在嵌套函数中避免重复输出的策略

本文探讨了在Python中使用装饰器时，如何避免因函数嵌套调用导致的重复输出问题。通过引入一个内部计数器来追踪装饰器的调用深度，并结合一个可配置的深度阈值，我们实现了一个智能的计时装饰器。该装饰器能确保只有指定层级的函数调用才会触发其核心逻辑（如打印计时信息），从而在保持代码模块化的同时，优化了输出的清晰度和可控性。

1. 理解装饰器与嵌套函数中的挑战

python装饰器提供了一种优雅的方式来在不修改原函数代码的情况下，为其添加额外的功能，例如日志记录、性能计时、权限检查等。然而，当一个被装饰的函数在其内部又调用了另一个同样被装饰的函数时，就会出现一个常见的挑战：装饰器的功能可能会被重复执行，导致不必要的输出或行为。

考虑一个简单的计时装饰器 @time_elapsed，它测量函数的执行时间并打印出来。如果我们将它应用于 func1 和 func2，而 func2 内部又调用了 func1：

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() # 调用了func1
    time.sleep(0.2)

# 期望行为：
# func1() -> func1 took 0.10 seconds.
# func2() -> func2 took 0.30 seconds. (只打印func2的总时间)

# 实际行为：
# func2()
# func1 took 0.10 seconds.  # 冗余输出
# func2 took 0.30 seconds.

登录后复制

上述代码在调用 func2() 时，会先打印 func1 的计时，再打印 func2 的计时。这通常不是我们期望的行为，因为我们可能只关心最外层函数的总执行时间。

2. 解决方案：基于调用深度的智能装饰器

为了解决这个问题，我们可以修改装饰器，使其能够感知当前的调用深度，并根据预设的深度阈值来决定是否执行其核心逻辑。这可以通过在装饰器函数本身上维护一个内部计数器来实现。

2.1 核心思想

内部计数器： 在装饰器函数内部定义一个属性（例如 _timer_running），用作一个全局的计数器，追踪当前有多少层级的被装饰函数正在执行。
深度阈值： 引入一个常量 DEPTH，表示我们希望打印计时信息的最大嵌套深度。例如，DEPTH = 1 意味着只打印最外层函数的计时。
条件判断： 在 wrapper 函数中，每次执行被装饰函数前，检查当前计数器是否已达到或超过 DEPTH。如果达到，则跳过计时和打印逻辑，直接调用原函数；否则，增加计数器，执行计时逻辑，并在完成后减少计数器。

2.2 实现细节

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

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

import time
from functools import wraps

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

    # 初始化一个内部计数器，用于追踪当前装饰器调用栈的深度。
    # 首次调用时，time_elapsed._timer_running 为 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

# 应用到多个函数，包括嵌套调用
@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 func1 ---")
    func1()
    print("\n--- Testing func2 ---")
    func2()
    print("\n--- Testing func3 ---")
    func3()
    print("\n--- Testing func4 ---")
    func4()

登录后复制

2.3 运行效果

当 DEPTH = 1 时，运行上述代码将得到以下输出：

--- Testing func1 ---
func1 took 0.10 seconds.

--- Testing func2 ---
func2 took 0.30 seconds.

--- Testing func3 ---
func3 took 0.70 seconds.

--- Testing func4 ---
func4 took 1.50 seconds.

登录后复制

可以看到，只有最外层的函数调用被计时并打印。内部 func1、func2、func3 的调用虽然仍然通过了装饰器，但由于 _timer_running 计数器已经达到或超过 DEPTH，它们的计时和打印逻辑被跳过。

2.4 调整深度阈值

这个解决方案的强大之处在于 DEPTH 参数的可配置性。如果你希望看到更深层次的调用计时，只需修改 DEPTH 的值。

降重鸟

要想效果好，就用降重鸟。AI改写智能降低AIGC率和重复率。

113

查看详情

例如，将 DEPTH = 2：

# ... (其他代码相同)

def time_elapsed(func):
    DEPTH = 2 # 允许打印两层嵌套的计时信息
    # ... (其他代码相同)

登录后复制

再次运行 if __name__ == "__main__": 块，输出将变为：

--- Testing func1 ---
func1 took 0.10 seconds.

--- Testing func2 ---
func1 took 0.10 seconds.  # func1 作为 func2 的直接子函数，被打印
func2 took 0.30 seconds.

--- Testing func3 ---
func1 took 0.10 seconds.  # func1 作为 func3 的直接子函数，被打印
func2 took 0.30 seconds.  # func2 作为 func3 的直接子函数，被打印
func3 took 0.70 seconds.

--- Testing func4 ---
func1 took 0.10 seconds.  # func1 作为 func4 的直接子函数，被打印
func2 took 0.30 seconds.  # func2 作为 func4 的直接子函数，被打印
func3 took 0.70 seconds.  # func3 作为 func4 的直接子函数，被打印
func4 took 1.50 seconds.

登录后复制

现在，func2 内部调用的 func1 的计时被打印了出来，因为它的调用深度是 2（相对于 func2 是 1，相对于最初的外部调用是 2），这仍然在 DEPTH = 2 的允许范围内。但 func3 内部调用的 func1 和 func2 仍然只打印了一次，因为它们是 func3 的直接子函数，深度为 2。而 func4 内部调用的 func1、func2 和 func3 也都打印了，因为它们相对于 func4 都是第一层嵌套，总深度为 2。

3. 注意事项与总结

线程安全： 上述 _timer_running 计数器是直接附加在 time_elapsed 函数对象上的，这意味着它是一个全局状态。在多线程环境中，多个线程同时调用被装饰函数时，这个计数器可能会出现竞态条件，导致不正确的行为。在多线程应用中，应考虑使用 threading.local() 来为每个线程维护独立的计数器。

import threading

def time_elapsed_thread_safe(func):
    _local = threading.local()
    _local.timer_running = 0 # 每个线程有自己的计数器

    DEPTH = 1

    @wraps(func)
    def wrapper(*args, **kwargs):
        # ... 使用 _local.timer_running 代替 time_elapsed._timer_running ...
        if _local.timer_running >= DEPTH:
            return func(*args, **kwargs)

        _local.timer_running += 1
        # ... 计时逻辑 ...
        _local.timer_running -= 1
        return result
    return wrapper

登录后复制