Numpy har inte en inbyggd funktion för att direkt beräkna den kartesiska produkten. Funktionen "IterteOls.Product" från Pythons standardbibliotek är i allmänhet det mest effektiva sättet att uppnå detta, särskilt för större matriser. Du kan emellertid sedan konvertera resultatet till en numpy matris om det behövs.
Så här kan du göra det, tillsammans med förklaringar och jämförelser med andra mindre effektiva metoder:
Metod 1:Använda `itertools.product '(rekommenderas)
Detta är den mest effektiva och pythoniska metoden:
`` `python
Importera numpy som NP
Från Itertools importprodukt
def cartesian_product_iterTools (matriser):
"" "Genererar den kartesiska produkten från flera matriser med Iterertools.Product.
Args:
Matriser:En lista över numpy matriser.
Returnerar:
En numpy matris som representerar den kartesiska produkten. Returnerar ingen om ingången är ogiltig.
"" "
om inte isinstance (matriser, lista):
returnera ingen
om inte alla (iSinstance (arr, np.ndarray) för arr i matriser):
returnera ingen
returnera np.array (lista (produkt (*matriser))))
Exempel Användning:
array1 =np.array ([1, 2])
array2 =np.array ([3, 4])
array3 =np.array ([5, 6])
resultat =cartesian_product_iterTools ([array1, array2, array3])
Skriv ut (resultat)
Utgång:[[1 3 5]
[1 3 6]
[1 4 5]
[1 4 6]
[2 3 5]
[2 3 6]
[2 4 5]
[2 4 6]]
`` `
Metod 2:Använd kapslade slingor (mindre effektiv, undvik för stora matriser)
Denna metod är konceptuellt enklare men betydligt långsammare för större ingångsuppsättningar:
`` `python
Importera numpy som NP
def cartesian_product_nested_loops (matriser):
"" "Genererar den kartesiska produkten med kapslade slingor (mindre effektiv)." "" "
om inte alla (iSinstance (arr, np.ndarray) för arr i matriser):
returnera ingen
num_arrays =len (matriser)
Former =[ARR.Shape för ARR in Arrays]
result_shape =(np.prod ([form [0] för form i former]), num_arrays)
resultat =np.zeros (result_shape, dtype =np.int32)
För i, arr i uppräkning (matriser):
indexer =[skiva (ingen)] * num_arrays
Indexer [i] =skiva (ingen)
# Använda avancerad indexering för att generera kartesisk produkt
arr_repeated =np.tile (arr, (np.prod ([sh [0] för sh i former [:i] + former [i + 1:]]), 1))
Resultat [:, i] =arr_repeated.FRESHAPE (result_shape [0])
avkastningsresultat
resultat =cartesian_product_nested_loops ([array1, array2, array3])
Skriv ut (resultat)
`` `
Varför `itertools.product` föredras:
* Effektivitet: `itertools.product 'är mycket optimerad för att generera kartesiska produkter. Det undviker att skapa stora mellanliggande matriser, vilket gör det mycket mer minneseffektivt, särskilt när man hanterar många eller stora inmatningsuppsättningar.
* läsbarhet: Koden som använder `itertools.product 'är renare och lättare att förstå.
Den kapslade slingmetoden, samtidigt som den underliggande konceptet illustrerar, blir drastiskt långsammare och mindre minneseffektivt när antalet ingångsuppsättningar eller deras storlekar ökar. Därför använder alltid `itertools.product` för att generera kartesiska produkter i Python, särskilt inom ett numpy -sammanhang. Endast tillgripa kapslade slingor för utbildningsändamål eller mycket små, enkla exempel. Kom ihåg att hantera potentiella fel, som att tillhandahålla en inmatning eller icke-numpy matriser, som visas i exemplet med felkontroll.
