如何对可变长度的生成器列表实现嵌套循环？

针对你提出的「基于可变长度生成器列表实现可变深度嵌套循环，且支持在各层级插入自定义逻辑」的需求，这里提供两种简洁的实现方式：递归式和迭代式（栈模拟），两种方式都能灵活适配任意层级的逻辑插入。

一、递归实现（直观易读） #

递归的核心思路是逐层处理生成器，维护当前已遍历的元素和索引状态，到达最后一层时执行目标操作。

代码实现 #

def nested_loop(gens, do_something):
    def recurse(current_level, current_elements, current_indices):
        # 到达最后一层的下一级，执行目标操作
        if current_level == len(gens):
            do_something(current_elements.copy(), current_indices.copy())
            return
        
        current_gen = gens[current_level]
        count = 0
        # 遍历当前层级的生成器
        for element in current_gen:
            count += 1
            # 记录当前元素和对应索引
            current_elements.append(element)
            current_indices.append(count)
            # 递归处理下一层级
            recurse(current_level + 1, current_elements, current_indices)
            # 回溯，清除当前层级的记录
            current_elements.pop()
            current_indices.pop()
    
    # 从第0层开始递归
    recurse(0, [], [])

测试示例 #

假设我们需要打印各层元素和对应的循环计数：

def demo_do_something(elements, indices):
    print(f"元素列表: {elements}, 循环计数: {indices}")

# 测试用生成器列表，模拟2层嵌套循环
generator_list = [range(2), range(3)]
nested_loop(generator_list, demo_do_something)

输出结果 #

元素列表: [0, 0], 循环计数: [1, 1]
元素列表: [0, 1], 循环计数: [1, 2]
元素列表: [0, 2], 循环计数: [1, 3]
元素列表: [1, 0], 循环计数: [2, 1]
元素列表: [1, 1], 循环计数: [2, 2]
元素列表: [1, 2], 循环计数: [2, 3]

二、迭代实现（避免递归栈溢出） #

如果生成器列表的长度n极大，递归会导致栈溢出问题，此时可以用栈模拟递归过程，实现迭代式的可变深度循环。

代码实现 #

def nested_loop_iterative(gens, do_something):
    if not gens:
        return
    
    # 栈元素结构：(当前层级, 生成器迭代器, 当前计数, 已选元素列表, 已选索引列表)
    stack = [ (0, iter(gens[0]), 0, [], []) ]
    
    while stack:
        level, gen_iter, count, elements, indices = stack.pop()
        
        try:
            # 取出当前生成器的下一个元素
            element = next(gen_iter)
            count += 1
            # 将当前状态重新压入栈，后续继续迭代当前生成器的剩余元素
            stack.append( (level, gen_iter, count, elements.copy(), indices.copy()) )
            
            # 更新元素和索引列表
            new_elements = elements + [element]
            new_indices = indices + [count]
            
            if level == len(gens) - 1:
                # 到达最后一层，执行目标操作
                do_something(new_elements, new_indices)
            else:
                # 压入下一层级的初始状态
                next_gen = iter(gens[level + 1])
                stack.append( (level + 1, next_gen, 0, new_elements, new_indices) )
        except StopIteration:
            # 当前生成器迭代完毕，跳过
            continue

说明 #

迭代方式通过栈保存每一层的迭代状态，每次弹出栈顶元素处理，遇到未迭代完的生成器就把当前状态回压栈，再处理下一层级。这种方式不会受递归深度限制，适合处理n较大的场景。

灵活扩展逻辑 #

两种实现都支持在任意层级插入自定义代码：

• 若要在进入某层级循环前执行逻辑，可在递归的for循环前、或迭代的压入下一层级前添加代码；
• 若要在某层级循环结束后执行逻辑，可在递归的for循环后、或迭代的StopIteration分支中添加代码。

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