Erstellen mehrerer Subplots mit plt.subplots

pyplot.subplotserstellt mit einem einzigen Aufruf eine Figur und ein Raster von Subplots und bietet gleichzeitig eine angemessene Kontrolle darüber, wie die einzelnen Plots erstellt werden. Für fortgeschrittenere Anwendungsfälle können Sie GridSpecfür ein allgemeineres Subplot-Layout oder Figure.add_subplotzum Hinzufügen von Subplots an beliebigen Stellen innerhalb der Abbildung verwenden.

import matplotlib.pyplot as plt
import numpy as np

# Some example data to display
x = np.linspace(0, 2 * np.pi, 400)
y = np.sin(x ** 2)

Eine Figur mit nur einer Nebenhandlung

subplots()ohne Argumente gibt a Figureund ein einzelnes zurück Axes.

Dies ist tatsächlich die einfachste und empfohlene Methode, um eine einzelne Figur und Achsen zu erstellen.

fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title('A single plot')

Text(0.5, 1.0, 'A single plot')

Nebenhandlungen in eine Richtung stapeln

Die ersten beiden optionalen Argumente von pyplot.subplotsdefinieren die Anzahl der Zeilen und Spalten des Subplot-Rasters.

Wenn nur in eine Richtung gestapelt wird, ist das zurückgegebene axsein 1D-numpy-Array, das die Liste der erstellten Achsen enthält.

fig, axs = plt.subplots(2)
fig.suptitle('Vertically stacked subplots')
axs[0].plot(x, y)
axs[1].plot(x, -y)

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

Wenn Sie nur wenige Achsen erstellen, ist es praktisch, sie sofort in dedizierte Variablen für jede Achse zu entpacken. Auf diese Weise können wir ax1anstelle des ausführlicheren verwenden axs[0].

fig, (ax1, ax2) = plt.subplots(2)
fig.suptitle('Vertically stacked subplots')
ax1.plot(x, y)
ax2.plot(x, -y)

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

Um Nebendiagramme nebeneinander zu erhalten, übergeben Sie Parameter für eine Zeile und zwei Spalten.1, 2

fig, (ax1, ax2) = plt.subplots(1, 2)
fig.suptitle('Horizontally stacked subplots')
ax1.plot(x, y)
ax2.plot(x, -y)

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

Nebenhandlungen in zwei Richtungen stapeln

Beim Stapeln in zwei Richtungen axswird ein 2D-NumPy-Array zurückgegeben.

Wenn Sie Parameter für jeden Teilplot einstellen müssen, ist es praktisch, mit über alle Teilplots in einem 2D-Gitter zu iterieren .for ax in axs.flat:

fig, axs = plt.subplots(2, 2)
axs[0, 0].plot(x, y)
axs[0, 0].set_title('Axis [0, 0]')
axs[0, 1].plot(x, y, 'tab:orange')
axs[0, 1].set_title('Axis [0, 1]')
axs[1, 0].plot(x, -y, 'tab:green')
axs[1, 0].set_title('Axis [1, 0]')
axs[1, 1].plot(x, -y, 'tab:red')
axs[1, 1].set_title('Axis [1, 1]')

for ax in axs.flat:
    ax.set(xlabel='x-label', ylabel='y-label')

# Hide x labels and tick labels for top plots and y ticks for right plots.
for ax in axs.flat:
    ax.label_outer()

Sie können Tuple-Unpacking auch in 2D verwenden, um alle Subplots dedizierten Variablen zuzuweisen:

fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)
fig.suptitle('Sharing x per column, y per row')
ax1.plot(x, y)
ax2.plot(x, y**2, 'tab:orange')
ax3.plot(x, -y, 'tab:green')
ax4.plot(x, -y**2, 'tab:red')

for ax in fig.get_axes():
    ax.label_outer()

Gemeinsame Achsen

Standardmäßig wird jede Achse einzeln skaliert. Wenn die Bereiche unterschiedlich sind, stimmen die Tick-Werte der Subplots also nicht überein.

fig, (ax1, ax2) = plt.subplots(2)
fig.suptitle('Axes values are scaled individually by default')
ax1.plot(x, y)
ax2.plot(x + 1, -y)

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

Sie können Sharex oder Sharey verwenden , um die horizontale oder vertikale Achse auszurichten.

fig, (ax1, ax2) = plt.subplots(2, sharex=True)
fig.suptitle('Aligning x-axis using sharex')
ax1.plot(x, y)
ax2.plot(x + 1, -y)

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

Die Einstellung von sharex oder sharey auf Trueermöglicht die globale gemeinsame Nutzung über das gesamte Grid, dh auch die y-Achsen vertikal gestapelter Subplots haben bei Verwendung von den gleichen Maßstab sharey=True.

fig, axs = plt.subplots(3, sharex=True, sharey=True)
fig.suptitle('Sharing both axes')
axs[0].plot(x, y ** 2)
axs[1].plot(x, 0.3 * y, 'o')
axs[2].plot(x, y, '+')

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

Für Teilplots mit gemeinsamen Achsen reicht ein Satz Tick-Labels aus. Tick-Labels innerer Achsen werden automatisch von sharex und sharey entfernt . Dennoch bleibt zwischen den Teilparzellen eine ungenutzte Leerstelle.

Um die Positionierung der Subplots genau zu steuern, kann man explizit eine GridSpecmit erstellen Figure.add_gridspecund dann ihre subplotsMethode aufrufen. Zum Beispiel können wir die Höhe zwischen vertikalen Subplots mit reduzieren add_gridspec(hspace=0).

label_outerist eine praktische Methode, um Beschriftungen und Häkchen von Teilplots zu entfernen, die sich nicht am Rand des Rasters befinden.

fig = plt.figure()
gs = fig.add_gridspec(3, hspace=0)
axs = gs.subplots(sharex=True, sharey=True)
fig.suptitle('Sharing both axes')
axs[0].plot(x, y ** 2)
axs[1].plot(x, 0.3 * y, 'o')
axs[2].plot(x, y, '+')

# Hide x labels and tick labels for all but bottom plot.
for ax in axs:
    ax.label_outer()

Abgesehen von Trueund akzeptieren Falsesowohl sharex als auch sharey die Werte 'row' und 'col', um die Werte nur pro Zeile oder Spalte zu teilen.

fig = plt.figure()
gs = fig.add_gridspec(2, 2, hspace=0, wspace=0)
(ax1, ax2), (ax3, ax4) = gs.subplots(sharex='col', sharey='row')
fig.suptitle('Sharing x per column, y per row')
ax1.plot(x, y)
ax2.plot(x, y**2, 'tab:orange')
ax3.plot(x + 1, -y, 'tab:green')
ax4.plot(x + 2, -y**2, 'tab:red')

for ax in axs.flat:
    ax.label_outer()

Wenn Sie eine komplexere Freigabestruktur wünschen, können Sie zuerst das Achsenraster ohne Freigabe erstellen und dann aufrufen axes.Axes.sharexoder axes.Axes.shareydie Freigabeinformationen a posteriori hinzufügen.

fig, axs = plt.subplots(2, 2)
axs[0, 0].plot(x, y)
axs[0, 0].set_title("main")
axs[1, 0].plot(x, y**2)
axs[1, 0].set_title("shares x with main")
axs[1, 0].sharex(axs[0, 0])
axs[0, 1].plot(x + 1, y + 1)
axs[0, 1].set_title("unrelated")
axs[1, 1].plot(x + 2, y + 2)
axs[1, 1].set_title("also unrelated")
fig.tight_layout()

Polarachsen

Der Parameter subplot_kw von pyplot.subplotssteuert die Subplot-Eigenschaften (siehe auch Figure.add_subplot). Insbesondere kann dies verwendet werden, um ein Gitter aus polaren Achsen zu erstellen.

fig, (ax1, ax2) = plt.subplots(1, 2, subplot_kw=dict(projection='polar'))
ax1.plot(x, y)
ax2.plot(x, y ** 2)

plt.show()