Phenquestions
Come SciPy è open source, ha una comunità di sviluppatori molto attiva e vivace grazie alla quale è presente un numero enorme di moduli per una vasta quantità di applicazioni e calcoli scientifici 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 paragonato alla maggior parte delle librerie di comandi e standard come la libreria GSL per C++ e Matlab. Poiché SciPy è basato 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 SciPy prima di implementare quel modulo da solo perché nella maggior parte dei casi, SciPy ha tutte le operazioni per te già completamente implementate.
Installa la libreria SciPy
Installiamo la libreria SciPy prima di passare agli esempi e ai concetti reali. Ci sono due modi per installare questo pacchetto. Il primo include l'uso del gestore di pacchetti Python, pip:
pip installa scipyIl secondo modo riguarda Anaconda, possiamo installare il pacchetto come:
conda install -c anaconda scipyUna volta installata la libreria, possiamo importarla come:
importa scipyInfine, poiché utilizzeremo anche NumPy (si consiglia di utilizzare NumPy direttamente per tutte le operazioni di NumPy invece di passare attraverso il pacchetto SciPy):
importa numpyÈ possibile che in alcuni casi ci piaccia anche tracciare i nostri risultati per i quali utilizzeremo la libreria Matplotlib. Eseguire la seguente importazione per quella libreria:
import matplotlibUserò il manager Anaconda per tutti gli esempi in questa lezione. Lancerò un notebook Jupyter per lo stesso:
Ora che siamo pronti con tutte le istruzioni di importazione per scrivere del codice, iniziamo a tuffarci nel pacchetto SciPy con alcuni esempi pratici.
Lavorare con le equazioni polinomiali
Inizieremo guardando semplici equazioni polinomiali. Ci sono due modi con cui possiamo integrare le funzioni polinomiali nel nostro programma. Possiamo utilizzare poli1d classe che utilizza i coefficienti o le radici di un polinomio per inizializzare un polinomio. Vediamo un esempio:
da numpy import poly1dprimo_polinomio = poli1d([3, 4, 7])
print(primo_polinomio)
Quando eseguiamo questo esempio, vedremo il seguente output:
Chiaramente, la rappresentazione polinomiale dell'equazione viene stampata come output in modo che il risultato sia abbastanza facile da capire. Possiamo anche eseguire varie operazioni su questo polinomio, come elevarlo al quadrato, trovarne la derivata o addirittura risolverlo per un valore di x. Proviamo a fare tutto questo nel prossimo esempio:
print("Quadrato polinomiale: \n")print(primo_polinomio * primo_polinomio)
print("Derivata del polinomio: \n")
print(primo_polinomio.deriva())
print("Risoluzione del polinomio: \n")
print(primo_polinomio(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 integrare anche un polinomio. Facciamo un ultimo esempio con i polinomi:
print("Integrazione del polinomio: \n")print(primo_polinomio.intero(1))
L'intero che passiamo dice al pacchetto quante volte integrare il polinomio:
Possiamo semplicemente passare un altro intero che dice al pacchetto quante volte integrare questo polinomio.
Risolvere equazioni lineari
È anche possibile risolvere equazioni lineari con SciPy e trovarne le 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 ci avvaliamo di linalg pacchetto per trovare le radici delle equazioni, ecco le equazioni che risolveremo:
1x + 5y = 63x + 7y = 9
Risolviamo le equazioni precedenti:
da scipy import linalgequazione = np.matrice([[1, 5], [3, 7]])
soluzione = np.matrice([[6], [9]])
radici = linalg.risolvere (equazione, soluzione)
print("Ho trovato le radici:")
stampa (radici)
print("\n Il prodotto scalare deve essere zero se le soluzioni sono corrette:")
print(equazione.punto (radici) - soluzione)
Quando eseguiamo il programma sopra, vedremo che l'equazione del prodotto scalare dà un risultato zero, il che significa che le radici trovate dal 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 guidano 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 coseni usando la libreria Matplotlib:
da scipy.fftpack import fft# Numero di punti campione
N = 500
# spaziatura campione
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 * V), N//2)
# matplotlib per la stampa
import matplotlib.pyplot come plt
per favore.trama(xf, 2.0/N * np.abs(yf[0:N//2]))
per favore.titolo('Informazioni')
per favore.ylabel('asse Y')
per favore.xlabel('asse X')
per favore.griglia()
per favore.mostrare()
Qui, abbiamo iniziato costruendo uno spazio campione e un'equazione del coseno che abbiamo poi trasformato e tracciato. Ecco l'output del programma precedente:
Questo è uno dei buoni esempi in cui vediamo SciPy utilizzato in una complessa equazione matematica per visualizzare facilmente le cose.
Vettori e matrice con SciPy
Ora che sappiamo molte cose di cui è capace SciPy, possiamo essere sicuri che SciPy può funzionare anche con Vettori e Matrix. Le matrici sono una parte importante dell'algebra lineare poiché le matrici sono qualcosa che usiamo anche per rappresentare le mappature vettoriali.
Proprio come abbiamo esaminato la risoluzione di equazioni lineari con SciPy, possiamo rappresentare i vettori con np.Vettore() funzioni. Iniziamo costruendo una matrice:
mia_matrice = np.matrice(np.casuale.casuale((3, 3)))print(mia_matrice)
Ecco l'output dello snippet sopra:
Ogni volta che si parla di matrici, si parla sempre di Autovalori e Autovettori. In parole povere, gli autovettori sono i vettori che, moltiplicati per una matrice, non cambiano direzione, al contrario della maggior parte dei vettori. Ciò significa che anche moltiplicando un Autovettore per 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 dato vettore:
la, vettore = linalg.eig(mia_matrice)print(vettore[:, 0])
print(vettore[:, 1])
print(linalg.eigvals(my_matrix))
Quando eseguiamo questo esempio, vedremo il seguente output:
Calcolo del determinante della matrice
La prossima operazione che faremo con SciPy è calcolare il determinante di una matrice bidimensionale. Riutilizzeremo la matrice che abbiamo usato nell'ultimo frammento di codice qui:
linalg.det( mia_matrice )Quando eseguiamo questo esempio, vedremo il seguente output:
Conclusione
In questa lezione, abbiamo esaminato molti buoni esempi in cui SciPy può aiutarci eseguendo complessi calcoli matematici per noi con un'API e pacchetti facili da usare.
