Python Scipy Tutorial

In questa lezione, vedremo a cosa serve la biblioteca Scipy in Python e come ci aiuta a lavorare con equazioni matematiche e algoritmi in modo interattivo. La cosa buona del pacchetto Scipy Python è che se vogliamo classi o costruiscono pagine Web, Scipy è completamente compatibile con il sistema nel suo insieme e può fornire un'integrazione senza soluzione di continuità.

COME Scipy è open source, Ha una comunità molto attiva e vibrante di sviluppatori a causa della quale vi è un numero enorme di moduli presenti per una grande quantità di applicazioni scientifiche e calcoli disponibili con Scipy. Alcune delle complesse operazioni matematiche che possono essere eseguite con Scipy sono:

• Interpolazione
• Integrazione
• Ottimizzazione
• Elaborazione delle immagini
• Statistiche
• Calcoli di funzioni speciali ecc.

Scipy può essere confrontato con la maggior parte delle librerie di comando e standard come la libreria GSL per C ++ e MATLAB. Poiché Scipy è costruito sul pacchetto numpy, anche questi due pacchetti possono essere integrati completamente. Se riesci a pensare a un'operazione matematica che deve essere eseguita, assicurati di controllare la libreria di Scipy prima di implementare quel modulo da solo perché nella maggior parte dei casi, Scipy ha tutte le operazioni per te già implementate completamente implementate.

Installa la libreria Scipy

Installiamo la libreria Scipy prima di passare agli esempi e ai concetti reali. Esistono due modi per installare questo pacchetto. Il primo include l'utilizzo del Python Package Manager, PIP:

PIP Installa Scipy

Il secondo modo riguarda Anaconda, possiamo installare il pacchetto come:

Conda Install -c Anaconda Scipy

Una volta installata la libreria, possiamo importarla come:

Import Scipy

Infine, poiché useremo anche Numpy (si consiglia che per tutte le operazioni numpy usiamo direttamente numpy invece di passare attraverso il pacchetto Scipy):

importa numpy

È possibile che in alcuni casi ci piacerebbe anche tracciare i nostri risultati per i quali useremo la libreria Matplotlib. Eseguire la seguente importazione per quella libreria:

Importa matplotlib

Userò il gestore Anaconda per tutti gli esempi in questa lezione. Lancerò un taccuino jupyter per lo stesso:

Ora che siamo pronti con tutte le dichiarazioni di importazione per scrivere un po 'di codice, iniziamo a immergerci nel pacchetto Scipy con alcuni esempi pratici.

Lavorare con equazioni polinomiali

Inizieremo guardando semplici equazioni polinomiali. Esistono due modi in cui possiamo integrare le funzioni polinomiali nel nostro programma. Possiamo usare poli1d Classe che utilizza coefficienti o le radici di un polinomio per l'inizializzazione di un polinomio. Diamo un'occhiata a un esempio:

da numpy import poly1d
first_polynomial = poli1d ([3, 4, 7])
Stampa (First_Polynomiale)

Quando eseguiamo questo esempio, vedremo il seguente output:

Chiaramente, la rappresentazione polinomiale dell'equazione è stampata come output in modo che il risultato sia abbastanza facile da capire. Possiamo eseguire varie operazioni anche su questo polinomio, come Square It, trovarla o addirittura risolverlo per un valore di x. Proviamo a fare tutto questo nel prossimo esempio:

print ("Polinomiale quadrato: \ n")
Stampa (First_Polynomial * First_Polynomial)
Print ("Derivative of Polinomio: \ n")
Stampa (First_Polynomiale.deriv ())
print ("Risoluzione del polinomio: \ n")
Stampa (First_Polynomial (3))

Quando eseguiamo questo esempio, vedremo il seguente output:

Proprio quando pensavo che questo è tutto ciò che potevamo fare con Scipy, mi sono ricordato che possiamo anche integrare un polinomio. Eseguiamo un ultimo esempio con i polinomi:

print ("Integrazione del polinomio: \ n")
Stampa (First_Polynomiale.Integ (1))

Il numero intero che passiamo dice al pacchetto quante volte integrare il polinomio:

Possiamo semplicemente passare un altro numero intero che dice al pacchetto quante volte integrare questo polinomio.

Risolvere equazioni lineari

È anche possibile risolvere equazioni lineari con Scipy e trovare le loro radici, se esistono. Per risolvere equazioni lineari, rappresentiamo l'insieme di equazioni come array numpy e la loro soluzione come array numpy separati. Visualizziamolo con un esempio in cui facciamo lo stesso e facciamo uso linalg Pacchetto per trovare le radici delle equazioni, ecco le equazioni che risolveremo:

1x + 5y = 6
3x + 7y = 9

Risolviamo le equazioni di cui sopra:

da Scipy Import Linalg
equazione = np.array ([[1, 5], [3, 7]])
soluzione = np.array ([[6], [9]])
radici = linalg.risolvere (equazione, soluzione)
Stampa ("Trovato le radici:")
Stampa (radici)
Print ("\ n Dot Product dovrebbe essere zero se le soluzioni sono corrette:")
Stampa (equazione.punto (radici) - soluzione)

Quando eseguiamo il programma di cui sopra, vedremo che l'equazione del prodotto DOT fornisce un risultato zero, il che significa che le radici che hanno trovato il programma erano corrette:

Trasformazioni di Fourier con Scipy

Le trasformazioni di Fourier ci aiutano a esprimere una funzione come componenti separati che compongono quella funzione e ci guida sul modo in cui possiamo ricombinare quei componenti per recuperare la funzione originale.

Diamo un'occhiata a un semplice esempio di trasformazioni di Fourier in cui tracciamo la somma di due cosini usando la libreria Matplotlib:

da Scipy.FFTPACK Import FFT
# Numero di punti campione
N = 500
# Spaziatura di esempio
T = 1.0 /800.0
x = np.Linspace (0.0, n*t, n)
y = np.cos (50.0 * 2.0* np.pi * x) + 0.5 * np.cos (80.0 * 2.0 * np.pi * x)
yf = fft (y)
xf = np.Linspace (0.0, 1.0/(2.0 * t), n // 2)
# matplotlib per scopi di trama
Importa matplotlib.Pyplot come Plt
Plt.Trama (XF, 2.0/n * np.ABS (yf [0: n // 2]))
Plt.Titolo ('Info')
Plt.Ylabel ('Y asse')
Plt.XLabel ('X Axis')
Plt.griglia()
Plt.spettacolo()

Qui, abbiamo iniziato costruendo uno spazio campione e l'equazione del coseno che poi abbiamo trasformato e tracciato. Ecco l'output del programma sopra:

Questo è un buon esempio in cui vediamo Scipy essere usato in una complessa equazione matematica per visualizzare facilmente le cose.

Vettori e matrice con Scipy

Ora che sappiamo molte cose di cui Scipy è capace, possiamo essere sicuri che Scipy possa funzionare anche con vettori e matrice. Le matrici sono una parte importante dell'algebra lineare poiché le matrici è qualcosa che usiamo per rappresentare anche le mappature vettoriali.

Proprio come abbiamo guardato a risolvere equazioni lineari con Scipy, possiamo rappresentare i vettori con np.vettore() funzioni. Cominciamo costruendo una matrice:

my_matrix = np.Matrix (NP.casuale.casuale ((3, 3)))
stampa (my_matrix)

Ecco l'output dello snippet sopra:

Ogni volta che parliamo di matrici, parliamo sempre di autovalori e autovettori. Per esprimere parole semplici, gli autovettori sono i vettori che, se moltiplicati con una matrice, non cambiano la loro direzione, al contrario della maggior parte dei vettori. Ciò significa che anche quando moltiplichi un autovettore con una matrice, esiste un valore (o autovalore) che è uno dei fattori della moltiplicazione. Questo significa:

Ax = λx.

Nell'equazione sopra, a è la matrice, λ è l'autovalore e x è il vettore. Scriviamo un semplice frammento di codice per trovare gli autovalori per un determinato vettore:

la, vettore = linalg.eig (my_matrix)
Stampa (Vector [:, 0])
Stampa (Vector [:, 1])
Stampa (Linalg.Eigvals (my_matrix))

Quando eseguiamo questo esempio, vedremo il seguente output:

Calcolo del determinante della matrice

La prossima operazione che effettueremo con Scipy è calcolare il fattore determinante di una matrice bidimensionale. Riutilizzeremo la matrice che abbiamo usato nell'ultimo frammento di codice qui:

linalg.det (my_matrix)

Quando eseguiamo questo esempio, vedremo il seguente output:

Conclusione

In questa lezione, abbiamo esaminato molti buoni esempi in cui Scipy può aiutarci effettuando complessi calcoli matematici per noi con un'API e pacchetti facili da usare.