Python Scipy Tutorial

I denne leksjonen vil vi se hva som er bruken av Scipy Library i Python og hvordan det hjelper oss å jobbe med matematiske ligninger og algoritmer på en interaktiv måte. Det gode med Scipy Python -pakken er at hvis vi vil ha klasser eller konstruere websider, er Scipy fullt kompatibel med systemet som helhet og kan gi sømløs integrasjon.

Som Scipy er åpen kildekode, Det har et veldig aktivt og levende fellesskap av utviklere som det er et enormt antall moduler til stede for en enorm mengde 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. Siden Scipy er bygget på toppen av Numpy -pakken, kan disse to pakkene også integreres helt. Hvis du kan tenke på en matematisk operasjon som må gjøres, må du sjekke Scipy -biblioteket før du implementerer den modulen på egen hånd, fordi i de fleste tilfeller har Scipy alle operasjoner for deg fullt ut implementert allerede.

Installer Scipy Library

La oss installere Scipy Library før vi går over til de faktiske eksemplene og konseptene. Det er to måter å installere denne pakken. Den første inkluderer å bruke Python Package Manager, PIP:

Pip installer scipy

Den andre måten forholder seg til Anaconda, vi kan installere pakken som:

conda install -c anaconda scipy

Når biblioteket er installert, kan vi importere det som:

Importer scipy

Til slutt, som vi også vil bruke Numpy (det anbefales at vi for alle Numpy -operasjoner bruker Numpy direkte i stedet for å gå gjennom Scipy -pakken):

Importer numpy

Det er mulig at vi i noen tilfeller også vil planlegge resultatene våre som vi vil bruke Matplotlib -biblioteket. Utfør følgende import for det biblioteket:

Importer matplotlib

Jeg vil bruke Anaconda Manager for alle eksemplene i denne leksjonen. Jeg vil lansere en Jupyter -notatbok for det samme:

Nå som vi er klare med alle importuttalelser for å skrive litt kode, la oss begynne å dykke inn i Scipy -pakken med noen praktiske eksempler.

Arbeide med polynomligninger

Vi starter med å se på enkle polynomligninger. Det er to måter vi kan integrere polynomfunksjoner i programmet vårt. Vi kan benytte oss av Poly1d klasse som benytter seg av koeffisienter eller røttene til et polynom for initialisering av et polynomial. La oss se på et eksempel:

fra numpy import poly1d
First_Polynomial = Poly1d ([3, 4, 7])
print (first_polynomial)

Når vi kjører dette eksemplet, vil vi se følgende utgang:

Det er klart at den polynomiske representasjonen av ligningen er skrevet ut som utgangen slik at resultatet er ganske enkelt å forstå. Vi kan utføre forskjellige operasjoner på dette polynomet også, som firkantet det, finne dets derivat eller til og med løse det for en verdi av x. La oss prøve å gjøre alle disse i neste eksempel:

Print ("Polynomial Square: \ n")
print (first_polynomial * first_polynomial)
trykk ("Derivat av polynom: \ n")
print (first_polynomial.deriv ())
trykk ("Løsning av polynomet: \ n")
print (first_polynomial (3))

Når vi kjører dette eksemplet, vil vi se følgende utgang:

Akkurat da jeg tenkte at dette er 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")
print (first_polynomial.Integ (1))

Heltallet vi passerer forteller pakken hvor mange ganger for å integrere polynomet:

Vi kan ganske enkelt passere et annet heltall som forteller pakken hvor mange ganger for å integrere dette polynomet.

Løsing av lineære ligninger

Det er til og med mulig å løse lineære ligninger med scipy og finne røttene sine, hvis de eksisterer. For å løse lineære ligninger representerer vi settet med ligninger som numpy matriser og deres løsning som en egen numpy matriser. La oss visualisere det med et eksempel der vi gjør det samme og benytte oss av Lining Pakke for å finne røttene til ligningene, her er ligningene vi vil løse:

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

La oss løse ligningene ovenfor:

fra Scipy Import Linald
Ligning = np.Array ([[1, 5], [3, 7]])
Løsning = NP.Array ([[6], [9]])
røtter = ling.Løs (ligning, løsning)
trykk ("Fant røttene:")
trykk (røtter)
Print ("\ n Dot -produktet skal være null hvis løsningene er riktige:")
trykk (ligning.Dot (røtter) - Løsning)

Når vi kjører ovennevnte program, vil vi se at prikkproduktligningen gir null resultat, noe som betyr at røttene som programmet fant var riktige:

Fourier -transformasjoner med scipy

Fourier -transformasjoner hjelper oss med å uttrykke en funksjon som separate komponenter som utgjør den funksjonen og guider oss om måten vi kan rekombinere disse komponentene for å få den originale funksjonen tilbake.

La oss se på et enkelt eksempel på Fourier -transformasjoner der vi planlegger summen av to kosiner ved bruk av Matplotlib -biblioteket:

Fra scipy.fftpack import fft
# Antall prøvepoeng
N = 500
# Eksempelavstand
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 plotteformål
Importer matplotlib.Pyplot som Plt
plt.plot (xf, 2.0/n * np.ABS (YF [0: N // 2]))
plt.tittel ('info')
plt.ylabel ('y Axis')
plt.Xlabel ('X Axis')
plt.Nett()
plt.forestilling()

Her startet vi med å konstruere en prøveområde og kosinusligning som vi deretter forvandlet og plottet. Her er utdataene fra ovennevnte program:

Dette er et av de gode eksemplene der vi ser at Scipy blir brukt 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 fungere med vektorer og matrise. Matrisene er en viktig del av lineær algebra, da matriser er noe vi bruker for å representere vektormapper også.

Akkurat som vi så på å løse lineære ligninger med scipy, kan vi representere vektorer med np.Array () funksjoner. La oss starte med å konstruere en matrise:

my_matrix = np.Matrise (NP.tilfeldig.tilfeldig ((3, 3))))
print (my_matrix)

Her er utgangen fra ovennevnte utdrag:

Hver gang vi snakker om matriser, snakker vi alltid om egenverdier og egenvektorer. For å sette inn enkle ord, er egenvektorer 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 egenvektorer med en matrise, eksisterer det en verdi (eller egenverdi) som er en av faktoren for multiplikasjonen. Dette betyr:

AX = λx.

I ovennevnte ligning er a matrisen, λ er egenverdien og x er vektoren. La oss skrive et enkelt kodebit for å finne egenverdiene for en gitt vektor:

la, vektor = ling.eig (my_matrix)
Print (Vector [:, 0])
Print (Vector [:, 1])
Trykk (Lining.eigals (my_matrix))

Når vi kjører dette eksemplet, vil vi se følgende utgang:

Beregning av matrisedeterminant

Den neste operasjonen vi vil utføre med scipy er å beregne determinanten for en 2-dimensjonal matrise. Vi bruker matrisen vi brukte i det siste kodebiten her:

Lining.det (my_matrix)

Når vi kjører dette eksemplet, vil vi se følgende utgang:

Konklusjon

I denne leksjonen så vi på mange gode eksempler der Scipy kan hjelpe oss ved å utføre komplekse matematiske beregninger for oss med en brukervennlig API og pakker.