Así es como puede hacerlo, junto con explicaciones y comparaciones con otros métodos menos eficientes:
Método 1:Uso de `ITerTools.Product` (recomendado)
Este es el enfoque más eficiente y pitónico:
`` `Python
importar numpy como np
del producto de importación de IterTools
def Cartesian_Product_iterTools (matrices):
"" "Genera el producto cartesiano de múltiples matrices usando ITerTools.Product.
Args:
Matrices:una lista de matrices numpy.
Devoluciones:
Una matriz numpy que representa el producto cartesiano. No devuelve ninguno si la entrada no es válida.
"" "
Si no es ISInstance (matrices, lista):
no devuelve ninguno
Si no todos (isinstance (arr, np.ndarray) para arr en las matrices):
no devuelve ninguno
devolver np.array (lista (producto (*matrices)))
Uso de ejemplo:
array1 =np.array ([1, 2])
array2 =np.array ([3, 4])
array3 =np.array ([5, 6])
resultado =Cartesian_Product_iterTools ([Array1, Array2, Array3])
Imprimir (resultado)
Salida:[[1 3 5]
[1 3 6]
[1 4 5]
[1 4 6]
[2 3 5]
[2 3 6]
[2 4 5]
[2 4 6]]
`` `` ``
Método 2:Uso de bucles anidados (menos eficientes, evite para matrices grandes)
Este método es conceptualmente más simple pero significativamente más lento para matrices de entrada más grandes:
`` `Python
importar numpy como np
Def Cartesian_Product_Nested_Loops (matrices):
"" "Genera el producto cartesiano utilizando bucles anidados (menos eficientes)." "
Si no todos (isinstance (arr, np.ndarray) para arr en las matrices):
no devuelve ninguno
num_arrays =len (matrices)
formas =[arr.shape para arr en matrices]
result_shape =(np.prod ([forma [0] para la forma en formas]), num_arrays)
resultado =np.zeros (result_shape, dtype =np.int32)
Para i, arr en enumerado (matrices):
indexer =[slice (none)] * num_arrays
indexer [i] =slice (ninguno)
# Uso de la indexación avanzada para generar productos cartesianos
arr_repeated =np.tile (arr, (np.prod ([sh [0] para sh en formas [:i] + formas [i + 1:]]), 1)))
resultado [:, i] =arr_repeated.reshape (result_shape [0])
Resultado de retorno
resultado =Cartesian_Product_Nested_Loops ([Array1, Array2, Array3])
Imprimir (resultado)
`` `` ``
Por qué se prefiere `ITerTools.Product`:
* Eficiencia: `ITerTools.Product` está altamente optimizado para generar productos cartesianos. Evita crear grandes matrices intermedias, lo que lo hace mucho más eficiente en la memoria, especialmente cuando se trata de muchas o grandes matrices de entrada.
* Legabilidad: El código que usa `ITerTools.Product` es más limpio y más fácil de entender.
El enfoque de bucle anidado, aunque ilustra el concepto subyacente, se vuelve drásticamente más lento y menos eficiente en la memoria a medida que aumenta el número de matrices de entrada o sus tamaños. Por lo tanto, siempre use `ITerTools.Product` para generar productos cartesianos en Python, especialmente dentro de un contexto numpy. Solo recurren a bucles anidados para fines educativos o ejemplos muy pequeños y simples. Recuerde manejar posibles errores, como proporcionar una entrada no de la lista o matrices no nocturnas, como se muestra en el ejemplo con verificación de errores.