Python中如何同时限制两个函数的递归调用及循环内执行次数？

针对你提出的两个需求，我会分步骤给出可落地的实现方案，代码都是可直接复用的：

1. 通用递归次数限制：装饰器实现 #

要同时限制两个函数的递归调用次数，最优雅的方式是用带参数的装饰器——它能为每个函数独立维护调用计数器，而且不需要修改函数本身的逻辑。

下面是装饰器的完整实现，还附带了计数器重置方法（满足你循环内每次迭代重新计数的需求）：

from functools import wraps

def limit_recursion(max_calls):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 初始化计数器：用函数属性存储，每个函数独立计数
            if not hasattr(wrapper, 'call_count'):
                wrapper.call_count = 0
            
            wrapper.call_count += 1
            # 达到上限时停止递归（这里可以选择返回或抛异常，按需调整）
            if wrapper.call_count > max_calls:
                print(f"⚠️ {func.__name__} 递归次数超过上限 {max_calls}，终止执行")
                return None  # 或者抛出自定义异常
            
            return func(*args, **kwargs)
        
        # 给装饰后的函数添加重置计数器的方法
        def reset_counter():
            wrapper.call_count = 0
        wrapper.reset_counter = reset_counter
        
        return wrapper
    return decorator

2. 装饰你的目标函数f1和f2 #

用上面的装饰器装饰你的实际函数，指定最大递归次数为10。不管你的函数是自递归还是互相递归，都能精准限制各自的调用次数：

示例1：自递归函数 #

@limit_recursion(10)
def f1(n):
    # 替换成你的实际业务逻辑
    print(f"f1 第{f1.call_count}次调用，当前参数: {n}")
    if n > 0:
        return f1(n - 1)
    return "f1 递归完成"

@limit_recursion(10)
def f2(n):
    # 替换成你的实际业务逻辑
    print(f"f2 第{f2.call_count}次调用，当前参数: {n}")
    if n > 0:
        return f2(n - 1)
    return "f2 递归完成"

示例2：互相递归函数（如果你的场景是f1调用f2、f2调用f1） #

@limit_recursion(10)
def f1(n):
    print(f"f1 第{f1.call_count}次调用，当前参数: {n}")
    if n > 0:
        return f2(n - 1)
    return "f1 递归完成"

@limit_recursion(10)
def f2(n):
    print(f"f2 第{f2.call_count}次调用，当前参数: {n}")
    if n > 0:
        return f1(n - 1)
    return "f2 递归完成"

3. For循环内的迭代控制 #

在每次循环迭代开始前，调用两个函数的reset_counter()方法重置计数器，这样每次循环中f1和f2都能从0开始计数，最多执行10次递归：

# 假设你的循环遍历这些值（替换成你的实际迭代对象）
for item in [5, 15, 8]:
    print(f"\n===== 处理循环项: {item} =====")
    
    # 重置两个函数的递归计数器，确保每次循环都是全新的计数
    f1.reset_counter()
    f2.reset_counter()
    
    # 执行f1和f2，此时它们的递归次数会被限制在10次以内
    result1 = f1(item)
    print(f"f1 执行结果: {result1}")
    
    result2 = f2(item)
    print(f"f2 执行结果: {result2}")

关键细节说明 #

• 独立计数：每个被装饰的函数有自己的计数器，f1的调用次数不会影响f2，反之亦然。
• 灵活调整：如果需要修改最大递归次数，只需要修改装饰器的参数（比如改成@limit_recursion(15)）即可。
• 异常处理：如果需要明确捕获递归超限的情况，可以把装饰器里的return None改成抛出自定义异常，然后在调用时用try-except处理。

内容的提问来源于stack exchange，提问作者Sourav Kar