Matplotlib sekundäre Achse

Einführung

Matplotlib ist eine beliebte Datenvisualisierungsbibliothek in Python. Manchmal müssen wir zwei verschiedene Skalen von Daten auf einem Diagramm darstellen, und genau hier kommt das Konzept der Sekundärachse ins Spiel. In diesem Lab werden wir lernen, wie man in Matplotlib eine Sekundärachse erstellt.

VM-Tipps

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen von Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie sofort beheben.

Importieren der erforderlichen Bibliotheken

Wir beginnen mit dem Importieren der erforderlichen Bibliotheken, nämlich matplotlib, numpy und datetime.

import datetime
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.dates as mdates
from matplotlib.ticker import AutoMinorLocator

Zeichnen der Daten

Wir werden eine einfache Sinuswelle erstellen, um die Verwendung einer Sekundärachse zu demonstrieren. Wir werden die Sinuswelle mit Grad als x-Achse zeichnen.

fig, ax = plt.subplots(layout='constrained')
x = np.arange(0, 360, 1)
y = np.sin(2 * x * np.pi / 180)
ax.plot(x, y)
ax.set_xlabel('angle [degrees]')
ax.set_ylabel('signal')
ax.set_title('Sine wave')

Erstellen der Sekundärachse

Wir werden jetzt die Sekundärachse erstellen und die x-Achse von Grad in Radiant umwandeln. Wir werden deg2rad als die Vorwärtsfunktion und rad2deg als die Umkehrfunktion verwenden.

def deg2rad(x):
    return x * np.pi / 180

def rad2deg(x):
    return x * 180 / np.pi

secax = ax.secondary_xaxis('top', functions=(deg2rad, rad2deg))
secax.set_xlabel('angle [rad]')

Zeichnen eines weiteren Beispiels

Wir werden jetzt ein weiteres Beispiel zeichnen, bei dem die Umrechnung von Wellenzahl in Wellenlänge in einem doppelt-logarithmischen Maßstab erfolgt. Für dieses Beispiel werden wir ein zufälliges Spektrum verwenden.

fig, ax = plt.subplots(layout='constrained')
x = np.arange(0.02, 1, 0.02)
np.random.seed(19680801)
y = np.random.randn(len(x)) ** 2
ax.loglog(x, y)
ax.set_xlabel('f [Hz]')
ax.set_ylabel('PSD')
ax.set_title('Random spectrum')

Erstellen der sekundären X-Achse

Wir werden die sekundäre X-Achse erstellen und die Umrechnung von Frequenz in Periode durchführen. Wir werden one_over als die Vorwärtsfunktion und inverse als die Umkehrfunktion verwenden.

def one_over(x):
    """Vektorisiertes 1/x, wobei x==0 manuell behandelt wird"""
    x = np.array(x, float)
    near_zero = np.isclose(x, 0)
    x[near_zero] = np.inf
    x[~near_zero] = 1 / x[~near_zero]
    return x

## die Funktion "1/x" ist ihre eigene Umkehrfunktion
inverse = one_over

secax = ax.secondary_xaxis('top', functions=(one_over, inverse))
secax.set_xlabel('period [s]')

Erstellen der sekundären Y-Achse

Wir werden ein drittes Beispiel erstellen, bei dem die Achsen in einer Transformierung zusammenhängen, die von den Daten ad-hoc und empirisch abgeleitet ist. In diesem Fall werden wir die Vorwärts- und Umkehrtransformationsfunktionen als lineare Interpolation von einem Datensatz zu einem anderen festlegen.

fig, ax = plt.subplots(layout='constrained')
xdata = np.arange(1, 11, 0.4)
ydata = np.random.randn(len(xdata))
ax.plot(xdata, ydata, label='Plotted data')

xold = np.arange(0, 11, 0.2)
## gefälschter Datensatz, der die x-Koordinate mit einer anderen datenabgeleiteten Koordinate in Verbindung bringt.
## xnew muss monoton sein, also sortieren wir...
xnew = np.sort(10 * np.exp(-xold / 4) + np.random.randn(len(xold)) / 3)

ax.plot(xold[3:], xnew[3:], label='Transform data')
ax.set_xlabel('X [m]')
ax.legend()

def forward(x):
    return np.interp(x, xold, xnew)

def inverse(x):
    return np.interp(x, xnew, xold)

secax = ax.secondary_xaxis('top', functions=(forward, inverse))
secax.xaxis.set_minor_locator(AutoMinorLocator())
secax.set_xlabel('$X_{other}$')

Erstellen mehrerer Achsen

Wir werden jetzt ein letztes Beispiel erstellen, bei dem np.datetime64 auf der x-Achse in das Jahrstag und auf der y-Achse von Celsius in Fahrenheit umgewandelt wird. Wir werden auch eine dritte y-Achse hinzufügen und sie anhand eines Floats für das Positionsargument platzieren.

dates = [datetime.datetime(2018, 1, 1) + datetime.timedelta(hours=k * 6)
         for k in range(240)]
temperature = np.random.randn(len(dates)) * 4 + 6.7
fig, ax = plt.subplots(layout='constrained')

ax.plot(dates, temperature)
ax.set_ylabel(r'$T\ [^oC]$')
plt.xticks(rotation=70)

def date2yday(x):
    """Konvertiert matplotlib datenum in Tage seit 2018-01-01."""
    y = x - mdates.date2num(datetime.datetime(2018, 1, 1))
    return y

def yday2date(x):
    """Gibt ein matplotlib datenum für *x* Tage nach 2018-01-01 zurück."""
    y = x + mdates.date2num(datetime.datetime(2018, 1, 1))
    return y

secax_x = ax.secondary_xaxis('top', functions=(date2yday, yday2date))
secax_x.set_xlabel('yday [2018]')

def celsius_to_fahrenheit(x):
    return x * 1.8 + 32

def fahrenheit_to_celsius(x):
    return (x - 32) / 1.8

secax_y = ax.secondary_yaxis(
    'right', functions=(celsius_to_fahrenheit, fahrenheit_to_celsius))
secax_y.set_ylabel(r'$T\ [^oF]$')

def celsius_to_anomaly(x):
    return (x - np.mean(temperature))

def anomaly_to_celsius(x):
    return (x + np.mean(temperature))

## Verwendung eines Floats für die Position:
secax_y2 = ax.secondary_yaxis(
    1.2, functions=(celsius_to_anomaly, anomaly_to_celsius))
secax_y2.set_ylabel(r'$T - \overline{T}\ [^oC]$')

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Matplotlib eine sekundäre Achse erstellt. Wir haben verschiedene Beispiele verwendet, um das Konzept einer sekundären Achse und wie man sie erstellt, zu demonstrieren.