Cómo obtener el producto cartesiano de múltiples listas

Question 1

¿Cómo puedo obtener el producto cartesiano (todas las combinaciones posibles de valores) de un grupo de listas?

Por ejemplo, dado

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

¿Cómo consigo esto?

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

_{Una aplicación común de esta técnica es evitar bucles profundamente anidados. Consulte Evitar bucles for anidados para obtener un duplicado más específico. De manera similar, esta técnica podría usarse para “explotar” un diccionario con valores de lista; consulte Combinar permutaciones de diccionarios de Python en una lista de diccionarios.}

_{Si desea un producto cartesiano de lo mismo lista consigo mismo varias veces, itertools.product puede manejar eso con elegancia. Ver Operación en cada par de elementos en una lista o ¿Cómo puedo obtener “permutaciones con repeticiones” de una lista (producto cartesiano de una lista consigo misma)?.}

_{Muchas personas que ya conocen itertools.product lucha con el hecho de que espera argumentos separados para cada secuencia de entrada, en lugar de, por ejemplo, una lista de listas. La respuesta aceptada muestra cómo manejar esto con *. Sin embargo, el uso de * aquí para desempaquetar argumentos es fundamentalmente no diferente desde cualquier otro momento en que se use en una llamada de función. Consulte Expansión de tuplas en argumentos para este tema (y utilícelo en su lugar para cerrar preguntas duplicadas, según corresponda).}

Question 2

Usar itertools.productque ha estado disponible desde Python 2.6.

import itertools

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

Esto es lo mismo que:

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

Para Python 2.5 y anteriores:

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

Aquí hay una versión recursiva de product() (solo una ilustración):

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

Ejemplo:

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

Yo usaría la lista de comprensión:

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

con itertools.producto:

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

Question 7

Aquí hay un generador recursivo, que no almacena ninguna lista temporal.

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

Producción:

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

En Python 2.6 y superior, puede usar ‘itertools.product`. En versiones anteriores de Python, puede usar el siguiente equivalente (casi, consulte la documentación) código de la documentaciónal menos como punto de partida:

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)

El resultado de ambos es un iterador, por lo que si realmente necesita una lista para un procesamiento posterior, use list(result).

¿Ha sido útil esta solución?