1. Definición formal

Dados dos conjuntos A = {a₁,…,aₙ} y B = {b₁,…,bₘ}, el producto cartesiano es el conjunto de pares ordenados:

A × B = {(aᵢ, bⱼ) | 1 ≤ i ≤ n, 1 ≤ j ≤ m}

Para k conjuntos el resultado tiene n₁·n₂·…·nₖ combinaciones, lo que implica un crecimiento exponencial.

2. Algoritmo paso a paso

1. Iterar sobre el primer conjunto.
2. Para cada elemento del primer conjunto, iterar sobre el segundo.
3. Construir una tupla (o lista) con la combinación actual.
4. Repetir recursivamente si existen más de dos conjuntos.

Este proceso se puede expresar de forma iterativa o recursiva; Python ofrece utilidades que lo simplifican.

3. Implementaciones en Python

3.1 Usando itertools.product (recomendado)

import itertools
# Ejemplo básico con dos listas
a = [1, 2]
b = ['a', 'b', 'c']
resultado = list(itertools.product(a, b))
print(resultado)
# [(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c')]

3.2 List comprehension (para pocos elementos)

a = [1, 2]
b = ['x', 'y']
resultado = [(x, y) for x in a for y in b]
print(resultado)
# [(1, 'x'), (1, 'y'), (2, 'x'), (2, 'y')]

3.3 Implementación manual con bucles anidados (educativo)

def cartesian_manual(*sets):
    if not sets:
        return []
    result = [[]]
    for current in sets:
        temp = []
        for prefix in result:
            for item in current:
                temp.append(prefix + [item])
        result = temp
    return [tuple(r) for r in result]
print(cartesian_manual([1, 2], ['a', 'b'], [True, False]))
# [(1, 'a', True), (1, 'a', False), (1, 'b', True), ...]

4. Comparativa de métodos (máximo dos columnas)

5. Casos de uso reales

• Generación de datos de prueba: crear todas las combinaciones de parámetros para pruebas automatizadas.
• Machine Learning: combinar hiperparámetros en búsqueda de cuadrícula (grid search).
• SQL & Data Warehousing: CROSS JOIN equivale a producto cartesiano; útil para crear tablas de referencia.
• Bioinformática: combinar bases de nucleótidos para generar todas las secuencias posibles.
• Combinatoria de UI/UX: generar todas las combinaciones de colores, fuentes y tamaños.

6. Rendimiento y escalabilidad

El número total de combinaciones crece como ∏ nᵢ. Para conjuntos grandes, es vital:

• Usar itertools.product como generador para procesar "en streaming".
• Aplicar filtrado temprano (p.ej., if dentro de la comprensión) para reducir el espacio.
• Dividir la tarea en chunks y procesarlos en paralelo con multiprocessing o concurrent.futures.

Ejemplo de paralelismo con ProcessPoolExecutor

import itertools, concurrent.futures
def consumer(chunk):
    # Simular procesamiento costoso
    return [sum(pair) for pair in chunk]
A = range(1000)
B = range(1000)
product_iter = itertools.product(A, B)
# Agrupar en bloques de 10 000 pares
chunks = itertools.islice(product_iter, 0, None, 10000)
with concurrent.futures.ProcessPoolExecutor() as pool:
    results = list(pool.map(consumer, chunks))
print('Processed', len(results), 'chunks')

7. Buenas prácticas y troubleshooting

• Never materialize the whole product unless you really need it. MemoryError es el síntoma típico.
• Si necesitas solo una parte, usa itertools.islice o more_itertools.chunked para paginar.
• Comprueba la longitud esperada con math.prod(len(s) for s in iterables) antes de ejecutar.
• En entornos con Docker o Podman, asigna límites de memoria (--memory) para evitar que el proceso agote recursos.
• Para datos sensibles, evita generar combinaciones que puedan revelar información confidencial (ej. combinaciones de contraseñas).

8. Compatibilidad y versiones de Python

Las funciones mostradas son compatibles con Python 3.7+. itertools.product no ha cambiado desde Python 2.3, por lo que el código funciona también en 2.7, aunque se recomienda migrar a 3.x por mejoras de rendimiento y tipado.