Numpy attraverso il metodo

Oggi apprendiamo il metodo Arccos () e il modo in cui implementiamo il metodo Arccos () in Python usando una delle biblioteche importanti di Python che è numpy. Numpy viene utilizzato per calcolare i valori numerici. Implettiamo una delle funzioni trigonometriche inverse che è il metodo Arccos ().

In matematica, la funzione arccos () è l'inverso della funzione cos () e può essere scritta come cos-1. Quando applichiamo la funzione arccos () dell'array numpy, esegue l'elemento per elemento funzione per elemento.

Sintassi:

Ora, discutiamo dello stile di scrittura e dell'implementazione della funzione Arccos () in Numpy Python. Innanzitutto, scriviamo il nome della libreria che utilizziamo in tutto l'articolo che è numpy perché è usato per calcolare i valori numerici. Quindi, concateniamo il nome della funzione in cui utilizziamo la funzione "Arccos ()" con il pacchetto numpy. Quindi, passiamo i parametri per calcolare l'inverso di COS in esso.

Parametri:

X: Array di input su cui implementiamo la funzione Arccos () per ottenere l'output desiderato.

fuori: La forma dell'array che otteniamo in cambio. Ci dice anche in quale posizione il risultato della funzione Arccos () è memorizzato in Python.

Valore di ritorno:

In cambio, otteniamo l'inverso della funzione cos () applicando la funzione arccos ().

Esempio 1:

Iniziamo a scrivere il primo e più semplice esempio di numpy in modo che possa essere facilmente comprensibile per l'utente su ciò che stiamo facendo in questo esempio. Ecco perché dobbiamo prendere il semplice esempio della funzione Arccos (). Innanzitutto, dobbiamo aprire qualsiasi compilatore Python in modo da poter implementare il codice. Qui, utilizziamo il taccuino Jupyter per la compilation e l'esecuzione del nostro codice di programma.

Quindi, installiamo il pacchetto numpy perché implementiamo una delle funzioni importanti di numpy che è arccos (). Dopo l'installazione del pacchetto numpy, importa il pacchetto nel nostro compilatore. Innanzitutto, scriviamo sempre la parola chiave "importazione" che dice al compilatore che stiamo importando il pacchetto. Quindi, scriviamo il nome del pacchetto che utilizziamo nel programma che è "numpy". Quindi, possiamo anche scrivere l'alias pacchetto numpy che è "NP".

Importa Numpy come NP
Print ("Implementazione del semplice esempio di funzione arccos (): \ n")
array = np.Arange (-1, 1)
Stampa ("L'array di input è:", arr)
arccos_array = np.arccos (arr)
print ("\ nthe inverse of COS valori è:", arccos_array)

Dopo aver importato il pacchetto, iniziamo a scrivere la riga di codice effettiva che vogliamo implementare nel programma. Stampiamo il messaggio utilizzando il metodo Print (). È il metodo predefinito, che viene utilizzato per visualizzare i dati che vogliamo visualizzare. Dopo questo, creiamo l'array di input usando una delle funzioni di creazione dell'array, Arange () funzione di Numpy. Quindi, ci passiamo gli argomenti. Quindi, visualizziamo l'array di input chiamando di nuovo il metodo print ().

Dopo la creazione dell'array di input, prendiamo l'inverso della funzione di input. Per questo, prima scriviamo l'alias numpy "np" e poi lo concateniamo con la funzione arccos (). Quindi, passiamo l'argomento che è l'array di input in esso. E poi, visualizziamo l'array chiamando il metodo Print (). Vediamo l'output di questo esempio e controlliamo se otteniamo o meno l'output desiderato:

Come vedi, abbiamo ottenuto l'output desiderato dell'esempio precedentemente spiegato.

Esempio 2:

Iniziamo a implementare il nostro secondo esempio della funzione Arccos (). Per iniziare a scrivere il nostro prossimo esempio, per prima cosa importa la biblioteca che utilizziamo nel nostro programma che è numpy. Qui, usiamo questa libreria solo perché calcoliamo l'inverso di cos. Innanzitutto, scriviamo la parola chiave "importazione" che viene utilizzata per importare le librerie nella programmazione Python. Quindi, scriviamo il nome della libreria che usiamo qui che è "numpy". Possiamo anche scrivere il nome alternativo di Numpy che è "NP" che stiamo usando. L'uso di "NP" invece di scrivere il nome completo della libreria è un buon approccio di programmazione e i programmatori di solito usano questo approccio.

Dopo aver importato il pacchetto, utilizziamo un'istruzione print () per visualizzare il messaggio in modo che l'utente possa facilmente comprendere il codice. Quindi, creiamo l'array usando una delle funzioni di array che è la funzione Linspace () che viene utilizzata per spazzare uniformemente gli elementi dell'array di input. Usiamo prima la "NP" e poi concateniamo la funzione Linspace () con essa e ci passiamo gli argomenti in essa. Il primo argomento è "0" che è il valore iniziale. Il valore finale è "pi" che scriviamo chiamando la funzione pi () di numpy. Quindi, "10" è il numero di elementi nell'array. Archiviamo tutta questa funzione in un altro array chiamato "array", quindi non dobbiamo scrivere di nuovo questa funzione nel programma.

Quindi, chiamiamo un'altra funzione di numpy che è la funzione cos (). Qui, calcoliamo il COS dell'array di input. Innanzitutto, scriviamo il "NP". Quindi, chiamiamo la funzione cos () e passiamo l'array di input, quindi lo memorizziamo in un altro array chiamato "cos_arr". Quindi, chiamiamo la funzione effettiva che vogliamo implementare che è la funzione Arccos (). Innanzitutto, scriviamo la funzione "np" e concateniamo la funzione arccos () e passiamo l'array di input in essa. Archiviamo questa funzione in un altro array chiamato "arcos_arr".

Importa Numpy come NP
Print ("Implementation of Arccos Method in Numpy Python: \ n")
array = np.Linspace (-3, 3, 10)
Stampa ("L'array di input è: \ n", array)
cos_arr = np.cos (array)
print ("\ nthe COS Array è: \ n", cos_arr)
arccos_arr = np.arccos (array)
print ("\ nthe arccos array è: \ n", arccos_arr, "\ n")

Dopo aver chiamato questa funzione precedente, otteniamo il seguente output:

Ora, dobbiamo tracciare questi array risultanti in un grafico usando un altro pacchetto di programmazione Python che è "Matplotlib". Viene utilizzato per visualizzare il grafico visivo. Innanzitutto, scriviamo la parola chiave "importazione". Quindi, scriviamo il nome del pacchetto "Matplotlib" e lo concateniamo con "Pyplot" che è il modulo di "Matplotlib" che significa "Python Trama". Quindi, scriviamo l'alias "PLT".

Importa matplotlib.Pyplot come Plt
Plt.Plot (array, cos_arr, color = "black", marker = "*")
Plt.Plot (array, arccos_arr, color = "giallo", marker = "o")
Plt.Titolo ("Black: Numpy.cos () \ n giallo: numpy.arccos () ")
Plt.XLabel ("X-Axis")
Plt.Ylabel ("Asse Y")
Plt.spettacolo()

Quindi, chiamiamo la funzione trama () con l'alias "PLT" e passiamo i parametri in esso che sono l'array di input, cos_arr e il colore e il marcatore dell'asse x. Quindi, chiamiamo di nuovo la funzione trama () per l'asse y. Quindi, scriviamo il titolo del grafico, dell'asse X e dell'asse Y e mostriamo il grafico usando le diverse funzioni di Matplotlib.

Ecco la rappresentazione visiva della funzione Arccos () usando il pacchetto Matplotlib:

Conclusione

In questo articolo, abbiamo appreso la funzione Arccos () e come implementare questa funzione in Python. Abbiamo imparato un'altra libreria di Python che è il pacchetto matplotlib per tracciare il grafico. Abbiamo anche implementato più esempi della funzione Arccos () con una spiegazione dettagliata di ogni riga di codice.