Lấy sản phẩm cartesian của một loạt các danh sách?

Làm cách nào tôi có thể nhận được sản phẩm của Cartesian (mọi sự kết hợp có thể của các giá trị) từ một nhóm danh sách?

Đầu vào:

somelists = [
   [1, 2, 3],
   ['a', 'b'],
   [4, 5]
]

Sản phẩm chất lượng:

[(1, 'a', 4), (1, 'a', 5), (1, 'b', 4), (1, 'b', 5), (2, 'a', 4), (2, 'a', 5) ...]

itertools.product

Có sẵn từ Python 2.6.

import itertools

somelists = [
   [1, 2, 3],
   ['a', 'b'],
   [4, 5]
]
for element in itertools.product(*somelists):
    print(element)

Giống như,

for element in itertools.product([1, 2, 3], ['a', 'b'], [4, 5]):
    print(element)

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

Đối với Python 2.5 trở lên:

>>> [(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)]

Đây là phiên bản đệ quy của product()(chỉ là một minh họa):

def product(*args):
    if not args:
        return iter(((),)) # yield tuple()
    return (items + (item,) 
            for items in product(*args[:-1]) for item in args[-1])

Thí dụ:

>>> 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())
[()]

với itertools.product :

import itertools
result = list(itertools.product(*somelists))

Tôi sẽ sử dụng danh sách hiểu:

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]]

Đây là một trình tạo đệ quy, không lưu trữ bất kỳ danh sách tạm thời nào

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]]))

Đầu ra:

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

Trong Python 2.6 trở lên, bạn có thể sử dụng 'itertools.product`. Trong các phiên bản cũ hơn của Python, bạn có thể sử dụng mã tương đương (gần như - xem tài liệu) sau đây từ tài liệu , ít nhất là điểm bắt đầu:

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)

Kết quả của cả hai là một trình vòng lặp, vì vậy nếu bạn thực sự cần một danh sách để xử lý thêm, hãy sử dụng list(result).

Mặc dù đã có nhiều câu trả lời, tôi muốn chia sẻ một vài suy nghĩ của mình:

Phương pháp lặp

def cartesian_iterative(pools):
  result = [[]]
  for pool in pools:
    result = [x+[y] for x in result for y in pool]
  return result

Phương pháp đệ quy

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]

Phương pháp tiếp cận Lambda

def cartesian_reduct(pools):
  return reduce(lambda x,y: product(x,y) , pools)

Phương pháp đệ quy:

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)

Phương pháp lặp lại:

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)

Một sửa đổi nhỏ cho giải pháp máy phát đệ quy ở trên trong hương vị dao động:

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

Và dĩ nhiên, một trình bao bọc làm cho nó hoạt động giống hệt như giải pháp đó:

def product2(ar_list):
    """
    >>> list(product(()))
    [()]
    >>> list(product2(()))
    []
    """
    return product_args(*ar_list)

với một sự đánh đổi : nó kiểm tra xem đệ quy có nên phá vỡ mỗi vòng lặp bên ngoài hay không, và một lợi ích : không mang lại kết quả cho cuộc gọi trống, ví dụ product(()), mà tôi cho rằng sẽ đúng hơn về mặt ngữ nghĩa (xem tài liệu).

Về hiểu biết danh sách: định nghĩa toán học áp dụng cho một số lượng đối số tùy ý, trong khi hiểu danh sách chỉ có thể xử lý một số lượng đã biết.

Chỉ cần thêm một chút vào những gì đã được nói: nếu bạn sử dụng sympy, bạn có thể sử dụng các ký hiệu thay vì các chuỗi làm cho chúng có ích về mặt toán học.

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

Về sympy .

Tôi tin rằng điều này hoạt động:

def cartesian_product(L):  
   if L:
       return {(a,) + b for a in L[0] 
                        for b in cartesian_product(L[1:])}
   else:
       return {()}

Cách tiếp cận Stonehenge:

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

đầu ra:

[[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']]