Matplotlib Grid

Matplotlib verwendet das Wort „Grid" in zwei unterschiedlichen Bedeutungen: mehrteilige Grid-Layouts (mehrere Achsen nebeneinander in einer Figure anordnen) und Hintergrundgitterlinien (Referenzlinien, die hinter den Daten auf einer einzelnen Achse gezeichnet werden). Dieses Kapitel behandelt beide Aspekte, beginnend mit Layout-Grids und abschließend mit dem Styling von Gitterlinien.

Sie sollten bereits mit dem grundlegenden Plotten vertraut sein — falls nicht, lesen Sie zuerst die Kapitel Matplotlib Plotting und Matplotlib Subplot.

Mehrteilige Grid-Layouts

Wenn Sie mehrere zusammengehörige Diagramme in einer Figure anzeigen möchten, ordnen Sie sie in einem Raster aus Zeilen und Spalten an. Matplotlib bietet drei Ansätze, die sich für unterschiedliche Komplexitätsstufen eignen.

plt.subplots() — der schnelle Weg

plt.subplots(nrows, ncols) ist der schnellste Weg für gleichmäßige Raster, bei denen jeder Subplot die gleiche Größe hat. Die Funktion gibt eine Figure und ein NumPy-Array von Axes zurück.

import matplotlib.pyplot as plt

# 2-row, 2-column grid — four equal subplots
fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(8, 6))

axs[0, 0].plot([1, 2, 3], [4, 5, 6])
axs[0, 0].set_title("Line plot")

axs[0, 1].scatter([1, 2, 3], [4, 5, 6])
axs[0, 1].set_title("Scatter plot")

axs[1, 0].bar([1, 2, 3], [4, 5, 6])
axs[1, 0].set_title("Bar chart")

axs[1, 1].hist([1, 2, 3, 4, 5, 6], bins=3)
axs[1, 1].set_title("Histogram")

plt.tight_layout()
plt.show()

tight_layout() passt den Abstand automatisch an, sodass Titel und Achsenbeschriftungen sich nicht überlappen. Mit figsize=(width, height) in Zoll steuern Sie die Gesamtgröße der Figure.

Achsen gemeinsam nutzen

Wenn Diagramme dieselbe Skala verwenden, können Sie ihre Achsen verknüpfen, sodass das Zoomen einer Achse alle anderen ebenfalls zoomt:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 100)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(9, 3), sharey=True)

ax1.plot(x, np.sin(x))
ax1.set_title("sin(x)")

ax2.plot(x, np.cos(x))
ax2.set_title("cos(x)")

plt.tight_layout()
plt.show()

sharey=True verknüpft den y-Achsenbereich beider Subplots; sharex=True macht dasselbe für die x-Achse.

GridSpec — Zellen mit variabler Größe

GridSpec ermöglicht es, Zeilen und Spalten unterschiedliche Gewichtungen zuzuweisen, sodass manche Subplots höher oder breiter sein können als andere. Außerdem kann ein einzelner Subplot mehrere Zellen überspannen.

import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

fig = plt.figure(figsize=(9, 6))

# 2 rows, 3 columns; bottom row is twice as tall
gs = GridSpec(nrows=2, ncols=3, height_ratios=[1, 2], hspace=0.4, wspace=0.3)

ax_top_left   = fig.add_subplot(gs[0, 0])
ax_top_mid    = fig.add_subplot(gs[0, 1])
ax_top_right  = fig.add_subplot(gs[0, 2])
ax_bottom     = fig.add_subplot(gs[1, :])   # spans all three columns

ax_top_left.plot([0, 1, 2], [0, 1, 0])
ax_top_left.set_title("Top left")

ax_top_mid.bar([0, 1, 2], [3, 1, 4])
ax_top_mid.set_title("Top centre")

ax_top_right.scatter([0, 1, 2], [2, 7, 1])
ax_top_right.set_title("Top right")

ax_bottom.plot([0, 1, 2, 3, 4], [0, 1, 4, 9, 16], color="steelblue", linewidth=2)
ax_bottom.set_title("Bottom — full width")

plt.show()

Wichtige GridSpec-Argumente:

Das Slicing mit gs[row, col] funktioniert genauso wie bei NumPy: gs[1, :] überspannt alle Spalten; gs[:, 0] überspannt alle Zeilen in der ersten Spalte.

subplot_mosaic() — Layout aus einem String

Seit Matplotlib 3.3 ermöglicht subplot_mosaic(), das Layout mit einem String oder einer verschachtelten Liste zu beschreiben, die wie eine ASCII-Karte der Figure aussieht. Dies ist oft der lesbarste Ansatz für asymmetrische Layouts.

import matplotlib.pyplot as plt

layout = """
AB
CC
"""

fig, axes = plt.subplot_mosaic(layout, figsize=(8, 5))

axes["A"].set_title("Panel A")
axes["A"].plot([1, 2, 3], [3, 1, 2])

axes["B"].set_title("Panel B")
axes["B"].scatter([1, 2, 3], [2, 3, 1])

axes["C"].set_title("Panel C — full width")
axes["C"].bar(["x", "y", "z"], [5, 3, 7])

plt.tight_layout()
plt.show()

Jeder eindeutige Buchstabe im String wird zu einer Axes. Wiederholte Buchstaben in derselben Zeile oder Spalte lassen den Subplot über diese Zellen hinweg spannen. Das zurückgegebene axes-Dictionary ist nach Bezeichnung indiziert, sodass der Zugriff auf Panels per Name übersichtlicher ist als numerische Indizierung.

Abstände steuern: tight_layout vs. constrained_layout

Zwei integrierte Systeme regeln den automatischen Abstand:

• plt.tight_layout() — vor plt.show() aufrufen. Passt Subplot-Parameter an, damit Beschriftungen und Titel hineinpassen. Einfach und zuverlässig für die meisten Layouts.
• constrained_layout=True — an plt.subplots() oder plt.figure() übergeben. Löst beim Zeichnen ein Constraintsystem; verarbeitet Colorbars und Supertitel besser als tight_layout.

import matplotlib.pyplot as plt

# constrained_layout keeps the super-title from overlapping the subplots
fig, axs = plt.subplots(1, 2, figsize=(8, 3), constrained_layout=True)

fig.suptitle("Two plots with constrained_layout", fontsize=13)

axs[0].plot([1, 2, 3], [1, 4, 9])
axs[0].set_title("Subplot 1")

axs[1].plot([1, 2, 3], [9, 4, 1])
axs[1].set_title("Subplot 2")

plt.show()

Verwenden Sie nie beide gleichzeitig — sie widersprechen sich. constrained_layout ist die modernere Wahl.

Für manuelle Steuerung überschreibt fig.subplots_adjust(left, right, top, bottom, hspace, wspace) den automatischen Abstand vollständig.

Hintergrundgitterlinien

Auf einer einzelnen Achse zeichnet ax.grid() Referenzlinien an den Tick-Positionen. Diese unterscheiden sich vom oben beschriebenen Layout-Grid — es sind visuelle Hilfslinien, die hinter den gezeichneten Daten liegen.

Gitterlinien aktivieren

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(6, 4))

ax.plot([1, 2, 3, 4, 5], [2, 5, 3, 8, 6], marker="o")

# Enable gridlines on both axes
ax.grid(True)

ax.set_title("Plot with gridlines")
plt.tight_layout()
plt.show()

Gitterlinien gestalten

Übergeben Sie Schlüsselwortargumente an ax.grid(), um das Aussehen zu ändern:

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(6, 4))

ax.plot([1, 2, 3, 4, 5], [2, 5, 3, 8, 6], marker="o", color="steelblue")

ax.grid(
    True,
    which="major",      # "major", "minor", or "both"
    axis="both",        # "x", "y", or "both"
    color="gray",
    linestyle="--",
    linewidth=0.7,
    alpha=0.7,
)

ax.set_title("Styled gridlines")
plt.tight_layout()
plt.show()

Haupt- und Nebengitterlinien

Matplotlib unterscheidet Haupt-Ticks (die beschrifteten) von Neben-Ticks (unbeschriftete Unterteilungen). Sie können Gitterlinien auf beiden Ebenen anzeigen:

import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator

fig, ax = plt.subplots(figsize=(7, 4))

ax.plot([0, 1, 2, 3, 4, 5, 6], [0, 1, 4, 9, 16, 25, 36])

# Major gridlines every 1 unit, minor every 0.5
ax.xaxis.set_major_locator(MultipleLocator(1))
ax.xaxis.set_minor_locator(MultipleLocator(0.5))
ax.yaxis.set_major_locator(MultipleLocator(10))
ax.yaxis.set_minor_locator(MultipleLocator(5))

ax.grid(True, which="major", linestyle="-",  linewidth=0.8, color="gray",  alpha=0.6)
ax.grid(True, which="minor", linestyle=":",  linewidth=0.5, color="silver", alpha=0.5)

ax.set_title("Major and minor gridlines")
plt.tight_layout()
plt.show()

Nebenticks ohne Locator aktivieren

Wenn Sie Nebenticks einfach anzeigen möchten, ohne sie manuell zu platzieren:

ax.minorticks_on()
ax.grid(True, which="both")

Styling mit Matplotlib-Stylesheets

Gitterlinien werden auch durch Stylesheets gesteuert. Der Stil seaborn-v0_8-whitegrid aktiviert beispielsweise automatisch horizontale Gitterlinien:

import matplotlib.pyplot as plt

plt.style.use("seaborn-v0_8-whitegrid")

fig, ax = plt.subplots(figsize=(6, 4))
ax.plot([1, 2, 3, 4], [3, 7, 2, 9], marker="s")
ax.set_title("seaborn-v0_8-whitegrid style")
plt.tight_layout()
plt.show()

Führen Sie plt.style.available aus, um alle integrierten Stile aufzulisten.

Den richtigen Ansatz wählen

Verwandte Kapitel

• Matplotlib Subplot — tieferer Einblick in plt.subplots() und Axes-Objekte
• Matplotlib Labels — Titel, Achsenbeschriftungen und Anmerkungen hinzufügen
• Matplotlib Plotting — Liniendiagramme, Balkendiagramme und Kreisdiagramme
• Matplotlib Scatter — Streudiagramme und Marker-Anpassung