提问人：ʞɔıu 提问时间：2/11/2009 最后编辑：Karl Knechtelʞɔıu 更新时间：4/19/2023 访问量：371353
如何获取多个列表的笛卡尔积
How to get the Cartesian product of multiple lists
问：
如何从一组列表中获取笛卡尔积（每个可能的值组合）？
例如，给定
somelists = [
[1, 2, 3],
['a', 'b'],
[4, 5]
]
我如何得到这个？
[(1, 'a', 4), (1, 'a', 5), (1, 'b', 4), (1, 'b', 5), (2, 'a', 4), (2, 'a', 5), ...]
此技术的一个常见应用是避免深度嵌套循环。有关更具体的重复项，请参阅避免嵌套 for 循环。同样，这种技术可用于“分解”具有列表值的字典;请参 阅将 Python 字典排列组合到字典列表中 。
如果您想要同一列表的笛卡尔积多次出现，itertools.product 可以优雅地处理它。请参阅对列表中的每对元素的操作或如何从列表中获取“重复排列”（列表与自身的笛卡尔乘积）？。
许多已经了解 itertools.product 的人都在为这样一个事实而苦苦挣扎，即它期望每个输入序列都有单独的参数，而不是例如列表列表。接受的答案显示了如何使用 * 处理此问题。但是，在这里使用 * 来解压缩参数与在函数调用中使用的任何其他时候根本上没有什么不同。请参阅将元组扩展为本主题的参数（并根据需要改用它来关闭重复的问题）。
答：
632赞
Kenan Banks
2/11/2009
#1
使用 itertools.product，它从 Python 2.6 开始可用。
import itertools
somelists = [
[1, 2, 3],
['a', 'b'],
[4, 5]
]
for element in itertools.product(*somelists):
print(element)
这与以下相同：
for element in itertools.product([1, 2, 3], ['a', 'b'], [4, 5]):
print(element)
评论
35赞
brian buck
1/14/2011
如果您使用 OP 提供的变量 somelists，则只想添加“*”字符是必需的。
1赞
jfs
8/15/2015
@jaska：在结果 （） 中生成元素。没有理由相信生成单个元素不是（摊销的），即时间复杂度与简单的嵌套 for 循环相同，例如，对于问题中的输入：，结果中的元素总数：，并且每个元素都有项目（在本例中）。product()nitems_in_a_list ** nlistsreduce(mul, map(len, somelists))O(nlists)nlists=33*2*2nlists3
5赞
Vineet Kumar Doshi
8/25/2015
在somelists之前有什么用？它有什么作用？*
13赞
Moberg
9/15/2015
@VineetKumarDoshi：这里它用于将列表解压缩为函数调用的多个参数。在这里阅读更多： stackoverflow.com/questions/36901/...
2赞
normanius
12/6/2018
只是一个细节，但请注意，它也可以处理生成器，而不仅仅是类似列表的对象。itertools.product()
124赞
Jason Baker
2/11/2009
#2
import itertools
>>> for i in itertools.product([1,2,3],['a','b'],[4,5]):
... print i
...
(1, 'a', 4)
(1, 'a', 5)
(1, 'b', 4)
(1, 'b', 5)
(2, 'a', 4)
(2, 'a', 5)
(2, 'b', 4)
(2, 'b', 5)
(3, 'a', 4)
(3, 'a', 5)
(3, 'b', 4)
(3, 'b', 5)
>>>
33赞
SilentGhost
2/11/2009
#3
import itertools
result = list(itertools.product(*somelists))
评论
7赞
Vineet Kumar Doshi
8/25/2015
在somelists之前有什么用？*
1赞
hhh
2/16/2016
@VineetKumarDoshi “product（somelists）” 是子列表之间的笛卡尔乘积，其方式是 Python 首先获取“[1， 2， 3]”作为元素，然后在下一个逗号之后获取其他元素，即换行符，因此第一个乘积项是 （[1， 2， 3]，），第二个 （[4， 5]，） 类似，因此 “[（[1， 2， 3]，）， （[4， 5]，），（[6,7]，）]”。如果你想在元组内的元素之间得到一个笛卡尔积，你需要用星号告诉 Python 关于元组结构的信息。对于字典，请使用 **。更多内容请点击此处。
0赞
Solomon Ucko
3/24/2023
@VineetKumarDoshi 见 stackoverflow.com/questions/36901/....
11赞
user3850
2/11/2009
#4
在 Python 2.6 及更高版本中，您可以使用“itertools.product”。在旧版本的 Python 中，您可以使用文档中的以下（几乎 -- 参见文档）等效代码，至少作为起点：
def product(*args, **kwds):
# product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
# product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
pools = map(tuple, args) * kwds.get('repeat', 1)
result = [[]]
for pool in pools:
result = [x+[y] for x in result for y in pool]
for prod in result:
yield tuple(prod)
两者的结果都是一个迭代器，因此，如果您确实需要一个列表进行进一步处理，请使用 。list(result)
评论
0赞
Kenan Banks
2/11/2009
根据文档，实际的 itertools.product 实现不会构建中间结果，这可能会很昂贵。对于中等大小的列表，使用此技术可能会很快失控。
5赞
2/11/2009
我只能将 OP 指向文档，而不是为他阅读。
1赞
Kenan Banks
3/11/2009
文档中的代码旨在演示产品函数的作用，而不是作为早期版本的 Python 的解决方法。
44赞
jfs
2/11/2009
#5
对于 Python 2.5 及更早版本：
>>> [(a, b, c) for a in [1,2,3] for b in ['a','b'] for c in [4,5]]
[(1, 'a', 4), (1, 'a', 5), (1, 'b', 4), (1, 'b', 5), (2, 'a', 4),
(2, 'a', 5), (2, 'b', 4), (2, 'b', 5), (3, 'a', 4), (3, 'a', 5),
(3, 'b', 4), (3, 'b', 5)]
下面是一个递归版本（只是一个插图）：product()
def product(*args):
if not args:
return iter(((),)) # yield tuple()
return (items + (item,)
for items in product(*args[:-1]) for item in args[-1])
例：
>>> list(product([1,2,3], ['a','b'], [4,5]))
[(1, 'a', 4), (1, 'a', 5), (1, 'b', 4), (1, 'b', 5), (2, 'a', 4),
(2, 'a', 5), (2, 'b', 4), (2, 'b', 5), (3, 'a', 4), (3, 'a', 5),
(3, 'b', 4), (3, 'b', 5)]
>>> list(product([1,2,3]))
[(1,), (2,), (3,)]
>>> list(product([]))
[]
>>> list(product())
[()]
评论
1赞
jfs
2/11/2009
如果某些是迭代器，则递归版本不起作用。args
18赞
Anurag Uniyal
6/14/2013
#6
这是一个递归生成器，它不存储任何临时列表
def product(ar_list):
if not ar_list:
yield ()
else:
for a in ar_list[0]:
for prod in product(ar_list[1:]):
yield (a,)+prod
print list(product([[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)]
评论
2赞
Quentin Pradet
3/16/2015
不过，它们存储在堆栈中。
0赞
Anurag Uniyal
3/17/2015
@QuentinPradet你的意思是，当我们通过它时，像这样的发电机会不断增加其堆栈大小？def f(): while True: yield 1
0赞
Anurag Uniyal
3/18/2015
@QuentinPradet是的，但即使在这种情况下，也只有最大深度所需的堆栈，而不是整个列表，所以在这种情况下，堆栈为 3
0赞
Quentin Pradet
3/18/2015
这是真的，对不起。基准测试可能很有趣。:)
0赞
njzk2
3/8/2023
我们现在有了收益，这让事情变得更简单了
2赞
Tyler Heers
10/30/2015
#7
只是为了补充一点已经说过的内容：如果你使用 SymPy，你可以使用符号而不是字符串，这使得它们在数学上很有用。
import itertools
import sympy
x, y = sympy.symbols('x y')
somelist = [[x,y], [1,2,3], [4,5]]
somelist2 = [[1,2], [1,2,3], [4,5]]
for element in itertools.product(*somelist):
print element
41赞
user1035648
11/21/2016
#8
我会使用列表推导：
somelists = [
[1, 2, 3],
['a', 'b'],
[4, 5]
]
cart_prod = [(a,b,c) for a in somelists[0] for b in somelists[1] for c in somelists[2]]
评论
33赞
Bằng Rikimaru
1/16/2017
@llekn因为代码似乎固定在列表的数量上
0赞
Lucas Schwartz
12/12/2021
@Bằng Rikimaru 列表理解是如何固定的？lst = [i for i in itertools.product(*somelists)]
1赞
Lucas Lima
4/19/2022
@LucasSchwartz这个答案不使用 itertools，但它使用链式列表推导循环。基本上，您的解决方案是另一个答案。
3赞
Mike Lu
12/10/2016
#9
对上述递归生成器解决方案的微小修改，采用可变特性：
def product_args(*args):
if args:
for a in args[0]:
for prod in product_args(*args[1:]) if args[1:] else ((),):
yield (a,) + prod
当然，还有一个包装器，它使它的工作方式与该解决方案完全相同：
def product2(ar_list):
"""
>>> list(product(()))
[()]
>>> list(product2(()))
[]
"""
return product_args(*ar_list)
有一个权衡：它检查递归是否应该在每个外部循环上中断，还有一个收获：在空调用时没有屈服，例如，我认为这在语义上会更正确（参见 doctest）。product(())
关于列表理解：数学定义适用于任意数量的参数，而列表理解只能处理已知数量的参数。
9赞
weiyixie
2/21/2017
#10
虽然已经有很多答案，但我想分享我的一些想法：
迭代方法
def cartesian_iterative(pools):
result = [[]]
for pool in pools:
result = [x+[y] for x in result for y in pool]
return result
递归方法
def cartesian_recursive(pools):
if len(pools) > 2:
pools[0] = product(pools[0], pools[1])
del pools[1]
return cartesian_recursive(pools)
else:
pools[0] = product(pools[0], pools[1])
del pools[1]
return pools
def product(x, y):
return [xx + [yy] if isinstance(xx, list) else [xx] + [yy] for xx in x for yy in y]
Lambda 方法
def cartesian_reduct(pools):
return reduce(lambda x,y: product(x,y) , pools)
评论
0赞
Sachin S
7/16/2017
在“迭代方法”中，为什么结果声明为 result = [[]] 我知道它是list_of_list但一般来说，即使我们声明了list_of_list我们也会使用 [] 而不是 [[]]
1赞
Johnny Boy
12/11/2018
就 Python 解决方案而言，我有点新手。您或一些路人能否在单独的循环中以“迭代方法”编写列表理解？
0赞
Daniel
7/16/2020
@SachinS在外部列表中使用内部列表，因为您循环访问外部列表（对于结果中的 x），并且内部列表意味着外部列表不为空。如果它为空，则不会发生迭代，因为“result”中没有 x。然后，将项目添加到该列表中。这个例子几乎取自官方文档，但我敢说它比显式更隐含。如果你像 Johny Boy 所说的那样，仅基于循环将其重构为代码并删去理解，那么将需要更多的代码。
1赞
blkpingu
12/18/2020
什么？它是我想要的产品列表吗？pools
1赞
CyTex
11/24/2022
有人可以帮忙解释一下这句话吗return [xx + [yy] if isinstance(xx, list) else [xx] + [yy] for xx in x for yy in y]
9赞
Jai
1/1/2019
#11
递归方法：
def rec_cart(start, array, partial, results):
if len(partial) == len(array):
results.append(partial)
return
for element in array[start]:
rec_cart(start+1, array, partial+[element], results)
rec_res = []
some_lists = [[1, 2, 3], ['a', 'b'], [4, 5]]
rec_cart(0, some_lists, [], rec_res)
print(rec_res)
迭代方法：
def itr_cart(array):
results = [[]]
for i in range(len(array)):
temp = []
for res in results:
for element in array[i]:
temp.append(res+[element])
results = temp
return results
some_lists = [[1, 2, 3], ['a', 'b'], [4, 5]]
itr_res = itr_cart(some_lists)
print(itr_res)
0赞
Richard Samuelson
1/4/2020
#12
我相信这有效：
def cartesian_product(L):
if L:
return {(a,) + b for a in L[0]
for b in cartesian_product(L[1:])}
else:
return {()}
2赞
chriskoch
12/13/2020
#13
您可以在标准库中获取笛卡尔积。其他很酷的相关实用程序包括 、 和 。以下是以下代码片段的 Python CodePen 链接：itertools.productitertoolspermutationscombinationscombinations_with_replacement
from itertools import product
somelists = [
[1, 2, 3],
['a', 'b'],
[4, 5]
]
result = list(product(*somelists))
print(result)
0赞
questionto42
7/17/2021
#14
以下代码是使用 NumPy 构建两个数组的所有组合的数组的 95% 副本;所有学分都在那里！据说这要快得多，因为它仅在 NumPy 中。
import numpy as np
def cartesian(arrays, dtype=None, out=None):
arrays = [np.asarray(x) for x in arrays]
if dtype is None:
dtype = arrays[0].dtype
n = np.prod([x.size for x in arrays])
if out is None:
out = np.zeros([n, len(arrays)], dtype=dtype)
m = int(n / arrays[0].size)
out[:,0] = np.repeat(arrays[0], m)
if arrays[1:]:
cartesian(arrays[1:], out=out[0:m, 1:])
for j in range(1, arrays[0].size):
out[j*m:(j+1)*m, 1:] = out[0:m, 1:]
return out
如果不想从所有条目的第一个条目中获取 dtype，则需要将 dtype 定义为参数。如果将字母和数字作为项目，则使用 dtype = 'object'。测试：
somelists = [
[1, 2, 3],
['a', 'b'],
[4, 5]
]
[tuple(x) for x in cartesian(somelists, 'object')]
外：
[(1, 'a', 4),
(1, 'a', 5),
(1, 'b', 4),
(1, 'b', 5),
(2, 'a', 4),
(2, 'a', 5),
(2, 'b', 4),
(2, 'b', 5),
(3, 'a', 4),
(3, 'a', 5),
(3, 'b', 4),
(3, 'b', 5)]
1赞
Sergio Polimante
9/17/2021
#15
这可以像
[(x, y) for x in range(10) for y in range(10)]
另一个变量？没关系：
[(x, y, z) for x in range(10) for y in range(10) for z in range(10)]
1赞
Lucas Schwartz
12/12/2021
#16
列表理解简单明了：
import itertools
somelists = [
[1, 2, 3],
['a', 'b'],
[4, 5]
]
lst = [i for i in itertools.product(*somelists)]
2赞
Jack Taylor
9/10/2022
#17
在 99% 的情况下，您应该使用 itertools.product。它是用高效的 C 代码编写的，因此它可能比任何自定义实现都要好。
在 1% 的情况下，您需要仅使用 Python 算法（例如，如果您需要以某种方式修改它），您可以使用下面的代码。
def product(*args, repeat=1):
"""Find the Cartesian product of the arguments.
The interface is identical to itertools.product.
"""
# Initialize data structures and handle bad input
if len(args) == 0:
yield () # Match behavior of itertools.product
return
gears = [tuple(arg) for arg in args] * repeat
for gear in gears:
if len(gear) == 0:
return
tooth_numbers = [0] * len(gears)
result = [gear[0] for gear in gears]
# Rotate through all gears
last_gear_number = len(gears) - 1
finished = False
while not finished:
yield tuple(result)
# Get next result
gear_number = last_gear_number
while gear_number >= 0:
gear = gears[gear_number]
tooth_number = tooth_numbers[gear_number] + 1
if tooth_number < len(gear):
# No gear change is necessary, so exit the loop
result[gear_number] = gear[tooth_number]
tooth_numbers[gear_number] = tooth_number
break
result[gear_number] = gear[0]
tooth_numbers[gear_number] = 0
gear_number -= 1
else:
# We changed all the gears, so we are back at the beginning
finished = True
该接口与 itertools.product 的接口相同。例如：
>>> list(product((1, 2), "ab"))
[(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
与本页上的其他纯 Python 解决方案相比，此算法具有以下优点：
- 它不会在内存中建立中间结果，从而保持较小的内存占用。
- 它使用迭代而不是递归，这意味着您不会收到“超出最大递归深度”错误。
- 它可以接受任意数量的输入可迭代对象，使其比使用嵌套的 for 循环更灵活。
此代码基于 PyPy 的 itertools.product 算法，该算法在 MIT 许可下发布。
评论
0赞
Eric Zinda
4/19/2023
我也喜欢这个，因为它是迄今为止唯一一个可以轻松修改以流式传输答案而无需实例化传入的迭代器。因此，如果你正在做一堆非常大（或无限，或昂贵）迭代器的产物，并且你可能会在结束之前停止，你只需要实现你需要的尽可能多的东西。我在下面的帖子中添加了一种方法
1赞
njzk2
3/8/2023
#18
如果你想自己重新实现它，你可以尝试递归。像这样简单的事情：
def product(cats, prefix = ()):
if not cats:
yield prefix
else:
head, *tail = cats
for cat in head:
yield from product(tail, prefix + (cat,))
是一个有效的开始。
递归深度是您拥有的类别列表数量。
1赞
Eric Zinda
4/19/2023
#19
我喜欢上面的 jack taylor 的实现，因为它是迄今为止唯一一个可以轻松修改以流式传输答案而无需实例化传入的迭代器的实现。所以，如果你正在做一堆非常大（或无限，或昂贵）迭代器的产物，并且你可能会在结束之前停止，你只需要实现你需要的尽可能多的东西。
以下是为此修改它的一种方法：
def product_stream(*args, repeat=1):
"""Find the Cartesian product of the arguments.
The interface is identical to itertools.product.
"""
def index_from_stream(array_stream, index):
try:
while index >= len(array_stream[0]):
next_element = next(array_stream[1])
array_stream[0].append(next_element)
return True, array_stream[0][index]
except StopIteration:
return False, None
# Initialize data structures and handle bad input
if len(args) == 0:
# Match behavior of itertools.product
yield ()
return
gears = [([], arg) for arg in args] * repeat
for gear in gears:
if not index_from_stream(gear, 0)[0]:
return
tooth_numbers = [0] * len(gears)
result = [index_from_stream(gear, 0)[1] for gear in gears]
# Rotate through all gears
last_gear_number = len(gears) - 1
finished = False
while not finished:
yield tuple(result)
# Get next result
gear_number = last_gear_number
while gear_number >= 0:
gear = gears[gear_number]
tooth_number = tooth_numbers[gear_number] + 1
has_tooth, gear_tooth_value = index_from_stream(gear, tooth_number)
if has_tooth:
# No gear change is necessary, so exit the loop
result[gear_number] = gear_tooth_value
tooth_numbers[gear_number] = tooth_number
break
_, result[gear_number] = index_from_stream(gear, 0)
tooth_numbers[gear_number] = 0
gear_number -= 1
else:
# We changed all the gears, so we are back at the beginning
finished = True
评论
set(cartesian product)set(inputlist)itertools.productitertools.productset