Matplotlib Twinx

Matplotlib ist eine numerische analytische Erweiterung für das Numpy -Paket in Python. Die Achsenklasse definiert den Satz von Punkten und enthält die Mehrheit der grafischen Komponenten: Achse, Marke, Annotation, Polylinie usw. Achsenobjekte beinhalten einen Prozess, der Funktionsaufrufe unterstützt. Um eine Doppelachsen zu entwickeln, die die x-Achse teilt, verwenden Sie einfach die Achsen.Twinx () -Methode im Achsenabschnitt des Matplotlib -Pakets. Schauen wir uns die Twinx () -Funktion im Detail an.

Verwendung von Achsen.Twinx () Methode:

In diesem Schritt sehen wir, wie die Funktion Twinx () verwendet wird. Diese Methode erstellt Doppelachsen, die die x-Achse teilen.

Matplotlib importieren.Pyplot als PLT
Numph als NP importieren
Def GFG1 (TEMP):
Rückkehr (6. / 10.) * (Temp - 40)
Def GFG2 (AX1):
y1, y2 = ax1.get_ylim ()
ax_twin .set_ylim (gfg1 (y1), gfg1 (y2))
ax_twin .Figur.Leinwand.ziehen()
Fig, Ax1 = PLT.Nebenhandlungen ()
ax_twin = ax1.Twinx ()
Ax1.Rückrufe.connect ("ylim_changed", gfg2)
Ax1.Diagramm (NP.Linspace (-60, 100, 200))
Ax1.set_xlim (50, 150)
Ax1.set_ylabel ('y-axis')
ax_twin .set_ylabel ('y-axis')
Feige.Suptitle ('Abbildung \ n \ n', fontweight = "BOLD")
PLT.zeigen()

Der erste Schritt vor dem Schreiben des Programms besteht darin, Matplotlib einzuführen.Pyplot so PLT und Numpy wie NP. Wir definieren das Objekt und rufen die Funktion auf, die den Temperaturwert zurückgibt. Wir definieren auch GFG2 und es enthält ein Objekt.

Wir nennen die Funktion get_ylim (), um die Grenze der y-Achse anzugeben. Wir bieten 'GFG1' und 'GFG2' Argumenten für die Funktion set_ylim () Argumente. Wir deklarieren ein neues Objekt AX_TWIN.Figur.Leinwand.ziehen.

Jetzt PLT.Subplots () -Funktion wird angewendet, um die Grafik zu erstellen. Eine neue Funktion ax_twin () Funktion. Es wird verwendet, um identische Achsen zu erstellen, die die x-Achse teilen. Wir haben den Zeilenbereich des Diagramms mithilfe der Funktion NP angegeben.Linspace () der Numpy -Bibliothek.

Darüber hinaus setzen wir die Grenzen der x-Achse, indem wir die Methode set_xlim () aufrufen. Wir müssen die Beschriftungen beider Seiten der y-Achse einstellen, indem wir die Methode set_label () anwenden. Wir verwenden die Feigen.Suptitle () Funktion zum Definieren des Titels der Grafik. Für diese Funktion wird der Parameter des Schriftgewichts bereitgestellt.

Die Funktion plt.show () wird in der Beendigung des Codes aufgerufen, um die Grafik darzustellen.

Fügen Sie zusätzliche Y-Achse in Matplotlib ein:

Wir könnten die Methode Twinx () verwenden, um eine zweite y-Achse zu erzeugen.

Matplotlib importieren.Pyplot als PLT
Fig, BX = PLT.Nebenhandlungen ()
BX.Diagramm ([2, 4, 6, 8, 10], [1, 3, 9, 11, 1], Color = 'Green')
BX1 = BX.Twinx ()
BX1.Diagramm ([22, 32, 42, 52, 5], [10, 12, 14, 16, 18], Farbe = 'Orange')
Feige.eng_layout ()
PLT.zeigen()

Wir importieren die erforderliche Bibliotheks Matplotlib.Pyplot als PLT. Wir nehmen zwei Variablen, 'Fig' und 'BX.'Wir verwenden PLT.Subplots () Funktionen, bei denen keine Zeilen und Spalten auf 1 eingestellt sind. Darüber hinaus nennen wir den BX.Plot () Funktion zum Zeichnen der ersten Zeile der Grafik. Diese Funktion enthält zwei Arrays mit Datensätzen mit X-Achse und y-Achse getrennt.

Wir haben auch die Farbe der Linie als Argument für diese Funktion übergeben. Als nächstes wenden wir den BX an.Twinx () -Methode zur Erzeugung eines Zwillings von Achsen mit einer gegenseitigen x-Achse. Um eine weitere Zeile in der Grafik zu zeichnen, verwenden wir den BX1.Plot () Funktion. Hier deklarieren wir zwei Arrays. Diese Arrays bestehen aus Datenpunkten der X-Achse und der Y-Achse für die zweite Zeile.

Wir haben die Farbe für die zweite Zeile des Diagramms definiert, indem wir dem Funktionsdiagramm Farbparameter bereitstellen (). Wir zeichnen die zweite Zeile auf BX1. Jetzt die Funktion Abb. Abb.dight_layout () ist definiert, damit wir den Abstand zwischen den Linien einstellen müssen. Wir verwenden die PLT.show () Funktion zum Anzeigen des Diagramms.

Matplotlib Twin Y-Achse:

In dieser Unterschrift untersuchen wir die Verwendung von Matplotlib in Python, um eine Figur mit zwei Y-Achsen zu erstellen. Wir werden ein einzigartiges Diagramm erstellen, das verschiedene Variablen enthält, da wir eine einfache Analyse benötigen. Die Twinx () -Methode in Matplotlib wird verwendet, um Doppelachsen herzustellen. Schauen wir uns eine Instanz an, in der sich doppelte Y-Achsen gebildet haben:

Matplotlib importieren.Pyplot als PLT
Numph als NP importieren
x = np.Arange (5, 20, 1.5)
D1 = NP.Sünde (x)
D2 = NP.cos (x)
Abb, CX1 = PLT.Nebenhandlungen ()
CX1.set_xlabel ('x')
CX1.set_ylabel ('y1', color = 'schwarz')
CX1.Diagramm (x, d1, color = 'schwarz')
CX1.tick_params (axis = 'y', labelColor = 'schwarz')
dx2 = cx1.Twinx ()
DX2.set_ylabel ('y2', color = 'Magenta')
DX2.Diagramm (X, D2, Color = 'Magenta')
DX2.tick_params (axis = 'y', labelColor = 'Magenta')
PLT.zeigen()

Wir integrieren die Bibliotheken Matplotlib.Pyplot so PLT und Numpy wie NP zu Beginn des Code. Wir haben die Funktion arrang () verwendet, um die Datenpunkte anzugeben. Wir erstellen zwei Variablen, um die Datensätze zu speichern. Um das Diagramm zu erstellen, verwenden wir die PLT.subplots () Funktion. Hier haben wir auch den Titel der X-Achse und der Y-Achse angegeben, indem wir set_xlabel () und set_ylabel () aufrufen.

Wir können die Farbe des Etiketts der y-Achse einstellen, indem wir den Parameter "Farbe" übergeben. Wir wenden den CX1 an.set () Funktion zum Übergeben der Datensätze der y-Achse. In ähnlicher Weise können wir die Farbe dieser Datenpunkte anpassen. Die Funktion tick_params () wird verwendet, um die Zeile zu zeichnen. Es enthält die Farbe der Linie. Darüber hinaus zeichnen wir die Datensätze in der X-Achse und der zweiten y-Achse mit Hilfe der Plot () -Funktion.

Jetzt wird die Funktion twinx () angewendet, um eine doppelte y-Achse zu erzeugen. Jetzt setzen wir das Etikett und die Farbe der y-Achse der zweiten Zeile. Also nennen wir den DX2.set_ylabel () Funktion. Die Farbe der Datenpunkte der zweiten Zeile der y-Achse wird durch den DX2 definiert.Plot () Methode. Wir beschäftigen die PLT.show () Funktion im letzten, um die Handlung zu zeigen.

Matplotlib Dual Y-Achse mit denselben Daten:

Hier werden wir diskutieren, wie Sie die Funktion Plot () mit der Funktion von Twinx () anwenden können, um Twin Y-Achse zu erstellen und sie mit identischen Daten zu visualisieren: Matplotlib importieren.Pyplot als PLT.

Numph als NP importieren
a = np.Arange (300)
B = NP.Sünde (a)
Abb, CX1 = PLT.Nebenhandlungen ()
CX1.Grundstück (a, b)
CX1.set_xlabel ('x')
CX1.set_ylabel ('y1')
dx2 = cx1.Twinx ()
DX2.set_ylabel ('y2')
PLT.zeigen()

Nachdem wir die Bibliotheken eingefügt haben, müssen wir die Datensätze mit den Methoden Numpy () und sin () definieren. Wir definieren ein Objekt und verwenden dann die Funktion subplots (), um ein Diagramm zu zeichnen. Darüber hinaus werden die Beschriftungen der X-Achse und einer y-Achse unter Verwendung der Funktion set_label () angegeben.

Wir erstellen zwei Achsen, also nennen wir die Twinx () -Methode. Abgesehen davon definieren wir das Etikett einer anderen Y-Achse und am Ende des Programms zeigen wir den Diagramm mit der PLT an.show () Methode.

Abschluss:

In diesem Tutorial haben wir die Matplotlib Twinx () -Methode mit ihren Beispielen besprochen. Diese Funktion erstellt eine doppelte Y-Achse, die eine ähnliche X-Achse teilt. Wir verwenden diese Funktion, indem wir verschiedene Ansätze verwenden.