如何为可变长度对象列表实现层级嵌套的call_method调用逻辑？

你需要的是一种回溯式的层级重试逻辑：每一层实例调用成功后才进入下一层，下一层调用失败则回到当前层重新尝试，直到最内层调用成功时返回所有层级的结果，或最外层调用失败时整体终止。以下是两种实现方案：

递归实现（简洁直观） #

递归天然适配这种嵌套层级结构，代码逻辑和你给出的示例完全对应：

def get_success_sequence(objs):
    def backtrack(index, collected):
        # 已处理完所有实例，返回收集到的结果
        if index == len(objs):
            return collected.copy()
        
        current_obj = objs[index]
        while True:
            v, s = current_obj.call_method()
            if not s:
                # 当前实例调用失败，返回None触发上层重试
                return None
            
            # 当前调用成功，进入下一层级
            result = backtrack(index + 1, collected + [v])
            if result is not None:
                # 下层返回有效结果，直接向上传递
                return result
            # 下层调用失败，当前实例继续重试

    return backtrack(0, [])

逻辑说明 #

• backtrack函数负责处理第index个实例，collected存储前面层级成功获取的结果值
• 对当前实例循环调用call_method()：
  • 若s=False，返回None通知上一层重试
  • 若s=True，递归处理下一层级；如果下层返回有效结果，直接返回；如果下层失败，当前实例继续循环重试

迭代实现（避免递归深度限制） #

如果实例列表长度很大，递归可能触发栈溢出，这时可以用栈模拟递归过程：

def get_success_sequence_iterative(objs):
    obj_count = len(objs)
    if obj_count == 0:
        return []
    
    # 栈元素格式：(当前处理的实例索引, 已收集的结果列表)
    stack = [(0, [])]
    
    while stack:
        index, collected = stack.pop()
        current_obj = objs[index]
        
        while True:
            v, s = current_obj.call_method()
            if not s:
                # 当前实例调用失败，跳出循环回到上一层
                break
            
            if index == obj_count - 1:
                # 最后一个实例调用成功，直接返回完整结果
                return collected + [v]
            
            # 将当前层级状态压回栈（后续可能需要重试），再压入下一层级状态
            stack.append((index, collected))
            stack.append((index + 1, collected + [v]))
            # 跳出当前循环，处理下一层级
            break
    
    # 所有层级都失败，返回None（可根据需求改为空列表）
    return None

逻辑说明 #

• 用栈保存每个层级的状态，弹出栈元素时处理对应实例
• 实例调用成功时：
  • 若为最后一个实例，直接返回结果
  • 否则将当前层级状态压回栈，再压入下一层级状态，继续处理下一层
• 实例调用失败时，直接跳出循环，回到上一层级继续处理

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