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.