装饰器在嵌套函数中的重复输出问题
在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 时，输出如下：
--- 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 作为装饰器的参数传入，使其更具灵活性。
- 适用性：这种方法不仅限于计时装饰器，也可以应用于任何需要在嵌套函数调用中控制行为的场景，例如日志记录、性能监控等。
通过这种方式，我们可以在保持代码简洁性的同时，实现对复杂函数调用链中装饰器行为的精细控制。
