Python Scipy Tutorial

In dieser Lektion werden wir sehen, wie die Scipy -Bibliothek in Python verwendet wird und wie es uns hilft, mit mathematischen Gleichungen und Algorithmen auf interaktive Weise zu arbeiten. Das Gute an Scipy Python -Paket ist, dass Scipy, wenn wir Klassen oder Konstrukt -Webseiten konstruieren möchten, vollständig mit dem gesamten System kompatibel ist und eine nahtlose Integration liefern kann.

Als Scipy ist Open Source, Es verfügt über eine sehr aktive und lebendige Gemeinschaft von Entwicklern, auf die eine enorme Anzahl von Modulen für eine Vielzahl von wissenschaftlichen Anwendungen und Berechnungen mit Scipy vorhanden ist. Einige der komplexen mathematischen Operationen, die mit Scipy ausgeführt werden können, sind:

• Interpolation
• Integration
• Optimierung
• Bildverarbeitung
• Statistiken
• Spezialfunktionsberechnungen usw.

Scipy kann mit den meisten Befehls- und Standardbibliotheken wie GSL -Bibliothek für C ++ und MATLAB verglichen werden. Da Scipy auf dem Numpy -Paket aufgebaut ist, können diese beiden Pakete auch vollständig integriert werden. Wenn Sie sich einen mathematischen Betrieb vorstellen können, der durchgeführt werden muss, überprüfen Sie die Scipy -Bibliothek, bevor Sie dieses Modul selbst implementieren.

Installieren Sie die Scipy -Bibliothek

Installieren wir die Scipy -Bibliothek, bevor wir zu den tatsächlichen Beispielen und Konzepten übergehen. Es gibt zwei Möglichkeiten, dieses Paket zu installieren. Zuerst umfasst die Verwendung des Python -Paketmanagers, PIP:

PIP Installieren Sie Scipy

Der zweite Weg bezieht sich auf Anaconda. Wir können das Paket als:

Conda install -c Anaconda scipy

Sobald die Bibliothek installiert ist, können wir sie als:

Skipie importieren

Da wir auch Numpy verwenden werden (es wird empfohlen, für alle Numpy -Operationen Numpy direkt zu verwenden, anstatt das Scipy -Paket durchzugehen):

Numpy importieren

Es ist möglich, dass wir in einigen Fällen auch unsere Ergebnisse zeichnen, für die wir die Matplotlib -Bibliothek verwenden werden. Führen Sie den folgenden Import für diese Bibliothek durch:

Matplotlib importieren

Ich werde den Anaconda -Manager für alle Beispiele in dieser Lektion verwenden. Ich werde ein Jupyter -Notizbuch für dasselbe starten:

Nachdem wir mit allen Importanweisungen bereit sind, um Code zu schreiben, beginnen wir mit einigen praktischen Beispielen in das Scipy -Paket einzusteigen.

Arbeiten mit Polynomgleichungen

Wir werden zunächst einfache Polynomgleichungen betrachten. Es gibt zwei Möglichkeiten, mit denen wir Polynomfunktionen in unser Programm integrieren können. Wir können nutzen Poly1d Klasse, die Koeffizienten oder die Wurzeln eines Polynoms zur Initialisierung eines Polynoms verwendet. Schauen wir uns ein Beispiel an:

aus Numpy Import Poly1d
First_polynomial = poly1d ([3, 4, 7])
print (First_polynom)

Wenn wir dieses Beispiel ausführen, sehen wir die folgende Ausgabe:

Offensichtlich wird die Polynomdarstellung der Gleichung als Ausgabe gedruckt, so dass das Ergebnis ziemlich leicht zu verstehen ist. Wir können auch verschiedene Operationen auf diesem Polynom ausführen, z. Versuchen wir all dies im nächsten Beispiel:

print ("Polynomquadrat: \ n")
print (first_polynomial * first_polynom)
print ("Ableitung von Polynom: \ n")
print (first_polynomial.Deriv ())
print ("Lösen des Polynoms: \ n")
print (first_polynomial (3))

Wenn wir dieses Beispiel ausführen, sehen wir die folgende Ausgabe:

Gerade als ich dachte, dass dies alles ist, was wir mit Scipy machen konnten, erinnerte ich mich daran, dass wir auch ein Polynom integrieren können. Lassen Sie uns ein endgültiges Beispiel mit Polynomen durchführen:

print ("Integration des Polynoms: \ n")
print (first_polynomial.Intete (1))

Die Ganzzahl, die wir verabschieden, sagt dem Paket, wie oft das Polynom integriert wird:

Wir können einfach eine andere Ganzzahl übergeben, die dem Paket mitteilt, wie oft dieses Polynom integriert wird.

Lösung linearer Gleichungen

Es ist sogar möglich, lineare Gleichungen mit Scipy zu lösen und ihre Wurzeln zu finden, wenn sie existieren. Um lineare Gleichungen zu lösen, repräsentieren wir den Satz von Gleichungen als Numpy -Arrays und ihre Lösung als separate Numpy -Arrays. Lassen Sie es uns mit einem Beispiel visualisieren, in dem wir dasselbe tun und verwenden Linalg Paket, um die Wurzeln der Gleichungen zu finden, hier sind die Gleichungen, die wir lösen werden:

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

Lassen Sie uns die obigen Gleichungen lösen:

von Scipy Import Linalg
Gleichung = NP.Array ([1, 5], [3, 7]])
Lösung = NP.Array ([6], [9]])
Wurzeln = Linalg.Lösen (Gleichung, Lösung)
print ("Die Wurzeln gefunden:")
Druck (Wurzeln)
print ("\ n dot -Produkt sollte Null sein, wenn die Lösungen korrekt sind:")
Druck (Gleichung.Punkt (Wurzeln) - Lösung)

Wenn wir das obige Programm ausführen, werden wir feststellen, dass die DOT -Produktgleichung null Ergebnisse liefert, was bedeutet, dass die Wurzeln, die das Programm gefunden hat, korrekt waren:

Fourier -Transformationen mit Scipy

Fourier -Transformationen hilft uns, eine Funktion als separate Komponenten auszudrücken, aus denen diese Funktion besteht.

Schauen wir uns ein einfaches Beispiel für Fourier -Transformationen an, bei dem wir die Summe von zwei Cosinus unter Verwendung der Matplotlib -Bibliothek zeichnen:

von Scipy.fftpack import fft
# Anzahl der Stichprobenpunkte
N = 500
# Probenabstand
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 Plottenzwecke
Matplotlib importieren.Pyplot als PLT
PLT.Diagramm (xf, 2.0/n * np.ABS (yf [0: n // 2])))
PLT.Titel ('info')
PLT.Ylabel ('Y -Achse')
PLT.xlabel ('x Achse')
PLT.Netz()
PLT.zeigen()

Hier haben wir zunächst einen Stichprobenraum und eine Cosinus -Gleichung erstellt, die wir dann transformierten und aufgetragen haben. Hier ist die Ausgabe des obigen Programms:

Dies ist eines der guten Beispiele, bei denen Scipy in einer komplexen mathematischen Gleichung verwendet wird, um die Dinge leicht zu visualisieren.

Vektoren und Matrix mit Scipy

Jetzt, da wir viele Dinge wissen, zu denen Scipy fähig ist, können wir sicher sein, dass Scipy auch mit Vektoren und Matrix funktionieren kann. Die Matrizen sind ein wichtiger Bestandteil der linearen Algebra, da die Matrizen auch Vektorzuordnungen darstellen.

So wie wir es uns angesehen haben, lineare Gleichungen mit Scipy zu lösen, können wir Vektoren mit repräsentieren np.Array () Funktionen. Beginnen wir zunächst eine Matrix:

my_matrix = np.Matrix (NP.willkürlich.zufällig ((3, 3)))
print (my_matrix)

Hier ist die Ausgabe des obigen Snippets:

Wenn wir über Matrizen sprechen, sprechen wir immer über Eigenwerte und Eigenvektoren. Um einfache Wörter einzubringen, sind Eigenvektoren die Vektoren, die, wenn sie mit einer Matrix multipliziert werden, ihre Richtung nicht ändern, im Gegensatz zu den meisten Vektoren. Dies bedeutet, dass selbst wenn Sie ein Eigenvektoren mit einer Matrix multiplizieren, einen Wert (oder ein Eigenwert) gibt, der einer der Faktoren der Multiplikation ist. Das heisst:

Ax = λx.

In der obigen Gleichung ist a die Matrix, λ der Eigenwert und x der Vektor. Schreiben wir einen einfachen Code -Snippet, um die Eigenwerte für einen bestimmten Vektor zu finden:

la, vector = linalg.EIG (my_matrix)
print (vector [: 0])
print (vector [:, 1])
drucken (Linalg.Eigen (my_matrix))

Wenn wir dieses Beispiel ausführen, sehen wir die folgende Ausgabe:

Berechnung der Matrixdeterminante

Die nächste Operation, die wir mit Scipy ausführen werden, besteht darin, die Determinante einer zweidimensionalen Matrix zu berechnen. Wir werden die Matrix, die wir im letzten Code -Snippet verwendet haben, wiederverwenden:

Linalg.Det (my_matrix)

Wenn wir dieses Beispiel ausführen, sehen wir die folgende Ausgabe:

Abschluss

In dieser Lektion haben wir uns viele gute Beispiele angesehen, in denen Scipy uns helfen kann, indem wir komplexe mathematische Berechnungen für uns mit einer einfach zu verwendenden API und Paketen durchführen.