如何手动实现可变长度嵌套列表的笛卡尔积？

问题场景 #

给定嵌套列表：

a = [[1, 2], [3, 4], [5, 6]]

需要生成所有元素的笛卡尔积，预期结果：

[(1, 3, 5), (1, 3, 6), (1, 4, 5), (1, 4, 6), (2, 3, 5), (2, 3, 6), (2, 4, 5), (2, 4, 6)]

当前用固定层数嵌套循环实现，但嵌套列表长度变化时需手动调整循环层数，希望手动实现通用的笛卡尔积逻辑，替代itertools.product。

实现方案 #

方法1：递归实现

通过递归拆分问题，将多列表的笛卡尔积拆解为单列表元素与剩余列表笛卡尔积的组合：

def my_product(lists):
    # 终止条件：空列表返回包含空元组的列表，作为组合的基础
    if not lists:
        return [()]
    # 拆分第一个子列表和剩余列表
    first_list = lists[0]
    rest_product = my_product(lists[1:])
    # 组合第一个列表的每个元素与剩余列表的所有组合
    return [(item,) + combo for item in first_list for combo in rest_product]

# 测试
a = [[1, 2], [3, 4], [5, 6]]
print(my_product(a))

方法2：迭代实现

从空元组开始，逐个处理每个子列表，逐步扩展组合结果：

def my_product(lists):
    # 初始结果为包含空元组的列表
    result = [()]
    for current_list in lists:
        temp = []
        # 将现有每个组合与当前列表的元素拼接
        for combo in result:
            for item in current_list:
                temp.append(combo + (item,))
        result = temp
    return result

# 测试
a = [[1, 2], [3, 4], [5, 6]]
print(my_product(a))

原理说明 #

• 递归方式：不断缩小问题规模，把n个列表的笛卡尔积转化为「第一个列表元素」和「n-1个列表的笛卡尔积」的拼接，直到处理完所有列表。
• 迭代方式：从最基础的空组合出发，每处理一个子列表就更新一次结果集，最终得到所有可能的元素组合。

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