Automatische Skalierung

Die Grenzwerte für eine Achse können manuell festgelegt werden (z. B. ) oder Matplotlib kann sie automatisch basierend auf den Daten festlegen, die bereits auf den Achsen vorhanden sind. Es gibt eine Reihe von Optionen für dieses Autoscaling-Verhalten, die unten erläutert werden.ax.set_xlim(xmin, xmax)

Wir beginnen mit einem einfachen Liniendiagramm, das zeigt, dass die Autoskalierung die Achsengrenzen um 5 % über die Datengrenzen hinaus erweitert (-2π, 2π).

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

x = np.linspace(-2 * np.pi, 2 * np.pi, 100)
y = np.sinc(x)

fig, ax = plt.subplots()
ax.plot(x, y)

[<matplotlib.lines.Line2D object at 0x7f2cde5343a0>]

Ränder

Die Standardspanne um die Datenlimits beträgt 5 %:

ax.margins()

(0.05, 0.05)

Die Ränder können größer gemacht werden mit margins:

fig, ax = plt.subplots()
ax.plot(x, y)
ax.margins(0.2, 0.2)

Im Allgemeinen können Ränder im Bereich (-0,5, ∞) liegen, wobei negative Ränder die Achsengrenzen auf einen Unterbereich des Datenbereichs setzen, dh sie beschneiden Daten. Die Verwendung einer einzelnen Zahl für Ränder wirkt sich auf beide Achsen aus, ein einzelner Rand kann mit Schlüsselwortargumenten xoder angepasst werden y, aber Positions- und Schlüsselwortschnittstelle können nicht kombiniert werden.

fig, ax = plt.subplots()
ax.plot(x, y)
ax.margins(y=-0.2)

Klebrige Kanten

Es gibt Plot-Elemente ( Artiste), die normalerweise ohne Ränder verwendet werden. Beispielsweise werden Falschfarbenbilder (zB erstellt mit Axes.imshow) bei der Randberechnung nicht berücksichtigt.

xx, yy = np.meshgrid(x, x)
zz = np.sinc(np.sqrt((xx - 1)**2 + (yy - 1)**2))

fig, ax = plt.subplots(ncols=2, figsize=(12, 8))
ax[0].imshow(zz)
ax[0].set_title("default margins")
ax[1].imshow(zz)
ax[1].margins(0.2)
ax[1].set_title("margins(0.2)")

Text(0.5, 1.0, 'margins(0.2)')

Diese Überschreibung von Rändern wird durch "klebrige Kanten" bestimmt, eine Eigenschaft der ArtistKlasse, die das Hinzufügen von Rändern zu Achsengrenzen unterdrücken kann. Der Effekt von klebrigen Kanten kann bei Axes durch Ändern von deaktiviert werden use_sticky_edges. Künstler haben eine Eigenschaft Artist.sticky_edges, und die Werte von Sticky Edges können durch Schreiben in Artist.sticky_edges.xoder geändert werden Artist.sticky_edges.y.

Das folgende Beispiel zeigt, wie das Überschreiben funktioniert und wann es erforderlich ist.

fig, ax = plt.subplots(ncols=3, figsize=(16, 10))
ax[0].imshow(zz)
ax[0].margins(0.2)
ax[0].set_title("default use_sticky_edges\nmargins(0.2)")
ax[1].imshow(zz)
ax[1].margins(0.2)
ax[1].use_sticky_edges = False
ax[1].set_title("use_sticky_edges=False\nmargins(0.2)")
ax[2].imshow(zz)
ax[2].margins(-0.2)
ax[2].set_title("default use_sticky_edges\nmargins(-0.2)")

Text(0.5, 1.0, 'default use_sticky_edges\nmargins(-0.2)')

Wir können sehen, dass die Einstellung use_sticky_edgesauf False das Bild mit den angeforderten Rändern rendert.

Während Sticky Edges die Achsengrenzen nicht durch zusätzliche Ränder erhöhen, werden negative Ränder dennoch berücksichtigt. Dies ist in den reduzierten Grenzen des dritten Bildes zu sehen.

Autoscale steuern

Standardmäßig werden die Grenzwerte jedes Mal neu berechnet, wenn Sie dem Diagramm eine neue Kurve hinzufügen:

fig, ax = plt.subplots(ncols=2, figsize=(12, 8))
ax[0].plot(x, y)
ax[0].set_title("Single curve")
ax[1].plot(x, y)
ax[1].plot(x * 2.0, y)
ax[1].set_title("Two curves")

Text(0.5, 1.0, 'Two curves')

Es gibt jedoch Fälle, in denen Sie den Darstellungsbereich nicht automatisch an neue Daten anpassen möchten.

Eine Möglichkeit, die automatische Skalierung zu deaktivieren, besteht darin, die Achsenbegrenzung manuell festzulegen. Nehmen wir an, wir möchten nur einen Teil der Daten detaillierter sehen. Das Festlegen xlimbleibt auch dann bestehen, wenn wir den Daten weitere Kurven hinzufügen. Um die neuen Limits neu zu berechnen, Axes.autoscalewird die Funktionalität manuell umgeschaltet.

fig, ax = plt.subplots(ncols=2, figsize=(12, 8))
ax[0].plot(x, y)
ax[0].set_xlim(left=-1, right=1)
ax[0].plot(x + np.pi * 0.5, y)
ax[0].set_title("set_xlim(left=-1, right=1)\n")
ax[1].plot(x, y)
ax[1].set_xlim(left=-1, right=1)
ax[1].plot(x + np.pi * 0.5, y)
ax[1].autoscale()
ax[1].set_title("set_xlim(left=-1, right=1)\nautoscale()")

Text(0.5, 1.0, 'set_xlim(left=-1, right=1)\nautoscale()')

Wir können überprüfen, ob beim ersten Plot die automatische Skalierung deaktiviert und beim zweiten Plot wieder aktiviert ist, indem wir Folgendes verwenden Axes.get_autoscale_on():

print(ax[0].get_autoscale_on())  # False means disabled
print(ax[1].get_autoscale_on())  # True means enabled -> recalculated

False
True

Argumente der Autoscale-Funktion geben uns eine präzise Kontrolle über den Prozess der Autoskalierung. Eine Kombination aus Argumenten enable, und axislegt die automatische Skalierungsfunktion für die ausgewählte Achse (oder beide) fest. Das Argument tight setzt den Rand der ausgewählten Achse auf Null. Um die Einstellungen von entweder enableoder beizubehalten, tightkönnen Sie das Gegenteil auf None setzen, auf diese Weise sollte es nicht geändert werden. Die Einstellung enableauf None und fest auf True wirkt sich jedoch unabhängig vom axisArgument auf beide Achsen aus.

fig, ax = plt.subplots()
ax.plot(x, y)
ax.margins(0.2, 0.2)
ax.autoscale(enable=None, axis="x", tight=True)

print(ax.margins())

(0, 0)

Mit Sammlungen arbeiten

Die automatische Skalierung funktioniert sofort nach dem Auspacken für alle Linien, Patches und Bilder, die den Achsen hinzugefügt werden. Einer der Künstler, mit denen es nicht funktioniert, ist ein Collection. Nach dem Hinzufügen einer Sammlung zu den Achsen muss manuell ausgelöst werden, um die autoscale_view()Achsengrenzen neu zu berechnen.

fig, ax = plt.subplots()
collection = mpl.collections.StarPolygonCollection(
    5, rotation=0, sizes=(250,),  # five point star, zero angle, size 250px
    offsets=np.column_stack([x, y]),  # Set the positions
    offset_transform=ax.transData,  # Propagate transformations of the Axes
)
ax.add_collection(collection)
ax.autoscale_view()