Phenquestions
Som SciPy er åpen kildekode, den har et veldig aktivt og levende fellesskap av utviklere, og det er et enormt antall moduler til stede for et stort antall vitenskapelige applikasjoner og beregninger tilgjengelig med SciPy. Noen av de komplekse matematiske operasjonene som kan utføres med SciPy er:
- Interpolasjon
- Integrering
- Optimalisering
- Bildebehandling
- Statistikk
- Spesielle funksjonsberegninger osv.
SciPy kan sammenlignes med de fleste kommando- og standardbiblioteker som GSL-bibliotek for C ++ og Matlab. Ettersom SciPy er bygget på toppen av NumPy-pakken, kan disse to pakkene også integreres fullstendig. Hvis du kan tenke deg en matematisk operasjon som må gjøres, må du sjekke SciPy-biblioteket før du implementerer den modulen på egen hånd, for i de fleste tilfeller har SciPy alle operasjonene for deg fullstendig implementert allerede.
Installer SciPy Library
La oss installere SciPy-biblioteket før vi går til de faktiske eksemplene og konseptene. Det er to måter å installere denne pakken på. Den første inkluderer bruk av Python pakkebehandling, pip:
pip install scipyDen andre måten gjelder Anaconda, vi kan installere pakken som:
conda install -c anaconda scipyNår biblioteket er installert, kan vi importere det som:
importer scipyTil slutt, ettersom vi også bruker NumPy (det anbefales at vi bruker NumPy direkte i stedet for å gå gjennom SciPy-pakken for alle NumPy-operasjoner):
importer nummenDet er mulig at vi i noen tilfeller også vil plotte resultatene vi vil bruke Matplotlib-biblioteket for. Utfør følgende import for det biblioteket:
importer matplotlibJeg vil bruke Anaconda-sjefen for alle eksemplene i denne leksjonen. Jeg vil lansere en Jupyter Notebook for det samme:
Nå som vi er klare med alle importuttalelser for å skrive litt kode, la oss begynne å dykke ned i SciPy-pakken med noen praktiske eksempler.
Arbeide med polynomiske ligninger
Vi begynner med å se på enkle polynomiske ligninger. Det er to måter vi kan integrere polynomfunksjoner i programmet vårt. Vi kan gjøre bruk av poly1d klasse som bruker koeffisienter eller røttene til et polynom for initialisering av et polynom. La oss se på et eksempel:
fra nummen import poly1dfirst_polynomial = poly1d ([3, 4, 7])
skriv ut (første_polynom)
Når vi kjører dette eksemplet, ser vi følgende utdata:
Det er tydelig at polynomrepresentasjonen av ligningen skrives ut som utdata, slik at resultatet er ganske lett å forstå. Vi kan også utføre forskjellige operasjoner på dette polynomet, som å kvadratere det, finne dets derivat eller til og med løse det til en verdi på x. La oss prøve å gjøre alle disse i neste eksempel:
utskrift ("Polynomial Square: \ n")skriv ut (første_polynom * første_polynom)
print ("Derivat av polynom: \ n")
skriv ut (første_polynom.deriv ())
skriv ut ("Løse polynomet: \ n")
skriv ut (første_polynom (3))
Når vi kjører dette eksemplet, ser vi følgende utdata:
Akkurat da jeg tenkte at dette var alt vi kunne gjøre med SciPy, husket jeg at vi også kan integrere et polynom. La oss kjøre et siste eksempel med polynomer:
print ("Integrering av polynomet: \ n")skriv ut (første_polynom.integ (1))
Heltallet vi passerer forteller pakken hvor mange ganger polynomet skal integreres:
Vi kan ganske enkelt passere et annet heltall som forteller pakken hvor mange ganger vi skal integrere dette polynomet.
Løse lineære ligninger
Det er til og med mulig å løse lineære ligninger med SciPy og finne sine røtter, hvis de eksisterer. For å løse lineære ligninger representerer vi settet med ligninger som NumPy-matriser og løsningen deres som separate NumPy-matriser. La oss visualisere det med et eksempel der vi gjør det samme og bruker linalg pakke for å finne røttene til ligningene, her er ligningene vi skal løse:
1x + 5y = 63x + 7y = 9
La oss løse ovenstående ligninger:
fra scipy import linalgligning = np.matrise ([[1, 5], [3, 7]])
løsning = np.matrise ([[6], [9]])
røtter = linalg.løse (ligning, løsning)
print ("Fant røttene:")
trykk (røtter)
print ("\ n Punktproduktet skal være null hvis løsningene stemmer:")
skriv ut (ligning.prikk (røtter) - løsning)
Når vi kjører programmet ovenfor, ser vi at punktproduktligningen gir null resultat, noe som betyr at røttene som programmet fant var riktige:
Fourier-transformasjoner med SciPy
Fourier Transformations hjelper oss med å uttrykke en funksjon som separate komponenter som utgjør den funksjonen og veileder oss om hvordan vi kan kombinere disse komponentene for å få den opprinnelige funksjonen tilbake.
La oss se på et enkelt eksempel på Fourier-transformasjoner der vi tegner summen av to cosinus ved hjelp av Matplotlib-biblioteket:
fra scipy.fftpack import fft# Antall prøvepunkter
N = 500
# prøveavstand
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 for plottformål
importer matplotlib.pyplot som plt
plt.tomt (xf, 2.0 / N * np.abs (yf [0: N // 2]))
plt.tittel ('Info')
plt.ylabel ('Y-akse')
plt.xlabel ('X-akse')
plt.Nett()
plt.vise fram()
Her startet vi med å konstruere en prøveplass og cosinusligning som vi deretter transformerte og plottet. Her er utgangen av programmet ovenfor:
Dette er et av de gode eksemplene der vi ser SciPy brukes i en kompleks matematisk ligning for å visualisere ting enkelt.
Vektorer og matrise med SciPy
Nå som vi vet mange ting som SciPy er i stand til, kan vi være sikre på at SciPy også kan jobbe med vektorer og matrise. Matriser er en viktig del av lineær algebra da matriser er noe vi også bruker for å representere Vector-kartlegginger.
Akkurat som vi så på å løse lineære ligninger med SciPy, kan vi representere vektorer med np.matrise () funksjoner. La oss starte med å lage en matrise:
my_matrix = np.matrise (np.tilfeldig.tilfeldig ((3, 3)))skriv ut (my_matrix)
Her er utdataene fra utdraget ovenfor:
Hver gang vi snakker om matriser, snakker vi alltid om Eigenvalues og Eigenvectors. For å si det enkle ord, er Eigenvektorer vektorene som, når de multipliseres med en matrise, ikke endrer retning, i motsetning til de fleste vektorene. Dette betyr at selv når du multipliserer en Eigenvectors med en matrise, eksisterer det en verdi (eller egenverdi) som er en av faktorene for multiplikasjonen. Dette betyr:
Ax = λx.I ovenstående ligning er A matrisen, λ er Eigenvalue og x er Vector. La oss skrive et enkelt kodebit for å finne Eigenvalues for en gitt Vector:
la, vektor = linalg.eig (my_matrix)trykk (vektor [:, 0])
trykk (vektor [:, 1])
utskrift (linalg.eigvals (my_matrix))
Når vi kjører dette eksemplet, ser vi følgende utdata:
Beregning av matriksdeterminant
Den neste operasjonen vi skal utføre med SciPy er å beregne determinanten til en todimensjonal matrise. Vi vil gjenbruke matrisen vi brukte i den siste kodebiten her:
linalg.det (my_matrix)Når vi kjører dette eksemplet, ser vi følgende utdata:
Konklusjon
I denne leksjonen så vi på mange gode eksempler der SciPy kan hjelpe oss ved å utføre komplekse matematiske beregninger for oss med et brukervennlig API og pakker.
