So erhalten Sie das kartesische Produkt mehrerer Listen

Question 1

Wie bekomme ich das kartesische Produkt (jede mögliche Kombination von Werten) aus einer Gruppe von Listen?

Zum Beispiel gegeben

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

Wie bekomme ich das?

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

_{Eine häufige Anwendung für diese Technik besteht darin, tief verschachtelte Schleifen zu vermeiden. Siehe Vermeidung von verschachtelten for-Schleifen für ein spezifischeres Duplikat.}

_{Wenn Sie ein kartesisches Produkt von wollen das gleiche Liste mehrfach mit sich selbst, itertools.product kann damit elegant umgehen. Siehe Operation für jedes Paar von Elementen in einer Liste oder Permutationen mit Wiederholungen generieren.}

_{Viele Leute, die es bereits wissen itertools.product hat damit zu kämpfen, dass es für jede Eingabesequenz separate Argumente erwartet und nicht zB eine Liste von Listen. Die akzeptierte Antwort zeigt, wie damit umzugehen ist *. Allerdings ist die Verwendung von * Hier zum Auspacken von Argumenten grundsätzlich nicht anders von jeder anderen Zeit wird es in einem Funktionsaufruf verwendet. Siehe Erweitern von Tupeln in Argumente für dieses Thema (und verwenden Sie das stattdessen, um doppelte Fragen zu schließen, falls erforderlich).}

Question 2

Verwenden itertools.productdas seit Python 2.6 verfügbar ist.

import itertools

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

Dies ist dasselbe wie:

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

Question 3

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

Question 4

Für Python 2.5 und älter:

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

Hier ist eine rekursive Version von product() (nur eine Veranschaulichung):

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

Beispiel:

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

Question 5

Ich würde das Listenverständnis verwenden:

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

Question 6

mit itertools.product:

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

Question 7

Hier ist ein rekursiver Generator, der keine temporären Listen speichert

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

Ausgang:

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

Question 8

In Python 2.6 und höher können Sie ‘itertools.product’ verwenden. In älteren Versionen von Python können Sie das folgende (fast — siehe Dokumentation) Äquivalent verwenden Code aus der Dokumentationzumindest als Ausgangspunkt:

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)

Das Ergebnis von beiden ist ein Iterator, wenn Sie also wirklich eine Liste zur weiteren Verarbeitung benötigen, verwenden Sie list(result).