Matplotlib Cheat Sheet
Zuletzt aktualisiert
Figure und Axes
Eine Figure ist das ganze Bild. Ein Axes ist ein einzelner Plot darin, und fast jeder Aufruf unten ist eine Methode auf ax.
| Aufgabe | Code |
|---|---|
| pyplot importieren | import matplotlib.pyplot as plt |
| Eine Figure mit einem Plot | fig, ax = plt.subplots() |
| Größe in Zoll festlegen | fig, ax = plt.subplots(figsize=(8, 4)) |
| Auf die Axes zeichnen | ax.plot(x, y) |
| Figure anzeigen | plt.show() |
| Als scharfes PNG speichern | fig.savefig("chart.png", dpi=150, bbox_inches="tight") |
| Als Vektorgrafik speichern | fig.savefig("chart.svg"), fig.savefig("chart.pdf") |
| Transparenter Hintergrund | fig.savefig("chart.png", transparent=True) |
| Figure schließen, um Speicher freizugeben | plt.close(fig) |
| Schneller pyplot-Stil für ein Diagramm | plt.plot(x, y)
plt.title("Quick look")
plt.show() |
Plot-Typen
| Aufgabe | Code |
|---|---|
| Liniendiagramm | ax.plot(x, y) |
| Streudiagramm | ax.scatter(x, y, s=20, alpha=0.7) |
| Streudiagramm nach Wert eingefärbt, mit Farbskala | points = ax.scatter(x, y, c=y, cmap="viridis")
fig.colorbar(points, ax=ax) |
| Balkendiagramm | ax.bar(cats, a) |
| Horizontales Balkendiagramm | ax.barh(cats, a) |
| Gestapelte Balken | ax.bar(cats, a, label="2025")
ax.bar(cats, b, bottom=a, label="2026") |
| Gruppierte Balken | pos = np.arange(len(cats))
ax.bar(pos - 0.2, a, width=0.4)
ax.bar(pos + 0.2, b, width=0.4)
ax.set_xticks(pos, labels=cats) |
| Histogramm | ax.hist(data, bins=30) |
| Boxplot | ax.boxplot([data, data * 2], tick_labels=["A", "B"]) |
| Violinplot | ax.violinplot([data, data * 2]) |
| Kreisdiagramm | ax.pie([40, 35, 25], labels=cats, autopct="%1.0f%%") |
| Fläche zwischen zwei Kurven | ax.fill_between(x, y - 0.2, y + 0.2, alpha=0.3) |
| Fehlerbalken | ax.errorbar([1, 2, 3], [4, 5, 3], yerr=[0.5, 0.3, 0.6], fmt="o", capsize=4) |
| Stufendiagramm | ax.step(x, y, where="mid") |
| Heatmap eines 2D-Arrays | image = ax.imshow(np.random.default_rng(0).random((5, 5)), cmap="magma")
fig.colorbar(image, ax=ax) |
| Gefülltes Konturdiagramm | X, Y = np.meshgrid(x, x)
ax.contourf(X, Y, np.sin(X) * np.cos(Y), levels=20) |
| Dichte vieler Punkte | ax.hexbin(data, data + np.random.default_rng(1).normal(size=200), gridsize=20) |
| Horizontale oder vertikale Referenzlinie | ax.axhline(0, color="gray", linestyle="--"), ax.axvline(5) |
| Bereich schattieren | ax.axvspan(2, 4, alpha=0.2) |
Linien, Marker und Farben
| Aufgabe | Code |
|---|---|
| Farbe, Breite und Linienstil | ax.plot(x, y, color="tab:red", linewidth=2, linestyle="--") |
| Marker auf den Punkten | ax.plot(x, y, marker="o", markersize=4) |
| Kurzer Format-String | ax.plot(x, y, "g--o") |
| Transparenz | ax.plot(x, y, alpha=0.5) |
| Linienstile | "-", "--", "-.", ":" |
| Marker-Codes | "o", "s", "^", "x", ".", "*" |
| Möglichkeiten, eine Farbe anzugeben | "tab:blue", "C1", "#1f77b4", (0.2, 0.4, 0.6) |
| n Farben aus einer Colormap | colors = plt.colormaps["viridis"](np.linspace(0, 1, 5)) |
| Eigener Farbzyklus | ax.set_prop_cycle(color=["#0b7285", "#e8590c", "#5f3dc4"]) |
| Balken mit Rahmen und Schraffur | ax.bar(cats, a, color="white", edgecolor="black", hatch="//") |
Titel, Beschriftungen und Legenden
| Aufgabe | Code |
|---|---|
| Titel und Achsenbeschriftungen | ax.set_title("Sales"), ax.set_xlabel("Month"), ax.set_ylabel("EUR") |
| Alles in einem Aufruf | ax.set(title="Sales", xlabel="Month", ylabel="EUR") |
| Legende aus Linien-Labels | ax.plot(x, y, label="sin")
ax.legend() |
| Position und Spalten der Legende | ax.legend(loc="upper right", ncols=2, frameon=False) |
| Legende außerhalb des Plots | ax.legend(loc="center left", bbox_to_anchor=(1, 0.5)) |
| Text an einer Datenposition | ax.text(5, 0.5, "note") |
| Annotation mit Pfeil | ax.annotate("peak", xy=(1.57, 1), xytext=(3, 1.2), arrowprops=dict(arrowstyle="->")) |
| Werte an den Balken | bars = ax.bar(cats, a)
ax.bar_label(bars) |
| Titel für die ganze Figure | fig.suptitle("Q1 report") |
| Mathe in Beschriftungen | ax.set_xlabel(r"$\alpha$ (rad)") |
Achsen, Ticks und Skalen
| Aufgabe | Code |
|---|---|
| Achsengrenzen | ax.set_xlim(0, 10), ax.set_ylim(bottom=0) |
| Logarithmische Skala | ax.set_yscale("log") |
| Ticks und ihre Labels festlegen | ax.set_xticks([0, 5, 10], labels=["start", "middle", "end"]) |
| Tick-Labels drehen | ax.tick_params(axis="x", labelrotation=45) |
| Gitterlinien | ax.grid(True, alpha=0.3) |
| Prozentachse | from matplotlib.ticker import PercentFormatter
ax.yaxis.set_major_formatter(PercentFormatter(1.0)) |
| Tausendertrennzeichen | ax.yaxis.set_major_formatter("{x:,.0f}") |
| Oberen und rechten Rand ausblenden | ax.spines[["top", "right"]].set_visible(False) |
| Zweite y-Achse rechts | ax2 = ax.twinx()
ax2.plot(x, y * 100, color="tab:orange") |
| Gleiche Skala auf beiden Achsen | ax.set_aspect("equal") |
| Achse umkehren | ax.invert_yaxis() |
| Achsen komplett ausblenden | ax.axis("off") |
| Gut lesbare Datumslabels | fig.autofmt_xdate() |
Subplots und Layout
plt.subplots(rows, cols) gibt ein NumPy-Array von Axes zurück. Indexiere es wie ein Array.
| Aufgabe | Code |
|---|---|
| Raster aus Plots | fig, axs = plt.subplots(2, 2, figsize=(8, 6)) |
| In einen davon zeichnen | axs[0, 1].plot(x, y) |
| Über alle iterieren | for ax in axs.flat:
ax.grid(True) |
| Achse zwischen Plots teilen | fig, axs = plt.subplots(1, 3, sharey=True) |
| Abstände ohne Überlappung | fig, axs = plt.subplots(2, 2, layout="constrained") |
| Überlappungen nach dem Zeichnen beheben | fig.tight_layout() |
| Spalten unterschiedlicher Breite | fig, axs = plt.subplots(1, 2, width_ratios=[3, 1]) |
| Benanntes Layout mit breitem Panel | fig, axd = plt.subplot_mosaic([["top", "top"], ["left", "right"]])
axd["top"].plot(x, y) |
| Kleiner Plot im Plot | inset = ax.inset_axes([0.6, 0.6, 0.35, 0.35]) |
| Leeres Panel ausblenden | axs[0].axis("off") |
Styles und Standardwerte
| Aufgabe | Code |
|---|---|
| Eingebauten Style nutzen | plt.style.use("ggplot") |
| Styles auflisten | plt.style.available |
| Seaborn-Look ohne seaborn | plt.style.use("seaborn-v0_8-whitegrid") |
| Style nur für eine Figure | with plt.style.context("dark_background"):
fig, ax = plt.subplots() |
| Standard-Schriftgröße | plt.rcParams["font.size"] = 12 |
| Standardgröße und Auflösung der Figure | plt.rcParams["figure.figsize"] = (8, 4), plt.rcParams["figure.dpi"] = 120 |
| Zurück zu den Standardwerten | plt.style.use("default") |
| Gängige Colormaps: sequenziell, divergierend, grau | "viridis", "coolwarm", "Greys" |
Plotten aus pandas
pandas plottet mit Matplotlib. Übergib ax=, um in deine eigenen Axes zu zeichnen, oder behalte die ax, die pandas zurückgibt.
| Aufgabe | Code |
|---|---|
| DataFrame-Spalten in deine Axes | df.plot(x="month", y="sales", ax=ax) |
| Balkendiagramm einer Gruppenübersicht | df.groupby("city")["sales"].sum().plot.bar(ax=ax) |
| Was pandas gezeichnet hat, weiter gestalten | ax = df.plot(x="month", y="sales")
ax.set_title("Sales") |
| Spalten direkt an Matplotlib | ax.plot(df["month"], df["sales"]) |
Matplotlib 3.11: alte Schreibweisen und was du jetzt schreibst
Code aus älteren Tutorials kann in Matplotlib 3.11 fehlschlagen oder Warnungen werfen. Schreib stattdessen die Varianten aus der Spalte Matplotlib 3.11.
| Aufgabe | Matplotlib 3.11 | Alte Schreibweise |
|---|---|---|
| Boxplot-Labels | ax.boxplot([data, data * 2], tick_labels=["A", "B"]) | labels=["A", "B"] |
| Horizontaler Box- oder Violinplot | ax.boxplot(data, orientation="horizontal") | vert=False |
| Colormap holen | plt.colormaps["viridis"] | plt.cm.get_cmap("viridis") |
| Seaborn-Style | plt.style.use("seaborn-v0_8") | plt.style.use("seaborn") |
Der Matplotlib-Code, mit dem du aus Daten ein klares Diagramm machst, sortiert nach Aufgabe: Figure und Axes, Plot-Typen, Linien und Farben, Titel und Legenden, Achsen und Ticks, Subplots und Layout, Styles und Plotten aus pandas. Jede Zeile ist ein kurzes Snippet zum Einfügen, plus eine Zeile dazu, was es tut.
Alles hier nutzt den objektorientierten Stil (fig, ax = plt.subplots(), dann Methoden auf ax) und ist für Matplotlib 3.11 geschrieben, die Version, die Coddy verwendet. Ältere Varianten wie labels= in boxplot stehen nur in der letzten Tabelle, neben dem, was du stattdessen schreibst. Die Beispiele verwenden x = np.linspace(0, 10, 50), y = np.sin(x) und eine Stichprobe normalverteilter Werte namens data. Neu in Python? Starte mit dem Python Spickzettel, und halte die Spickzettel zu pandas, NumPy und scikit-learn neben diesem bereit.
FAQ zum Matplotlib Spickzettel
Ist dieser Matplotlib Spickzettel kostenlos?
Ja. Dieser Matplotlib Spickzettel ist komplett kostenlos, ganz ohne Anmeldung. Setz ein Lesezeichen oder druck ihn im Browser als PDF, und schau wieder vorbei, wenn du den genauen Aufruf für eine Legende, ein Subplot-Raster oder eine Farbskala brauchst.
Was ist der Unterschied zwischen plt und ax?
plt.plot() zeichnet auf die gerade aktuelle Axes, was für ein einzelnes Diagramm schnell geht. fig, ax = plt.subplots() gibt dir Figure und Axes als Objekte, also zeichnet ax.plot() immer genau dort, wo du willst. Nutze den ax Stil für alles mit mehr als einem Plot und für Code, den du behalten willst.Wie ändere ich die Größe der Figure?
Übergib
figsize in Zoll, wenn du die Figure erstellst: fig, ax = plt.subplots(figsize=(10, 5)). Um den Standard für jede Figure zu ändern, setz plt.rcParams["figure.figsize"] = (10, 5). Die Pixelgröße einer gespeicherten Datei ist figsize mal dpi.Wie speichere ich ein Diagramm in hoher Auflösung?
Ruf
fig.savefig("chart.png", dpi=300, bbox_inches="tight") auf. Ein höherer dpi Wert ergibt ein schärferes PNG, und bbox_inches="tight" schneidet leere Ränder ab. Für Druck oder Folien speicherst du als SVG oder PDF, die in jeder Größe scharf bleiben.Warum überlappen sich Titel und Beschriftungen meiner Subplots?
Erstelle die Figure mit
layout="constrained", etwa plt.subplots(2, 2, layout="constrained"), dann macht Matplotlib Platz für Titel, Beschriftungen und Farbskalen. Bei einer bestehenden Figure rufst du nach dem Zeichnen fig.tight_layout() auf.Welche Matplotlib-Version deckt dieser Spickzettel ab?
Matplotlib 3.11, die Version, die Coddy verwendet. Aufrufe, die neuere Versionen entfernt oder umbenannt haben, etwa
labels= in boxplot (jetzt tick_labels=) und plt.cm.get_cmap (jetzt plt.colormaps[...]), stehen in der letzten Tabelle neben dem, was du stattdessen schreibst.Kann ich Matplotlib-Code online ausführen?
Ja. Der kostenlose Matplotlib Playground führt Python mit Matplotlib, NumPy, pandas und scikit-learn in deinem Browser aus und zeichnet deine Figures neben der Ausgabe, also kannst du jedes Snippet aus diesem Spickzettel einfügen und das Diagramm ohne Installation sehen. Der Machine-Learning-Kurs von Coddy nutzt diese Plots, um Daten vor dem Training eines Modells zu erkunden.
Verwandte Ressourcen
Weitere Spickzettel
