Phenquestions
Som SciPy är öppen källkod, det har en mycket aktiv och levande grupp av utvecklare på grund av vilka det finns enormt antal moduler för en mängd vetenskapliga tillämpningar och beräkningar tillgängliga med SciPy. Några av de komplexa matematiska operationerna som kan utföras med SciPy är:
- Interpolation
- Integration
- Optimering
- Bildbehandling
- Statistik
- Specialfunktionsberäkningar etc.
SciPy kan jämföras med de flesta kommando- och standardbibliotek som GSL-bibliotek för C ++ och Matlab. Eftersom SciPy är byggt ovanpå NumPy-paketet kan dessa två paket också integreras helt. Om du kan tänka dig en matematisk operation som måste göras, se till att du kontrollerar SciPy-biblioteket innan du implementerar den modulen på egen hand, för i de flesta fall har SciPy alla funktioner för dig redan implementerade.
Installera SciPy Library
Låt oss installera SciPy-biblioteket innan vi går till de faktiska exemplen och koncepten. Det finns två sätt att installera detta paket. Den första inkluderar att använda Python-pakethanteraren, pip:
pip install scipyDet andra sättet gäller Anaconda, vi kan installera paketet som:
conda install -c anaconda scipyNär biblioteket har installerats kan vi importera det som:
importera scipySlutligen, eftersom vi också kommer att använda NumPy (det rekommenderas att vi använder NumPy direkt för alla NumPy-operationer istället för att gå igenom SciPy-paketet):
importera bedövadDet är möjligt att vi i vissa fall också vill plotta våra resultat för vilka vi kommer att använda Matplotlib-biblioteket. Utför följande import för det biblioteket:
importera matplotlibJag kommer att använda Anaconda-chefen för alla exemplen i den här lektionen. Jag kommer att starta en Jupyter Notebook för samma:
Nu när vi är redo med alla importuttalanden för att skriva lite kod, låt oss börja dyka in i SciPy-paketet med några praktiska exempel.
Arbeta med polynomiska ekvationer
Vi börjar med att titta på enkla polynomekvationer. Det finns två sätt som vi kan integrera polynomfunktioner i vårt program. Vi kan använda poly1d klass som använder koefficienter eller rötterna till ett polynom för att initialisera ett polynom. Låt oss titta på ett exempel:
från nummy import poly1dförsta_polynom = poly1d ([3, 4, 7])
skriva ut (första_polynom)
När vi kör detta exempel ser vi följande utdata:
Det är tydligt att polynomrepresentationen av ekvationen skrivs ut som utdata så att resultatet är ganska lätt att förstå. Vi kan också utföra olika operationer på detta polynom, som att kvadrera det, hitta dess derivat eller till och med lösa det till ett värde av x. Låt oss försöka göra alla dessa i nästa exempel:
skriva ut ("Polynomial Square: \ n")skriv ut (första_polynom * första_polynom)
tryck ("Derivat av polynom: \ n")
skriva ut (första_polynom.deriv ())
skriv ut ("Lösa polynom: \ n")
skriva ut (första_polynom (3))
När vi kör detta exempel ser vi följande utdata:
Just när jag tänkte att detta var allt vi kunde göra med SciPy, kom jag ihåg att vi också kan integrera ett polynom. Låt oss köra ett sista exempel med polynomier:
print ("Integrering av polynom: \ n")skriva ut (första_polynom.integ (1))
Heltalet vi skickar berättar för paketet hur många gånger polynom ska integreras:
Vi kan helt enkelt skicka ett annat heltal som berättar för paketet hur många gånger vi ska integrera detta polynom.
Lösa linjära ekvationer
Det är till och med möjligt att lösa linjära ekvationer med SciPy och hitta deras rötter, om de existerar. För att lösa linjära ekvationer representerar vi uppsättningen ekvationer som NumPy-matriser och deras lösning som en separat NumPy-matris. Låt oss visualisera det med ett exempel där vi gör detsamma och använder linalg paket för att hitta ekvationernas rötter, här är de ekvationer vi ska lösa:
1x + 5y = 63x + 7y = 9
Låt oss lösa ovanstående ekvationer:
från scipy import linalgekvation = np.array ([[1, 5], [3, 7]])
lösning = np.array ([[6], [9]])
rötter = linalg.lösa (ekvation, lösning)
tryck ("Hittade rötterna:")
tryck (rötter)
print ("\ n Punktprodukten ska vara noll om lösningarna är korrekta:")
skriva ut (ekvation.punkt (rötter) - lösning)
När vi kör programmet ovan ser vi att punktproduktekvationen ger noll resultat, vilket betyder att de rötter som programmet hittade var korrekta:
Fourier Transformations med SciPy
Fourier Transformations hjälper oss att uttrycka en funktion som separata komponenter som utgör den funktionen och guidar oss om hur vi kan kombinera dessa komponenter för att få tillbaka den ursprungliga funktionen.
Låt oss titta på ett enkelt exempel på Fourier Transformations där vi plottar summan av två cosinus med hjälp av Matplotlib-biblioteket:
från scipy.fftpack import fft# Antal provpunkter
N = 500
# provavstånd
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 för plottningsändamål
importera matplotlib.pyplot som plt
plt.tomt (xf, 2.0 / N * np.abs (yf [0: N // 2]))
plt.titel ('Info')
plt.ylabel ('Y-axel')
plt.xlabel ('X-axel')
plt.rutnät()
plt.show()
Här började vi med att konstruera ett provutrymme och kosinusekvation som vi sedan transformerade och plottade. Här är resultatet av ovanstående program:
Detta är ett av de goda exemplen där vi ser SciPy används i en komplex matematisk ekvation för att enkelt visualisera saker.
Vektorer och matris med SciPy
Nu när vi vet många saker som SciPy kan, kan vi vara säkra på att SciPy också kan arbeta med vektorer och matris. Matriserna är en viktig del av linjär algebra eftersom matriser också är något vi använder för att representera vektorkartningar.
Precis som vi tittade på att lösa linjära ekvationer med SciPy kan vi representera vektorer med np.array () funktioner. Låt oss börja med att konstruera en matris:
my_matrix = np.matris (np.slumpmässig.slumpmässig ((3, 3)))skriv ut (my_matrix)
Här är utdata från ovanstående utdrag:
När vi pratar om matriser pratar vi alltid om Eigenvalues och Eigenvectors. För att uttrycka enkla ord är Eigenvektorer de vektorer som, när de multipliceras med en matris, inte ändrar sin riktning, i motsats till de flesta vektorerna. Det betyder att även när du multiplicerar en Eigenvectors med en matris, finns det ett värde (eller egenvärde) som är en av multiplikationsfaktorn. Detta betyder:
Ax = λx.I ovanstående ekvation är A matrisen, λ är Eigenvalue och x är Vector. Låt oss skriva ett enkelt kodavsnitt för att hitta Eigenvalues för en given Vector:
la, vektor = linalg.eig (my_matrix)tryck (vektor [:, 0])
tryck (vektor [:, 1])
tryck (linalg.eigvals (my_matrix))
När vi kör detta exempel ser vi följande utdata:
Beräkning av matrisdeterminant
Nästa operation vi ska utföra med SciPy är att beräkna determinanten för en 2-dimensionell matris. Vi kommer att återanvända matrisen vi använde i det senaste kodavsnittet här:
linalg.det (my_matrix)När vi kör detta exempel ser vi följande utdata:
Slutsats
I den här lektionen tittade vi på många bra exempel där SciPy kan hjälpa oss genom att utföra komplexa matematiska beräkningar för oss med ett lättanvänt API och paket.
