Matplotlib -Köcher

Ein Köcherdiagramm zeigt Geschwindigkeitskomponenten als Pfeile, die Richtungsparameter U und V an den zweidimensionalen Variablen x und y enthalten. Um die Methode der Quiver () in Matplotlib zu verwenden, generieren wir einen Köchergraphen. Köcherdiagramme würden die elektrische Leistung in der Elektrotechnik veranschaulichen und Druckschwankungen im Maschinenbau zeigen.

In diesem Artikel werden wir die Methoden zum Erstellen von Köchergraphen in Python diskutieren.

Zeichnen Sie die Köcherplot mit einem Pfeil:

In diesem Schritt werden wir eine Köcherung mit einem Pfeil erstellen und wir werden die Arbeit des Matplotlibs beobachten.Axt.zivöser () Funktion.

Matplotlib importieren.Pyplot als PLT
Numph als NP importieren
x = 2
y = 2
U = 3
v = 3
Fig, Ax = PLT.Nebenhandlungen (AbbSize = (5, 5))
Axt.Köcher (x, y, u, v)
Axt.set_title ('Köcherdiagramm')
PLT.zeigen()

Um die Köcherdiagramme zu erstellen, müssen wir die erforderlichen Bibliotheken erwerben: Matplotlib und Numpy. Zum Erstellen des Pfeils deklarieren wir einige Variablen und geben ihnen zufällige Werte an. Diese Variablen zeigen die Position und Richtung des Pfeils. Darüber hinaus erstellen wir ein Objekt, das die Größe der Figur zeigt.

Wir nennen den Funktion zivier (). Diese Funktion enthält vier Parameter. Die Parameter 'x' und 'y' zeigen die Ausgangspunkte des gezogenen Pfeils. Die Richtlinien des Pfeils werden durch die Parameter 'u' und 'v gezeigt.' Außerdem; Wir rufen den Set an.Titel () Funktion, die das Etikett des Köcherplotes anzeigt. Am Ende können wir das Kaufdiagramm mit der PLT anzeigen.show () Funktion.

Dieses Diagramm hat einen Köcherpfeil in der Ausgabe, die bei 'x' = 2 und 'y' = 2 beginnt. Bei 'U' = 3 und 'V' = 3 ist die Richtung des gezogenen Pfeils nach oben und rechts.

Zeichnen Sie das Köcherdiagramm mit zwei Pfeilen:

Jetzt müssen wir einen weiteren Pfeil in die Grafik einfügen. Wir können dies erreichen, indem wir zwei Arrow -Anfangspunkte und zwei Richtlinien der Pfeile bereitstellen.

Matplotlib importieren.Pyplot als PLT
Numph als NP importieren
Fig, Ax = PLT.Nebenhandlungen ()
x = [1, 1]
y = [1, 1]
U = [2, 2]
v = [2, -2]
Axt.Köcher (x, y, u, v,
Skala = 8)
Axt.Achse ([ -5, 5, -5, 5])
PLT.zeigen()

Nach der Integration der Bibliotheken Matplotlib.Pyplot so PLT und Numpy wie NP, wir nennen die Funktion PLT.Subplots () Funktionen zum Erstellen des Diagramms. Dann deklarieren wir zwei Arrays, die die Anfangspunkte der Pfeile enthalten. In der Zwischenzeit speichern wir diese Arrays in 'x' und 'y' Variablen.

In ähnlicher Weise deklarieren wir die beiden anderen Arrays, die die Richtung der Pfeile halten und sie den Variablen "U" und "V" zuweisen. Wir nennen die Axt.zivier () Funktion jetzt. Im obigen Code verfügt diese Funktion über 4 Parameter, einschließlich der Ausgangsposition der Pfeile und der Richtung der Pfeile. In diesem Szenario wird jedoch der AX ein zusätzlicher Parameter -Skala zur Verfügung gestellt.zivöser () Funktion. Dieser Parameter wird verwendet, um die Dimension der Pfeile anzupassen.

Durch die Verringerung des Wertes des Arguments "Skala" können wir einen großen Pfeil zeichnen. Wir können die anfänglichen und terminationspunkte der Pfeile anpassen, indem wir die Grenzwerte an die AX definieren.Axis () Funktion. Wir stellen die Parameter so an, dass der erste Parameter den Mindestwert von 'x' zeigt. Der zweite Parameter zeigt den Maximalwert von 'x'; Der dritte Parameter zeigt den Mindestwert von 'y' und der letzte Parameter zeigt den Maximalwert von 'y'.

Jetzt wird der Diagramm mit der PLT angezeigt.show () Funktion.

Wir erhalten zwei Pfeile in dieser Grafik. Ein Pfeil hat eine Ausgangsposition (1, 1), die in die richtige Richtung zeigt. In ähnlicher Weise hat der andere Pfeil eine Ausgangsposition (1, 1) und zeigt auch in die richtige Richtung nach unten.

Zeichnen Sie das Köcherdiagramm mithilfe von Netzraster:

Das nachfolgende Programm zeigt, wie ein Köcher mit Hilfe eines Netzrasters eine Köcherung zeigt:

Matplotlib importieren.Pyplot als PLT
Numph als NP importieren
x = np.Arange (0, 2.4, 0.3)
y = np.Arange (0, 2.4, 0.3)
X, y = np.Meshgrid (x, y)
u = np.cos (x)*y
v = np.Sünde (y)*y
Fig, Ax = PLT.Nebenhandlungen (Figsize = (12, 10))
Axt.Köcher (x, y, u, v)
Axt.xaxis.set_ticks ([])
Axt.Yaxis.set_ticks ([])
Axt.Achse ([-0).2, 2.2 -0.2, 2.2]))
Axt.set_aspect ('gleich')
PLT.zeigen()

Zu Beginn des Programms importieren wir zwei Pakete, Matplotlib.Pyplot so PLT und Numpy wie NP. Hier erstellen wir die Anfangsposition mit der Numpy -Bibliothek. Wir deklarieren zwei Arrays und weisen diese Arrays der Variablen zu.

Jetzt nennen wir die Meshgrid () -Funktion der Numpy -Bibliothek. Diese Funktion enthält zwei Parameter. Jetzt machen wir zwei neue Variablen. Diese Variablen speichern die Punkte, die die Richtung der Pfeile zeigen. Wir müssen ein Diagramm mit der PLT erstellen.subplot () Funktion. Wir können die Größe des Diagramms mit dieser Funktion einstellen.

In der Zwischenzeit tragen wir die Axt an.Köcher () Methode. Und diese Methode enthält vier Argumente, einschließlich der Startpositionspunkte von Pfeilen und den Richtungspunkten von Pfeilen. Wir deklarieren zwei Funktionen AX.Achse.set_ticks ([]) und ax.Yaxis.set_ticks ([]), die die Zeckenzeichen aus X-Achse und y-Achse beseitigt.

Wir können dies tun, indem wir eine Axt verwenden.Achse(). Hier ändern wir die Achsengrenzen. Am Ende definieren wir vor dem Anzeigen des Diagramms die Axt.set_aspect () Funktion. Diese Funktion bestimmt das Perspektivverhältnis des Diagramms.

In diesem Fall erhalten wir diese Art von Graphen mithilfe der Netzgittermethode. Dieses Diagramm zeigt ein Kenderdiagramm mit mehreren Pfeilen.

Geben Sie die Farbe zum Köcherplot an:

Die Axt der Matplotlib -Bibliothek.Die Funktion von zivier () enthält eine zusätzliche Parameterfarbe, die den Farbton des Pfeils definiert. Die Konturen des Parameters der Köcherfarbe müssen mit den Messungen des Standorts und der Richtungselemente übereinstimmen.

Matplotlib importieren.Pyplot als PLT
Numph als NP importieren
Fig., (Ax1, Ax2) = PLT.Nebenhandlungen (1, 2, Figsize = (10, 5))
x = np.Arange (0, 2.0, 0.4)
y = np.Arange (0, 2.0, 0.4)
X, y = np.Meshgrid (x, y)
u = np.cos (x)*y
v = np.Sünde (y)*y
n = -4
color = np.sqrt (((v-n)/2)*2 + ((u-n)/2)*2)
Ax1.Köcher (x, y, u, v, Farbe, Alpha = 1.0)
Ax1.xaxis.set_ticks ([])
Ax1.Yaxis.set_ticks ([])
Ax1.Achse ([-0).2, 2.3, -0.2, 2.3])
Ax1.set_aspect ('gleich')
Ax1.set_title ('Erstes Diagramm')
x = np.Arange (-2, 2.2, 0.2)
y = np.Arange (-2, 2.2, 0.2)
X, y = np.Meshgrid (x, y)
z = x * np.exp (-x ** 2 -y ** 2)
DX, DY = NP.Gradient (z)
n = -4
color = np.sqrt (((dx-n)/2)*2 + ((dy-n)/2)*2)
AX2.Köcher (X, Y, DX, Dy, Farbe)
AX2.xaxis.set_ticks ([])
AX2.Yaxis.set_ticks ([])
AX2.set_aspect ('gleich')
AX2.set_title ('zweites Diagramm')
PLT.eng_layout ()
PLT.zeigen()

Wir stellen die Matplotlib vor.Pyplot so PLT und Numpy wie NP -Bibliotheken. Im nächsten Schritt werden wir Nebenhandlungen definieren und die Größe des Diagramms anpassen. Zum Zeichnen der ersten Nebenhandlung erstellen wir Pfeile mit dem Numpy -Paket. Die anfänglichen Positionen und Richtungen der Pfeile sind für die Pfeile der ersten Nebenhandlung definiert.

Darüber hinaus setzen wir die Farbe der Pfeile, indem wir die Funktion aufrufen. Wir erstellen das Diagramm, indem wir die Funktion zirkeln () anwenden. Hier haben wir die Farbe der Handlung zugewiesen. Wir haben den Titel der ersten Nebenhandlung angegeben, indem wir die Funktion set_title () aufgerufen haben.

Lassen Sie uns jetzt für die zweite Nebenhandlung gehen. Um Pfeile für die zweite Nebenhandlung zu erstellen, geben wir die Anfangspositionen an und verweisen auf Richtungen der Pfeile. Wir erstellen einen Gradienten zwischen beiden Nebenhandlungen. Wir definieren die Farbe für die zweite Nebenhandlung. Wir erstellen die Nebenhandlung, indem wir die Funktion zirkeln () verwenden. Wir entscheiden die Farbe der Pfeile der zweiten Nebenhandlung.

Am Ende zeigen wir die Grafik, indem wir die PLT aufrufen.show () Methode.

Abschluss:

Wir haben Matplotlib und Python verwendet, um in diesem Artikel eine Vielzahl neuer Köchergrafiken zu erstellen. Das Pyplot -Paket von Matplotlib enthält Kendergrafiken. Die Positionspunkte von x und y und die Richtungen der Pfeile sind die Parameter für die AX.zivöser () Funktion. Die meshgrid () -Methode in Numpy kann solche Positionsmodule erzeugen. Darüber hinaus haben wir einen zusätzlichen Farbton in Köchergraphen eingeführt, indem wir die AX aufrufen.zivier () Funktion mit einer neuen Parameterfarbe.''