获取一系列列表的笛卡尔积？

317

如何从一组列表中获得笛卡尔积（值的所有可能组合）？

输入： 

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) ...]
python  list  cartesian-product 
— ʞɔıu
source
24
请注意，“所有可能的组合”与“笛卡尔乘积”并不完全相同，因为在笛卡尔乘积中允许重复。
— 三联画
7
笛卡尔积是否存在非重复版本？
— KJW 2013年
16
@KJW是，set(cartesian product)
— NoBugs 2015年
5
笛卡尔积中不应有重复项，除非输入列表本身包含重复项。如果您不希望笛卡尔积中有重复项，请使用set(inputlist)所有输入列表。不在结果上。
— CamilB
@Triptych是什么？笛卡尔积的标准定义是一组。为什么会有这么多人支持？
— PascalIv

Answers:

378

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)
— 三联画
source
22
如果您使用OP提供的变量some​​lists，则只需要添加'*'字符即可。
— brian buck
1
@jaska：在结果（）中product()生成nitems_in_a_list ** nlists元素reduce(mul, map(len, somelists))。没有理由相信不会O(nlists)（摊销）产生单个元素，即时间复杂度与简单的嵌套for循环相同，例如，对于问题中的输入：nlists=3，结果中元素的总数：3*2*2和每个元素都有nlists项目（3在这种情况下）。
— jfs
2
*somelists之前有什么用？它有什么作用？
— Vineet Kumar Doshi 2015年
6
@VineetKumarDoshi：在这里它用于将列表解压缩为函数调用的多个参数。在此处了解更多信息：stackoverflow.com/questions/36901/…–
— Moberg
4
注意：仅当每个列表包含至少一项时，此方法才有效
— igo
84 
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)
>>>
— 杰森·贝克（Jason Baker）
source
38

对于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())
[()]
— f
source
如果其中某些args是迭代器，则递归版本不起作用。
— jfs
20

与itertools.product：

import itertools
result = list(itertools.product(*somelists))
— 寂静幽灵
source
6
*somelists之前有什么用？
— Vineet Kumar Doshi 2015年
@VineetKumarDoshi “ product（somelists）”是子列表之间的笛卡尔乘积，其方式为Python首先获取“ [1、2、3]”作为元素，然后在下一个逗号后获取其他元素，这是换行符，因此是第一个产品项是（[1，2，3]，），与第二个（[4，5]，）类似，因此“ [[[[1，2，3]，），（[4，5]，），（ [6，7]，）]“。如果要在元组内部的元素之间获得笛卡尔乘积，则需要使用Asterisk告诉Python有关元组结构的信息。对于字典，请使用**。这里更多。
— hhh
19

我将使用列表理解： 

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]]
— 用户名
source
1
我真的很喜欢使用列表推导的解决方案。我不知道为什么不更多地投票，它是如此简单。
— llekn
20
@llekn因为代码似乎是固定的，以列表的数目
— 砰力丸
11

这是一个递归生成器，它不存储任何临时列表

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)]
— 阿努拉格Uniyal
source
1
它们存储在堆栈中。
— Quentin Pradet 2015年
@QuentinPradet您的意思是像这样的生成器def f(): while True: yield 1在我们通过它时将继续增加其堆栈大小吗？
— Anurag Uniyal，2015年
@QuentinPradet是的，但是即使在这种情况下，也仅需要最大深度的堆栈，而不是整个列表，因此在这种情况下，堆栈为3
— Anurag Uniyal
是的，很抱歉。基准可能很有趣。:)
— Quentin Pradet 2015年
11

在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)。

根据文档，实际的itertools.product实现不会生成中间结果，这可能会很昂贵。对于中等大小的列表，使用此技术可能会很快失控。
— 三联画
4
我只能将OP指向文档，不能为他阅读。
1
文档中的代码旨在演示产品功能的作用，而不是针对早期版本的Python的解决方法。
— 三联画
9

尽管已经有很多答案，但我还是想分享一些想法：

迭代法

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)
— 唯一
source
在“迭代方法”中，为什么将结果声明为result = [[]]我知道它是list_of_list，但是通常即使我们声明了list_of_list，我们也使用[]而不是[[]]
— Sachin S
就Python解决方案而言，我有点不满意。您或某些路人是否会在单独的循环中以“迭代方式”编写列表理解？
— 约翰尼男孩
4

递归方法：

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)
— i
source
3

对上述递归生成器解决方案进行了些许改动，使其具有多种变化：

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)

有一个权衡：它检查是否递归应当在每个外环突破，以及一个增益：在空呼没有产量，例如product(())，我想，是语义更正确（请参阅文档测试）。

关于列表理解：数学定义适用于任意数量的参数，而列表理解只能处理已知数量的参数。

— 陆Lu
source
2

只是在已经说过的内容上加上一点：如果使用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

关于sympy。

— 泰勒·海尔斯（Tyler Heers）
source
0

巨石阵方法：

def giveAllLists(a, t):
    if (t + 1 == len(a)):
        x = []
        for i in a[t]:
            p = [i]
            x.append(p)
        return x
    x = []

    out = giveAllLists(a, t + 1)
    for i in a[t]:

        for j in range(len(out)):
            p = [i]
            for oz in out[j]:
                p.append(oz)
            x.append(p)
    return x

xx= [[1,2,3],[22,34,'se'],['k']]
print(giveAllLists(xx, 0))

输出：

[[1, 22, 'k'], [1, 34, 'k'], [1, 'se', 'k'], [2, 22, 'k'], [2, 34, 'k'], [2, 'se', 'k'], [3, 22, 'k'], [3, 34, 'k'], [3, 'se', 'k']]
— 新浪网
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.