Metodo Numpy Prod

Oggi impareremo quale sia la funzione Prod () in Numpy. Perché usiamo questa funzione? Apprezzeremo anche gli esempi con spiegazioni dettagliate.

La funzione Prod () è una delle funzioni importanti di Numpy (Python numerico). Il "Prod" indica il prodotto che viene utilizzato per trovare il prodotto dell'array in numpy. Il valore dell'asse è "nessuno" per impostazione predefinita, quindi il risultato è mostrato in un determinato array.

Sintassi:

Ora, passiamo al metodo di scrittura della funzione Numpy Prod ():

Qui, "NP" sta per Numpy e "Prod" mostra che chiamiamo la funzione del prodotto di Numpy per eseguire la moltiplicazione sull'array.

Parametro:

Di seguito sono riportati i parametri richiesti e opzionali della funzione Numpy Prod ():

Parametro richiesto:

UN: L'array di input. Quel array su cui vogliamo eseguire la funzione Prod ().

Parametri opzionali:

asse: Potrebbe essere un int, un'istanza di int o nessuna. Questa opzione definisce su quali assi il prodotto dovrebbe essere eseguito.

dtype: Ci dice quale tipo di dati otteniamo dopo il prodotto di un array.

fuori: Dice il percorso alternativo in cui i dati vengono archiviati dopo il prodotto dell'array.

Keepdims: Se è vero, gli assi ridotti sono ancora presenti nell'uscita come dimensioni della dimensione 1.

Valore di ritorno:

La funzione Numpy Prod () restituisce gli array uguali all'array di input su un determinato asse. Se inseriamo l'array vuoto/null, la funzione Prod () restituisce il valore 1.

Esempio 1: Implementazione della funzione Prod ()

Abbiamo discusso della parte teorica della funzione Prod (). Ora, passiamo all'implementazione della funzione Prod () attraverso diversi esempi e spiegazioni di ogni singola riga di codice. Per l'implementazione dell'esempio numpy, abbiamo prima bisogno di un compilatore Python per scrivere ed eseguire il nostro programma. Perché il compilatore Python per Numpy? Perché Numpy è la biblioteca avanzata di Python, ecco perché usiamo il compilatore Python.

Array midimensionale:

Iniziamo il nostro primo semplice esempio della funzione Prod (). Per iniziare a implementare il codice, dobbiamo prima importare la nostra libreria Numpy come alias NP. Quindi, stampiamo il messaggio "Qui, implementeremo la funzione Prod () su Array 1D" per l'utente per capire cosa stiamo per fare. Come puoi vedere nella riga 3, usiamo il "\ n" dopo aver scritto il messaggio. Questo perché vogliamo aggiungere la nuova riga nel codice in modo che l'output sia in forma gestibile.

Quindi, creiamo un array midimensionale "[5, 0]" chiamato "Array". E poi, visualizziamo l'array con il messaggio "L'array 1-dimensionale è:" usando il metodo print (). Quindi, passiamo l'array alla funzione Prod () in modo che gli elementi dell'array siano moltiplicati. Archiviamo la funzione prod () in un altro array chiamato "new_array". Il motivo alla base della memorizzazione della funzione Prod () in un altro array è che se vogliamo chiamare la funzione Prod (), non dobbiamo scrivere l'intera funzione ancora e ancora. Chiamiamo solo "New_array" e abbiamo quella funzione. Quindi, visualizziamo il metodo new_array utilizzando il metodo print ().

Importa Numpy come NP
Print ("Qui, implementeremo la funzione Prod () su Array 1D: \ n")
array = [5, 0]
Stampa ("L'array 1 è:", Array)
new_array = np.Prod (Array)
print ("L'array di ritorno è:", new_array)

Diamo un'occhiata all'uscita che è stata mostrata nella shell seguente. Come puoi vedere, abbiamo restituito il valore "0" perché moltiplicarci 5 per 0 ci dà 0.

Array bidimensionale:

Qui, implementeremo un semplice esempio di array 2D. Questa istanza è simile all'esempio precedente. L'unica differenza è che questo è un array 2D. Qui, implementiamo la funzione Prod () su un array 2D.

Importa Numpy come NP
Print ("Qui, implementeremo la funzione Prod () su Array 2D: \ n")
array = [[5, 1], [10, 1]]
Stampa ("L'array bidimensionale è:", Array)
new_array = np.Prod (Array)
print ("L'array di ritorno è:", new_array)

Ecco l'output dell'array 2D che è stato visualizzato nella seguente shell. Dopo aver applicato la funzione Prod () all'array ”[[5, 1], [10, 1]]”, ne otteniamo 50.

Facciamo una corsa asciutta di questo esempio in modo che non venga lasciato nessun punto di confusione per l'utente:

Esempio 2: array vuoto

Ora, abbiamo un altro esempio della funzione Prod () in cui implementiamo un array vuoto. La libreria Numpy deve prima essere importata come NP. Quindi, creiamo un array vuoto "[]" chiamato "Array". Quindi, passiamo questo array vuoto alla funzione Prod () e lo memorizziamo in un altro array che è stato chiamato "New_array". Quindi, chiamiamo il metodo Print () e stampiamo l'array.

Importa Numpy come NP
Print ("Qui, implementeremo la funzione Prod () su Array vuoto: \ N")
array = []
Stampa ("L'array vuoto è:", array)
new_array = np.Prod (Array)
print ("L'array di ritorno è:", new_array)

Vediamo l'output dell'illustrazione precedente che è stato mostrato nella shell. Come puoi vedere nella seguente uscita, otteniamo 1.0 in cambio. Questo perché quando vogliamo il prodotto di un array vuoto, otteniamo sempre l'output come elemento neutro 1.

Esempio 3: prodotto dell'array 2D quando asse = 1

Facciamo un altro esempio della funzione Prod () che sta dando un asse all'array di input. Innanzitutto, dobbiamo importare la biblioteca di Python che è numpy come alias NP. Quindi, creiamo un array "[8, 7], [4, 5]]" chiamato "Array". Dopo aver creato l'array, stampiamo l'array di input utilizzando l'istruzione print (). Quindi, passiamo l'array alla funzione Prod () per trovare il prodotto dell'array di input fornendo l'asse = 1 e lo archivialo in un altro array chiamato "new_array". Quindi, stampiamo il nuovo array chiamando il metodo Print ().

Importa Numpy come NP
Print ("Qui, implementeremo la funzione Prod () su Array 2D: \ n")
Array = [[8,7], [4,5]]
Stampa ("L'array 2D è con l'asse 1:", array)
new_array = np.Prod (Array, Axis = 1)
print ("L'array di ritorno è:", new_array)

Vediamo l'output dell'illustrazione precedente nella shell. Nel prodotto dell'input, otteniamo [56 20] con asse = 1.

Ora, facciamo la corsa a secco dell'esempio precedentemente spiegato su come otteniamo il prodotto dell'array di input quando forniamo l'asse = 1.

Quando Asse = 0:

Ora, implementiamo lo stesso esempio come abbiamo fatto nell'esempio precedente perché mostreremo all'utente la differenza quando diamo gli assi diversi.

Importa Numpy come NP
Print ("Qui, implementeremo la funzione Prod () su Array 2D: \ n")
Array = [[8,7], [4,5]]
Stampa ("L'array 2D è con l'asse 0:", array)
new_array = np.Prod (Array, Axis = 0)
print ("L'array di ritorno è:", new_array)

Ecco l'output dell'esempio precedente. Come puoi vedere, ora otteniamo un output diverso che è [32 35].

Ecco la corsa a secco quando diamo l'asse = 0 all'esempio precedente. Ora, capirai la differenza quando diamo le diverse assi.

Conclusione

L'implementazione della funzione Prod () è stata trattata in questo articolo. Per comprendere chiaramente la funzione Prod (), implementiamo i diversi esempi con spiegazioni dettagliate. Diamo anche i diversi assi alla funzione Prod (). Spero che questo tutorial sarà utile nella tua fase di apprendimento.