Wie werden logarithmische Achsen in Matplotlib gezeichnet

Mit set_xscale() oder set_yscale() lässt sich die Skalierung jeder Achse unabhängig festlegen. Für logarithmische Skalen auf beiden Achsen verwenden Sie loglog(). Die Hilfsfunktionen semilogx() und semilogy() wenden jeweils eine logarithmische Skala auf die x- beziehungsweise y-Achse an. Eine logarithmische Achse setzt ihre Teilstriche in Zehnerpotenzen, sodass Daten über mehrere Größenordnungen lesbar bleiben, statt sich im untersten Bereich einer linearen Achse zu drängen.
Alle Codebeispiele unten wurden erfolgreich ausgeführt.

Funktionen set_xscale() oder set_yscale()

Rufen Sie set_xscale("log") auf, um die x-Achse logarithmisch zu skalieren, und set_yscale("log") für die y-Achse. Mit beiden Aufrufen werden beide Achsen logarithmisch skaliert. Da die beiden Aufrufe unabhängig voneinander sind, können Sie genau eine Achse umstellen und die andere linear lassen.

Um nur die x-Achse logarithmisch zu skalieren, zeichnen Sie die Daten wie gewohnt und rufen dann set_xscale("log") für die Achsen auf:

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

fig, ax = plt.subplots()
ax.plot(x, y, marker="o")
ax.set_xscale("log")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Die Ausgabe bestätigt, dass sich nur die x-Achse geändert hat: x-axis: log, y-axis: linear. Die Dekaden-Markierungen bei 1, 10, 100 und 1000 sind gleichmäßig verteilt, obwohl die Werte selbst jeweils um den Faktor zehn wachsen.

Um nur die y-Achse logarithmisch zu skalieren, rufen Sie stattdessen set_yscale("log") auf und lassen die x-Achse unverändert:

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

fig, ax = plt.subplots()
ax.plot(x, y, marker="o")
ax.set_yscale("log")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Diesmal lautet die Ausgabe x-axis: linear, y-axis: log, und die y-Achse trägt die gleichmäßig verteilten Dekaden-Markierungen.

Die zustandsbasierte pyplot-Schnittstelle bietet dieselbe Änderung über die Funktionen plt.xscale() und plt.yscale() auf oberster Ebene, die auf die aktuellen Achsen wirken. Die yscale()-Variante desselben Diagramms sieht so aus:

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

plt.plot(x, y, marker="o")
plt.yscale("log")
plt.xlabel("x")
plt.ylabel("y")
ax = plt.gca()
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close()

Das Ergebnis ist dieselbe logarithmische y-Achse; die Methoden des Achsenobjekts sind in Programmen mit expliziter ax-Referenz meist klarer, weil die Zielachsen im Aufruf benannt werden, statt sich aus der aktuellen Figur zu ergeben.

Das vollständige Beispiel stellt positive numerische Daten dar und verwendet für beide Achsen eine logarithmische Skala.

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

fig, ax = plt.subplots()
ax.plot(x, y, marker="o")
ax.set_xscale("log")
ax.set_yscale("log")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Die Ausgabe meldet nun x-axis: log, y-axis: log, und gleiche Verhältnisse belegen auf beiden Achsen gleiche Abstände.

Eine normale log-Skala stellt positive Werte dar. Enthalten Ihre Daten auch negative Werte, verwenden Sie für die betreffende Achse symlog, zum Beispiel ax.set_yscale("symlog"); damit lassen sich Werte auf beiden Seiten von null darstellen. Der letzte Abschnitt greift diesen Fall mit einem verifizierten Beispiel wieder auf.

Funktionen semilogx() oder semilogy()

Verwenden Sie semilogx(), wenn die x-Achse logarithmisch und die y-Achse linear skaliert werden soll. Mit semilogy() erhalten Sie eine logarithmische y-Achse und eine lineare x-Achse. Beide Hilfsfunktionen übernehmen die x- und y-Daten als Argumente, sodass die gewählte Skalierung direkt im Plot-Aufruf festgelegt wird. Sollen beide Achsen logarithmisch skaliert werden, verwenden Sie loglog() oder kombinieren Sie semilogx() und semilogy() auf denselben Achsen.

Der folgende semilogx()-Aufruf zeichnet die Daten und setzt die logarithmische x-Achse in einem Schritt:

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

fig, ax = plt.subplots()
ax.semilogx(x, y, marker="o", label="logarithmic x")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.legend()
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Die Hilfsfunktion gibt die gezeichnete Linie zurück, und die Achsen melden danach x-axis: log, y-axis: linear — genau wie beim expliziten set_xscale("log")-Aufruf im ersten Abschnitt.

Die Kombination beider Hilfsfunktionen auf denselben Achsen ergibt eine logarithmische Skala auf beiden Achsen. Beachten Sie, dass eine Skala zu den Achsen gehört, nicht zu einer einzelnen gezeichneten Linie: Sobald semilogy() die y-Achse setzt, gilt diese Skala für jede Datenreihe der Achsen, auch für die zuvor von semilogx() gezeichnete.

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]
y2 = [3, 8, 30, 120]

fig, ax = plt.subplots()
ax.semilogx(x, y, marker="o", label="first series")
ax.semilogy(x, y2, marker="s", label="second series")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.legend()
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Beide Datenreihen landen auf logarithmischen x- und y-Achsen, und die Ausgabe bestätigt den Endzustand: x-axis: log, y-axis: log.

Funktion loglog()

Verwenden Sie loglog(), wenn beide Achsen logarithmisch skaliert werden sollen. Die Funktion stellt die übergebenen x- und y-Daten dar und setzt beide Achsen auf die normale logarithmische Skala. Hier ist ein vollständiges Beispiel mit positiven numerischen Werten:

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

fig, ax = plt.subplots()
ax.loglog(x, y, marker="o")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Das gerenderte Ergebnis entspricht der Kombination aus set_xscale("log") und set_yscale("log") aus dem ersten Abschnitt; loglog() faltet die Skalenwahl einfach in den Zeichenaufruf selbst.

Nicht-positive Werte und ungültige Skalennamen

Zwei Dinge überraschen Benutzer logarithmischer Achsen regelmäßig, und beide sollte man kennen, bevor man ein falsch aussehendes Diagramm debuggt. Erstens wird der Skalenname sofort validiert: Ein Tippfehler wie ax.set_yscale("logg") löst ValueError: 'logg' is not a valid value for scale. Did you mean one of: 'log', 'logit', 'symlog'? aus (Meldung wörtlich unter Matplotlib 3.11 erfasst). Der Fehler nennt die akzeptierten Werte, sodass ein Tippfehler sofort auffällt, statt stillschweigend eine lineare Achse zu erzeugen.

Zweitens kann eine logarithmische Skala null oder negative Werte nicht darstellen, und dieser Fall löst keinen Fehler aus. Matplotlib verwirft die nicht-positiven Punkte stillschweigend: Sie werden aus der Zeichnung ausgeblendet, Liniensegmente, die durch sie verlaufen würden, verschwinden, und die Achsengrenzen decken nur die positiven Werte ab. Das folgende Beispiel zeichnet y = [2, 0, -5, 80] auf einer logarithmischen y-Achse:

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 0, -5, 80]

fig, ax = plt.subplots()
ax.plot(x, y, marker="o")
ax.set_yscale("log")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Der Aufruf läuft normal durch und meldet y-axis: log, aber nur die Punkte bei y = 2 und y = 80 können erscheinen; im verifizierten Lauf lagen die resultierenden Grenzen der y-Achse bei etwa 1,66 bis 96,2 und umfassten nur die positiven Daten. Wenn eine Datenreihe nach dem Umstellen einer Achse auf log Punkte zu verlieren scheint, prüfen Sie die Daten auf Nullen und negative Werte, bevor Sie den Zeichen-Code verdächtigen.

Enthalten die Daten tatsächlich Werte mit Vorzeichen, ist die Skala symlog (symmetrischer Logarithmus) die geeignete Alternative: Sie wendet abseits von null eine logarithmische Skala und in einem kleinen Bereich um null eine lineare Skala an, sodass jeder Punkt sichtbar bleibt.

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 0, -5, 80]

fig, ax = plt.subplots()
ax.plot(x, y, marker="o")
ax.set_yscale("symlog")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Alle vier Punkte, einschließlich 0 und -5, werden auf der symlog-y-Achse dargestellt. Verwenden Sie sie immer dann, wenn das Vorzeichen der Werte eine Information trägt; behalten Sie die reine log-Skala für Daten, die von Natur aus positiv sind, etwa Anzahlen, Größen und physikalische Messwerte.