Ecco come puoi farlo, insieme a spiegazioni e confronti con altri metodi meno efficienti:
Metodo 1:usando `iTertols.product` (consigliato)
Questo è l'approccio più efficiente e pitonico:
`` `Python
Importa Numpy come NP
Dal prodotto import
DEF CARTESIAN_PRODUCT_ITERTOOLS (ARRAYS):
"" "Genera il prodotto cartesiano di più array utilizzando iTertools.Product.
Args:
Array:un elenco di array numpy.
Ritorni:
Un array numpy che rappresenta il prodotto cartesiano. Restituisce nessuno se l'input non è valido.
"" "
se non isinstance (array, elenco):
restituire nessuno
Se non tutto (isinstance (arr, np.ndarray) per arr in array):
restituire nessuno
return np.array (elenco (prodotto (*array))
Array1 =np.Array ([1, 2])
array2 =np.array ([3, 4])
array3 =np.array ([5, 6])
Result =Cartesian_Product_Itertools ([Array1, Array2, Array3])
Stampa (risultato)
`` `
Metodo 2:utilizzando loop nidificati (meno efficiente, evitare per array di grandi dimensioni)
Questo metodo è concettualmente più semplice ma significativamente più lento per gli array di input più grandi:
`` `Python
Importa Numpy come NP
DEF CARTESIAN_PRODUCT_NESTER_LOOPS (Array):
"" "Genera il prodotto cartesiano usando loop nidificati (meno efficiente)." ""
Se non tutto (isinstance (arr, np.ndarray) per arr in array):
restituire nessuno
num_arrays =len (array)
Shapes =[arr.Shape per arr in array]
risultato_shape =(np.prod ([Shape [0] per forma nelle forme]), num_arrays)
risultato =np.zeros (result_shape, dtype =np.int32)
Per io, arr in enumerate (array):
indicer =[slice (nessuno)] * num_arrays
Indexer [i] =slice (nessuno)
# Utilizzo dell'indicizzazione avanzata per generare prodotti cartesiani
arr_repeated =np.tile (arr, (np.prod ([sh [0] per sh in forme [:i] + forme [i + 1:]]), 1))
risultato [:, i] =arr_repeated.reshape (result_shape [0])
risultato di ritorno
risultato =cartesian_product_Nestated_Loops ([Array1, Array2, Array3])
Stampa (risultato)
`` `
perché `iTertols.product` è preferito:
* Efficienza: `iTertools.Product` è altamente ottimizzato per la generazione di prodotti cartesiani. Evita di creare grandi array intermedi, rendendolo molto più efficiente dalla memoria, specialmente quando si tratta di molti o grandi array di input.
* Leggibilità: Il codice che utilizza `iTertools.Product` è più pulito e più facile da capire.
L'approccio ad anello nidificato, pur ilustrando il concetto sottostante, diventa drasticamente più lento e meno efficiente dalla memoria all'aumentare del numero di array di input o delle loro dimensioni. Pertanto, usa sempre `iTertools.product` per generare prodotti cartesiani in Python, specialmente in un contesto numpy. Rinuncia solo a loop nidificati per scopi educativi o esempi molto piccoli e semplici. Ricorda di gestire potenziali errori, come fornire un input non elenco o array non ricchi di dollari, come mostrato nell'esempio con il controllo degli errori.
Programmazione © www.354353.com