Python函数中实现可变数量循环的技术问询

嘿，这个问题我太熟了！你现在写的函数需要针对参数个数写不同的分支，确实不够灵活——其实Python里有两种非常优雅的方式可以实现通用的任意层数嵌套循环，不用写一堆if判断，我给你一步步讲清楚：

方法一：用itertools.product（最简洁高效） #

Python标准库的itertools.product专门用来生成多个可迭代对象的笛卡尔积，这正好对应你想要的多层嵌套循环的所有组合。直接用它就能省去所有分支判断：

import itertools

d1 = {'a':1,'b':2,'c':3}
d2 = {'aa':11,'bb':22,'cc':33}
d3 = {'aaa':111,'bbb':222,'ccc':333}

def nLoop(*args):
    # 把每个字典转换成(key, value)的迭代器列表
    dict_pairs = [d.items() for d in args]
    # 生成所有字典键值对的笛卡尔积
    for combo in itertools.product(*dict_pairs):
        # 把每个组合里的键值对拼接成字符串打印
        print(' '.join(f"{k} {v}" for k, v in combo))

nLoop(d1,d2,d3)

代码解释：

• d.items()会返回字典的键值对迭代器（Python 3里直接用这个就行，Python 2可以换成d.iteritems()）；
• itertools.product(*dict_pairs)会自动帮你把所有字典的键值对做嵌套遍历，每个combo就是一次多层循环的结果（比如3个字典时，combo是((a,1), (aa,11), (aaa,111))这样的元组）；
• 最后用join把每个键值对拼接成你需要的格式打印，和原来的分支写法效果完全一致。

方法二：递归实现（理解嵌套循环本质） #

如果不想依赖标准库，或者想自己理解多层嵌套的逻辑，递归是个很好的思路。核心就是用递归函数逐层遍历字典，直到所有字典都处理完再打印结果：

d1 = {'a':1,'b':2,'c':3}
d2 = {'aa':11,'bb':22,'cc':33}
d3 = {'aaa':111,'bbb':222,'ccc':333}

def nLoop(*args):
    def recursive_traverse(current_index, collected_pairs):
        # 递归终止条件：所有字典都遍历完了
        if current_index == len(args):
            print(' '.join(collected_pairs))
            return
        # 遍历当前字典的每个键值对
        for k, v in args[current_index].items():
            # 把当前键值对加入已收集的列表，递归处理下一个字典
            recursive_traverse(current_index + 1, collected_pairs + [f"{k} {v}"])
    
    # 从第0个字典开始，初始收集列表为空
    recursive_traverse(0, [])

nLoop(d1,d2,d3)

代码解释：

• 辅助函数recursive_traverse的current_index表示当前正在处理第几个字典，collected_pairs保存已经遍历过的键值对字符串；
• 每次递归都会处理下一个字典，把当前的键值对加入列表，直到所有字典都处理完（current_index == len(args)），就打印收集到的所有内容；
• 这种写法完全不依赖外部库，而且可以灵活扩展到任意数量的字典参数。

两种方法对比 #

• 如果是日常开发，优先选itertools.product，它是Python官方优化过的实现，效率更高，代码也更简洁；
• 递归写法适合用来学习理解嵌套循环的本质，自己手动实现逻辑的时候可以用。

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