Obtenir le produit cartésien d'une série de listes en Python

Question

Comment puis-je obtenir le produit cartésien (toutes les combinaisons possibles de valeurs) d'un groupe de listes ?

Entrée :

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

Sortie souhaitée :

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

Answer 1

En Python 2.6 et plus

import itertools
for element in itertools.product(*somelists):
    print element

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

Answer 3

Pour Python 2.5 et plus :

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

Voici une version récursive de product() (juste une illustration) :

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

Exemple :

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

Answer 4

avec itertools.product :

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

Answer 5

Dans Python 2.6 et plus, vous pouvez utiliser 'itertools.product`. Dans les versions plus anciennes de Python, vous pouvez utiliser l'équivalent suivant (presque -- voir la documentation) code de la documentation :

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)

Le résultat des deux est un itérateur, donc si vous avez vraiment besoin d'une liste pour un traitement ultérieur, utilisez list(result) .