Matplotlib Tick-Locatoren

Einführung

In diesem Tutorial lernen wir, wie wir die Position der Striche in einem matplotlib-Graphen mithilfe von Tick-Locatoren definieren. Tick-Locatoren helfen, Graphen lesbarer zu machen, indem sie die Position der Striche auf den x- und y-Achsen definieren. Wir werden verschiedene Arten von Tick-Locatoren behandeln und zeigen, wie sie in einem matplotlib-Graphen implementiert werden.

Tipps für die VM

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 öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in 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 prompt beheben.

Bibliotheken importieren

Der erste Schritt besteht darin, die erforderlichen Bibliotheken zu importieren. Wir werden matplotlib.pyplot und matplotlib.ticker verwenden.

import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import numpy as np

Das Diagramm einrichten

Als nächstes werden wir das Diagramm einrichten, indem wir eine Figur und ein Array von Teildiagrammen erstellen. Wir definieren auch eine setup-Funktion, die die gemeinsamen Parameter für die Achsen im Beispiel einstellt.

fig, axs = plt.subplots(8, 1, figsize=(8, 6))

def setup(ax, title):
    """Set up common parameters for the Axes in the example."""
    ## only show the bottom spine
    ax.yaxis.set_major_locator(ticker.NullLocator())
    ax.spines[['left', 'right', 'top']].set_visible(False)

    ax.xaxis.set_ticks_position('bottom')
    ax.tick_params(which='major', width=1.00, length=5)
    ax.tick_params(which='minor', width=0.75, length=2.5)
    ax.set_xlim(0, 5)
    ax.set_ylim(0, 1)
    ax.text(0.0, 0.2, title, transform=ax.transAxes,
            fontsize=14, fontname='Monospace', color='tab:blue')

Den Null-Locator definieren

Der Null-Locator ist ein Locator, der keine Striche auf der Achse platziert. Wir können den Null-Locator mit ticker.NullLocator() definieren.

setup(axs[0], title="NullLocator()")
axs[0].xaxis.set_major_locator(ticker.NullLocator())
axs[0].xaxis.set_minor_locator(ticker.NullLocator())

Den Multiple-Locator definieren

Der Multiple-Locator ist ein Locator, der Striche in regelmäßigen Abständen platziert. Wir können den Multiple-Locator mit ticker.MultipleLocator() definieren.

setup(axs[1], title="MultipleLocator(0.5, offset=0.2)")
axs[1].xaxis.set_major_locator(ticker.MultipleLocator(0.5, offset=0.2))
axs[1].xaxis.set_minor_locator(ticker.MultipleLocator(0.1))

Den Fixed-Locator definieren

Der Fixed-Locator ist ein Locator, der Striche an festen Positionen platziert. Wir können den Fixed-Locator mit ticker.FixedLocator() definieren.

setup(axs[2], title="FixedLocator([0, 1, 5])")
axs[2].xaxis.set_major_locator(ticker.FixedLocator([0, 1, 5]))
axs[2].xaxis.set_minor_locator(ticker.FixedLocator(np.linspace(0.2, 0.8, 4)))

Den Linear-Locator definieren

Der Linear-Locator ist ein Locator, der Striche in regelmäßigen Abständen auf einer linearen Skala platziert. Wir können den Linear-Locator mit ticker.LinearLocator() definieren.

setup(axs[3], title="LinearLocator(numticks=3)")
axs[3].xaxis.set_major_locator(ticker.LinearLocator(3))
axs[3].xaxis.set_minor_locator(ticker.LinearLocator(31))

Den Index-Locator definieren

Der Index-Locator ist ein Locator, der Striche in regelmäßigen Abständen auf einer Indexskala platziert. Wir können den Index-Locator mit ticker.IndexLocator() definieren.

setup(axs[4], title="IndexLocator(base=0.5, offset=0.25)")
axs[4].plot([0]*5, color='white')
axs[4].xaxis.set_major_locator(ticker.IndexLocator(base=0.5, offset=0.25))

Den Auto-Locator definieren

Der Auto-Locator ist ein Locator, der automatisch Striche in regelmäßigen Abständen platziert. Wir können den Auto-Locator mit ticker.AutoLocator() definieren.

setup(axs[5], title="AutoLocator()")
axs[5].xaxis.set_major_locator(ticker.AutoLocator())
axs[5].xaxis.set_minor_locator(ticker.AutoMinorLocator())

Den MaxN-Locator definieren

Der MaxN-Locator ist ein Locator, der eine maximale Anzahl von Strichen auf der Achse platziert. Wir können den MaxN-Locator mit ticker.MaxNLocator() definieren.

setup(axs[6], title="MaxNLocator(n=4)")
axs[6].xaxis.set_major_locator(ticker.MaxNLocator(4))
axs[6].xaxis.set_minor_locator(ticker.MaxNLocator(40))

Den Log-Locator definieren

Der Log-Locator ist ein Locator, der Striche in regelmäßigen Abständen auf einer logarithmischen Skala platziert. Wir können den Log-Locator mit ticker.LogLocator() definieren.

setup(axs[7], title="LogLocator(base=10, numticks=15)")
axs[7].set_xlim(10**3, 10**10)
axs[7].set_xscale('log')
axs[7].xaxis.set_major_locator(ticker.LogLocator(base=10, numticks=15))

Anzeigen des Diagramms

Schließlich können wir das Diagramm mit plt.show() anzeigen.

plt.tight_layout()
plt.show()

Zusammenfassung

In diesem Tutorial haben wir gelernt, wie man die Position von Strichen in einem matplotlib-Diagramm mit Hilfe von Tick-Locatoren definiert. Wir haben verschiedene Arten von Tick-Locatoren behandelt und gezeigt, wie man sie in einem matplotlib-Diagramm implementiert. Dies kann dazu beitragen, Diagramme lesbarer und informativer zu gestalten.