Visualisierung mit Matplotlib und Seaborn

Matplotlib ist die Standardbibliothek für Diagramme in Python; sowohl pandas als auch seaborn zeichnen damit. Üblicherweise wird sie mit import matplotlib.pyplot as plt importiert. In einem Jupyter-Notebook erscheint ein Diagramm unter der Zelle, die es zeichnet; in einem Skript zeigt plt.show() die offenen Figures an und wartet in einem normalen Skript, bis ihre Fenster geschlossen werden.

Eine Figure ist die gesamte Zeichenfläche: das Bild, das angezeigt oder gespeichert wird. Ein Axes ist ein Zeichenbereich innerhalb der Figure mit eigenen Daten, einem eigenen Titel, Achsenbeschriftungen und Achsengrenzen; eine Figure kann mehrere davon enthalten. Eine Achse ist eine Zahlengerade eines Axes, also die x-Achse oder die y-Achse, mit ihren Teilstrichen und Teilstrichbeschriftungen. Jedes sichtbare Element, etwa eine Linie, ein Marker, ein Text oder ein Balken, heißt Artist.

fig, ax = plt.subplots() erstellt eine Figure mit einem Axes und gibt beide Objekte zurück. figsize=(width, height) legt die Größe der Figure in Zoll fest. Der Standard beträgt 6,4 × 4,8 Zoll bei 100 Punkten pro Zoll, sodass eine Figure mit Standardeinstellungen auf dem Bildschirm 640 × 480 Pixel groß ist; plt.subplots(figsize=(8, 4)) erstellt eine breitere, flachere Figure.

Matplotlib bietet zwei Schreibweisen. In der objektorientierten Schreibweise rufst du Methoden auf konkreten Objekten auf: ax.plot(...), ax.set_title(...). In der pyplot-Schreibweise wirken Funktionen wie plt.plot(...) und plt.title(...) auf das „aktuelle“ Axes, meist das zuletzt erstellte. Beide zeichnen dieselben Diagramme; die objektorientierte Schreibweise ist übersichtlicher, sobald eine Figure mehr als ein Axes enthält oder der Darstellungscode in einer Funktion steht. Deshalb verwendet dieser Kurs sie.

Die beiden Schreibweisen verwenden unterschiedliche Namen für dieselben Einstellungen: plt.title, plt.xlabel und plt.xlim entsprechen ax.set_title, ax.set_xlabel und ax.set_xlim. Ein häufiger Fehler ist ax.title("Rainfall"): Bei einem Axes ist title ein Attribut, das ein Textobjekt enthält. Der Aufruf löst daher TypeError: 'Text' object is not callable aus. Verwende ax.set_title("Rainfall").

months = [1, 2, 3, 4, 5, 6]; temp_c = [3, 5, 9, 13, 17, 20], dann

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(months, temp_c)
ax.set_title("Mean monthly temperature")
ax.set_xlabel("Month")
ax.set_ylabel("Temperature (°C)")

.

Zeichenaufrufe fügen einem Axes Elemente hinzu; sie ersetzen den vorhandenen Inhalt nicht. Ein zweiter Aufruf von ax.plot(...) auf demselben ax ergänzt das Diagramm um eine zweite Linie. Für ein separates Diagramm erstelle mit einem weiteren Aufruf von plt.subplots() eine neue Figure oder zeichne auf einem anderen Axes einer Figure mit mehreren Teilgrafiken.

pyplot hält jede von ihm erstellte Figure offen, bis sie mit plt.close(fig) oder plt.close("all") geschlossen wird. Offene Figures belegen Speicher; sobald mehr als 20 offen sind, gibt Matplotlib eine Warnung aus. Code, der Figures in einer Schleife erstellt, sollte jede Figure nach dem Speichern schließen.

ax.plot(x, y) zeichnet Marker oder gerade Liniensegmente, die die Punkte in der angegebenen Reihenfolge verbinden. Ein Liniendiagramm eignet sich für eine Größe, die entlang einer geordneten Variablen wie Zeit oder Entfernung gemessen wird. Bei einem Argument, ax.plot(y), sind die x-Werte standardmäßig 0, 1, 2, ….

Da die Punkte in der angegebenen Reihenfolge verbunden werden, erzeugen unsortierte x-Werte eine Zickzacklinie, die im Diagramm hin und her verläuft. Bei x = [3, 1, 2] verläuft die Linie von x = 3 zurück zu x = 1 und dann vorwärts zu x = 2. Sortiere die Daten zuerst nach x, zum Beispiel mit df.sort_values("x").

Stilargumente: color (ein Name wie "black" oder "tab:orange" oder ein Hexadezimalcode wie "#1f77b4"), linestyle ("-" durchgezogen, "--" gestrichelt, ":" gepunktet, "-." strichpunktiert), linewidth, marker ("o" Kreis, "s" Quadrat, "^" Dreieck) und markersize. Eine kurze Formatzeichenkette kombiniert Marker und Linienstil: ax.plot(x, y, "o--") zeichnet Kreise, die durch eine gestrichelte Linie verbunden sind. Ohne color erhält jede neue Linie die nächste Farbe aus der Standardfolge, die mit "tab:blue" und "tab:orange" beginnt.

Gib jeder Linie ein label und rufe ax.legend() auf, um eine Legende anzuzeigen:

ax.plot(months, north, marker="o", label="North")
ax.plot(months, coast, linestyle="--", label="Coast")
ax.legend()

. Hat kein Artist eine Beschriftung, zeichnet ax.legend() nichts und Matplotlib warnt, dass keine Artists mit Beschriftungen gefunden wurden.

ax.scatter(x, y) zeichnet für jede Beobachtung einen nicht verbundenen Marker und eignet sich für den Zusammenhang zwischen zwei numerischen Variablen. Beispiel: Tagestemperatur [12, 15, 18, 21, 24, 27, 30, 22] °C und Fahrradverleihzahlen [180, 220, 260, 310, 330, 360, 340, 250]; ax.scatter(temp_c, rentals) zeigt, dass die Verleihzahlen mit der Temperatur meist steigen, und die Korrelation der beiden Listen beträgt etwa 0,92.

In ax.scatter legt s die Fläche jedes Markers in Quadratpunkt fest; der Standardwert ist 36, die Fläche eines 6 Punkt breiten Markers. Eine Verdopplung von s verdoppelt die Fläche, sodass die Breite des Markers nur um den Faktor etwa 1,4 wächst. s kann eine einzelne Zahl oder einen Wert pro Punkt enthalten, sodass die Markergröße eine dritte Variable darstellen kann.

c färbt die Punkte: entweder mit einer Farbe für alle oder anhand einer Zahl pro Punkt, die einer Farbskala wie cmap="viridis" zugeordnet wird. Bewahre das zurückgegebene Objekt auf und füge eine Farbleiste hinzu: sc = ax.scatter(temp_c, rentals, c=rain_mm, cmap="viridis"); fig.colorbar(sc, ax=ax, label="Rain (mm)").

Wenn sich viele Punkte überlagern, werden dichte Bereiche zu einfarbigen Flecken und verdecken, wie viele Punkte sie enthalten. Verringere die Deckkraft mit alpha=0.3, verwende kleinere Marker oder zeige stattdessen die Dichte, zum Beispiel mit einem Diagramm aus sechseckigen Klassen (df.plot.hexbin) oder einem zweidimensionalen Histogramm.

ax.plot(x, y, "o") zeichnet mit einem Marker und ohne Linie ebenfalls Punkte. Bei sehr vielen Punkten ist es schneller, weil alle Marker dieselbe Größe und Farbe haben. Verwende ax.scatter, wenn Größe oder Farbe von Punkt zu Punkt variieren sollen.

ax.bar(categories, heights) zeichnet einen vertikalen Balken pro Kategorie; ax.barh(categories, widths) zeichnet horizontale Balken, die Platz für lange Kategorienamen lassen. Sind die Kategorien Zeichenketten, platziert Matplotlib sie in der angegebenen Reihenfolge in gleichen Abständen und verwendet sie als Teilstrichbeschriftungen. Sind sie Zahlen, stehen die Balken an diesen numerischen Positionen auf einer gewöhnlichen numerischen Achse.

Balken beginnen standardmäßig an einer Basislinie bei 0, sodass ihre Länge ihren Wert zeigt. Das Argument width wird in Einheiten der x-Achse gemessen und beträgt standardmäßig 0,8. Kategorien als Zeichenketten werden im Abstand von einer Einheit platziert. Daher lässt die Standardeinstellung eine Lücke von 0,2 zwischen den Balken; bei width=1 berühren sich benachbarte Balken.

200 Pendler wurden gefragt, wie sie üblicherweise reisen: Auto 84, Bus 52, Fahrrad 38, zu Fuß 26. ax.barh(["Car", "Bus", "Bike", "Walk"], [84, 52, 38, 26]) zeichnet vier horizontale Balken. Die Anteile betragen 42 %, 26 %, 19 % und 13 % und ergeben zusammen 100 %.

ax.barh setzt die erste Kategorie an das untere Ende der Achse, weil die y-Achse nach oben wächst. Um eine Rangliste wie im Pendelbeispiel von oben zu lesen, rufe ax.invert_yaxis() auf oder kehre vor dem Zeichnen sowohl die Kategorien als auch ihre Werte um, sodass jeder Wert bei seiner Kategorie bleibt.

Gruppierte Balken stellen mehrere Datenreihen innerhalb jeder Kategorie nebeneinander. Verwende numerische Positionen und verschiebe jede Reihe um eine halbe Balkenbreite:

x = np.arange(3)
ax.bar(x - 0.2, north, width=0.4, label="North")
ax.bar(x + 0.2, coast, width=0.4, label="Coast")
ax.set_xticks(x, labels=["Jan", "Feb", "Mar"])
ax.legend()

. Die Balken für North stehen bei −0,2, 0,8 und 1,8, die für Coast bei 0,2, 1,2 und 2,2, jeweils mittig um den Teilstrich.

Gestapelte Balken zeichnen mit bottom= eine zweite Datenreihe auf die erste: ax.bar(days, car); ax.bar(days, bus, bottom=car). Gibt es an einem Tag 40 Autofahrten und 25 Busfahrten, reicht das Bussegment von 40 bis 65 und der gesamte Balken ist 65 hoch.

bars = ax.bar(...) gibt einen Container mit Balken zurück; ax.bar_label(bars) schreibt jeden Wert an das Ende seines Balkens. fmt steuert den Text: fmt="%.1f" gibt 3,14 als „3.1“ aus und fmt="{:.0f} km" als „3 km“.

Matplotlib zeichnet Balken in der Reihenfolge der Daten, nicht nach Größe. Sortiere für ein nach Rangfolge geordnetes Diagramm zuerst die Werte, zum Beispiel mit sorted() auf Paaren oder sort_values() in pandas. Das Argument yerr= ergänzt jeden Balken um einen Fehlerbalken vorgegebener Länge; ax.errorbar(x, y, yerr=...) tut dasselbe für Punkte.

Ein Balkendiagramm vergleicht Werte getrennter Kategorien, daher stehen seine Balken mit Lücken nebeneinander. Ein Histogramm zeigt dagegen, wie eine numerische Variable über benachbarte Intervalle verteilt ist; seine Balken berühren sich. Werden Messwerte mit einem Balken pro Datenzeile dargestellt, entsteht ein Balkendiagramm der Rohwerte, kein Histogramm.

Setze Texte mit ax.set_title("..."), ax.set_xlabel("...") und ax.set_ylabel("...") oder mit einem einzigen Aufruf: ax.set(title="Monthly rainfall", xlabel="Month", ylabel="Rainfall (mm)"). Nenne die Einheit in der Achsenbeschriftung, zum Beispiel „Niederschlag (mm)“ oder „Entfernung (km)“, damit jeder Teilstrichwert eine Bedeutung hat.

Matplotlib wählt die Achsengrenzen anhand der Daten und fügt einen kleinen Rand hinzu. Lege sie selbst mit ax.set_xlim(1, 12) und ax.set_ylim(0, 120) fest oder bestimme nur ein Ende mit ax.set_ylim(bottom=0). ax.set(xlim=(1, 12), ylim=(0, 120)) erledigt dasselbe mit einem Aufruf.

ax.set_xticks([1, 4, 7, 10]) wählt die Positionen der Teilstriche; ax.set_xticks([1, 2, 3], labels=["Jan", "Feb", "Mar"]) ersetzt zusätzlich ihre Beschriftungen. Drehe dicht stehende Beschriftungen mit ax.tick_params(axis="x", labelrotation=45). Formatierer für Teilstrichbeschriftungen ändern die Schreibweise der Werte: ax.yaxis.set_major_formatter(PercentFormatter(xmax=1, decimals=0)) beschriftet den Wert 0,25 mit „25%“. Dabei wird PercentFormatter aus matplotlib.ticker importiert.

ax.set_yscale("log") stellt die y-Achse auf eine logarithmische Skala ein, auf der gleiche Abstände gleiche Verhältnisse darstellen: Der Schritt von 10 zu 100 ist genauso lang wie der Schritt von 100 zu 1.000. Das eignet sich für Werte über mehrere Größenordnungen, etwa Einwohnerzahlen von Städten. Eine logarithmische Achse kann weder null noch negative Werte darstellen.

ax.legend() platziert die Legende dort, wo sie die wenigsten Punkte verdeckt (loc="best", die Standardeinstellung für eine Axes-Legende). Wähle mit loc="upper left" eine Position, ergänze mit title="Station" eine Überschrift und verteile die Einträge mit ncols=2 auf Spalten. ax.legend(bbox_to_anchor=(1.02, 1), loc="upper left") setzt die Legende knapp außerhalb des rechten Rands des Zeichenbereichs.

ax.grid(True, alpha=0.3) ergänzt helle Gitternetzlinien an den Teilstrichen; ax.grid(axis="y") zeichnet nur horizontale Linien, was das Ablesen von Balkenhöhen erleichtert.

Stilvorlagen ändern das standardmäßige Aussehen aller folgenden Diagramme: plt.style.use("ggplot"). plt.style.available listet die installierten Stile auf; die mit Matplotlib gelieferten Stile nach dem Vorbild von seaborn heißen zum Beispiel "seaborn-v0_8-whitegrid". Um einen Stil nur auf einen Codeblock anzuwenden, verwende with plt.style.context("ggplot"):.

Einzelne Standardeinstellungen stehen in plt.rcParams, zum Beispiel plt.rcParams["font.size"] = 12 oder plt.rcParams["figure.figsize"] = (8, 4). Sie gelten für danach erstellte Figures; plt.rcdefaults() stellt die Standardeinstellungen von Matplotlib wieder her.

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot([1, 2, 3, 4], [62, 48, 55, 40], marker="o", label="North")
ax.set(title="Monthly rainfall, January to April", xlabel="Month", ylabel="Rainfall (mm)", ylim=(0, 70))
ax.set_xticks([1, 2, 3, 4], labels=["Jan", "Feb", "Mar", "Apr"])
ax.legend()
ax.grid(axis="y", alpha=0.3)

.

In einer Figure mit mehreren Axes-Objekten ändern pyplot-Funktionen wie plt.title oder plt.xlabel nur das aktuelle Axes, meist das zuletzt erstellte. Dadurch kann ein Titel auf der falschen Teilgrafik landen. Methodenaufrufe auf dem gewünschten Axes, etwa axes[0].set_title(...), vermeiden das.

Erstelle die Niederschlagstabelle im Breitformat mit einer Spalte pro Station:

import pandas as pd
wide = pd.DataFrame({
    "North": [62, 48, 55, 40],
    "Coast": [110, 95, 80, 60],
    "Valley": [20, 15, 30, 45]
}, index=pd.Index(["Jan", "Feb", "Mar", "Apr"], name="month"))

Jede pandas-Series und jeder DataFrame hat eine .plot-Methode, die mit Matplotlib zeichnet und das Matplotlib-Axes zurückgibt, auf dem sie gezeichnet hat. df.plot(kind="bar") und df.plot.bar() sind derselbe Aufruf. Die Typen sind "line" (Standard), "bar", "barh", "hist", "box", "kde" oder "density", "area", "pie", "scatter" und "hexbin".

Standardmäßig wird der Index zur x-Achse und jede numerische Spalte zu einer Linie; die Legende wird aus den Spaltennamen erstellt. Eine Series stellt ihre Werte gegen ihren Index dar. Um Spalten auszuwählen, übergib x="month" und y="rain_mm" oder eine Liste wie y=["North", "Coast"].

Eine Tabelle wide mit dem Index Jan, Feb, Mar, Apr und den Spalten North [62, 48, 55, 40], Coast [110, 95, 80, 60] und Valley [20, 15, 30, 45], alle Angaben in Millimetern Niederschlag. ax = wide.plot(marker="o", figsize=(8, 4), title="Monthly rainfall"); ax.set_ylabel("Rainfall (mm)") zeichnet drei beschriftete Linien in einem Axes und setzt anschließend die y-Achsenbeschriftung mit einer gewöhnlichen Matplotlib-Methode.

Häufige Argumente von .plot: title, xlabel, ylabel, xlim, ylim, figsize, color, legend=False, rot (Drehung der Teilstrichbeschriftungen in Grad), grid=True und logy=True. ax= zeichnet in ein vorhandenes Axes, zum Beispiel eine Teilgrafik von plt.subplots(1, 2), statt eine neue Figure zu erstellen.

subplots=True zeichnet jede Spalte in ein eigenes Axes und gibt statt eines einzelnen Axes ein NumPy-Array von Axes-Objekten zurück; layout=(2, 2) ordnet sie in einem Raster an und sharey=True gibt ihnen eine gemeinsame y-Skala. Für die Tabelle mit drei Stationen liefert wide.plot(subplots=True, layout=(1, 3), sharey=True) eine Teilgrafik pro Station.

Streu- und Hexbin-Diagramme gibt es nur für DataFrames; sie benötigen sowohl x als auch y: days.plot.scatter(x="temp_c", y="rentals", c="rain_mm", colormap="viridis") färbt die Punkte nach Niederschlag. Eine Series hat kein Streudiagramm, daher löst s.plot.scatter() einen Fehler aus. df.plot.hist(bins=5) und df.plot.box() liefern für jede numerische Spalte ein Histogramm beziehungsweise einen Boxplot.

s.plot.pie() zeichnet für jeden Wert ein Kreissegment, dessen Größe seinem Anteil an der Gesamtsumme entspricht. Da Kreisdiagramme eine Series mit nicht negativen Teilen eines Ganzen benötigen, ist eine Spalte mit Häufigkeiten wie s.value_counts() eine typische Eingabe.

Balkendiagramme in pandas behandeln den Index als Kategorien und platzieren die Balken unabhängig von den Indexwerten an den Positionen 0, 1, 2, …. Liniendiagramme verwenden die tatsächlichen Indexwerte, wenn diese Zahlen oder Datumsangaben sind. Eine Linie und Balken aus pandas liegen auf demselben Axes daher nur dann passend übereinander, wenn die x-Werte der Linie den Balkenpositionen entsprechen, wie beim Standardindex 0, 1, 2, …; bei Jahren wie 2020 bis 2023 liegt die Linie weit rechts von den Balken. Stelle beim Kombinieren beide anhand derselben Positionen dar.

Bei einem DatetimeIndex setzt .plot() Datumsangaben auf die x-Achse und beschriftet sie automatisch. Tagesdaten werden nach einem Resampling oft übersichtlicher, zum Beispiel zu Monatsmittelwerten mit s.resample("MS").mean().plot().

.plot stellt nur numerische Spalten dar. Wurden Zahlen als Text eingelesen, zum Beispiel weil eine Spalte „12 mm“ enthält, wird die Spalte übersprungen. Bleiben keine numerischen Daten übrig, löst pandas TypeError: no numeric data to plot aus. Wandle die Spalte zuerst um, zum Beispiel mit pd.to_numeric(...).

Ein Diagramm zeichnet die Werte, die in der Tabelle stehen. Fasse sie deshalb zuerst zusammen. Beispiel: eine Tabelle rain im Langformat mit 12 Zeilen, einer pro Station und Monat, und den Spalten month, station und rain_mm. rain.groupby("station")["rain_mm"].mean() liefert einen Mittelwert pro Station: Coast 86,25 mm, North 51,25 mm und Valley 27,5 mm. Ergänzt du .plot.bar(), werden drei Balken gezeichnet.

Wenn du versehentlich Rohdatenzeilen darstellst, erhältst du einzelne Messwerte statt der gewünschten Mittelwerte: rain.plot.bar(x="station", y="rain_mm") zeichnet 12 Balken mit wiederholten Stationsnamen statt drei Mittelwerten.

Sortiere vor dem Zeichnen, um die Balken nach Rangfolge anzuordnen: means.sort_values(ascending=False).plot.bar() setzt den größten Mittelwert nach links. Bei einem horizontalen Diagramm setzt means.sort_values().plot.barh() den größten Wert nach oben, weil der erste Wert unten gezeichnet wird.

s.value_counts() zählt, wie oft jede Kategorie vorkommt, und listet die Häufigkeiten absteigend auf. Für die Verkehrsmittel „Bus“, „Auto“, „Bus“, „Fahrrad“, „Bus“, „Auto“ ergibt das Bus 3, Auto 2, Fahrrad 1, bereit für .plot.bar(). Verwende .sort_index() oder .reindex([...]), wenn die Kategorien eine natürliche Reihenfolge haben, etwa Wochentage.

Ein DataFrame im Breitformat mit einer Spalte pro Datenreihe ergibt in pandas eine Linie beziehungsweise Balkenfarbe pro Spalte. Forme eine Tabelle im Langformat mit rain.pivot(index="month", columns="station", values="rain_mm") um. Kommt ein Paar aus Index- und Spaltenwert mehr als einmal vor, löst pivot einen Fehler aus; verwende stattdessen pivot_table(..., aggfunc="mean") oder groupby(["month", "station"])["rain_mm"].mean().unstack().

pivot und pivot_table sortieren den neuen Index. Monatsnamen als Zeichenketten erscheinen daher alphabetisch als Apr, Feb, Jan, Mar; ein Liniendiagramm durchläuft die Monate dann in der falschen Reihenfolge. Stelle die tatsächliche Reihenfolge mit wide.reindex(["Jan", "Feb", "Mar", "Apr"]) wieder her oder speichere den Monat vor dem Pivotieren als geordnete kategoriale Variable oder als Monatszahl.

Auf einer Tabelle im Breitformat zeichnet wide.plot.bar() gruppierte Balken, eine Gruppe pro Indexbezeichnung und eine Farbe pro Spalte, während wide.plot.bar(stacked=True) die Spalten stapelt. Die Transponierung wide.T.plot.bar() vertauscht die Rollen: eine Gruppe pro Station, eine Farbe pro Monat.

Für Anteile innerhalb jeder Gruppe normiere eine Kreuztabelle: pd.crosstab(trips["region"], trips["mode"], normalize="index") dividiert jede Häufigkeit durch die Zeilensumme, sodass sich jede Zeile zu 1 summiert. Hat Region N zwei Auto- und eine Busfahrt, enthält ihre Zeile Auto 0,67 und Bus 0,33 (gerundet). .plot.bar(stacked=True) zeichnet dann gleich hohe Balken, die die Zusammensetzung jeder Region zeigen.

seaborn arbeitet am besten mit Daten im Langformat: eine Zeile pro Beobachtung und eine Spalte pro Variable. wide.reset_index().melt(id_vars="month", var_name="station", value_name="rain_mm") wandelt die 4 × 3-Tabelle im Breitformat zurück in 12 Zeilen mit drei Spalten, sodass station für Farben oder Facetten verwendet werden kann.

seaborn ist eine auf Matplotlib aufbauende Bibliothek für Diagramme, die direkt mit pandas-DataFrames arbeitet und gängige statistische Kennwerte selbst berechnet. Üblicherweise wird sie mit import seaborn as sns importiert. Ein typischer Aufruf nennt die Tabelle und ihre Spalten: sns.scatterplot(data=days, x="temp_c", y="rentals").

Neben x und y lassen sich Spalten weiteren Merkmalen zuordnen (semantische Zuordnungen): hue legt die Farbe fest, style den Marker oder das Strichmuster und size die Markergröße oder Linienbreite. seaborn wählt die Farben und erstellt die Legende selbst. Eine kategoriale hue-Spalte erhält unterschiedliche Farben, eine numerische einen Farbverlauf.

Für jede Zuordnung wird eine Spalte im Langformat benötigt. Mit der Niederschlagstabelle im Langformat zeichnet sns.lineplot(data=rain, x="month", y="rain_mm", hue="station", marker="o") eine farbige Linie pro Station mit Legende. Nennt hue eine Spalte, die nicht in der Tabelle steht, löst seaborn einen ValueError aus, der besagt, dass der Wert nicht interpretiert werden konnte.

Enthält x Zeichenketten, platziert seaborn die Kategorien in der Reihenfolge, in der sie erstmals in den Daten erscheinen. Monatsnamen, die in dieser Zeilenreihenfolge als „Jan“, „Feb“, „Mar“ gespeichert sind, bleiben daher in Kalenderreihenfolge. Die Funktionen für kategoriale Daten wie barplot, boxplot und countplot akzeptieren order=["Mon", "Tue", "Wed"], um die Kategorienreihenfolge festzulegen; hue_order legt die Reihenfolge der Farbgruppen in jeder Funktion mit hue fest. lineplot hat kein Argument order: Um dort die Reihenfolge der Monatsnamen festzulegen, mache die x-Spalte zu einer geordneten kategorialen Variablen, zum Beispiel mit pd.Categorical(rain["month"], categories=["Jan", "Feb", "Mar", "Apr"], ordered=True).

Funktionen auf Axes-Ebene wie scatterplot, lineplot, histplot, boxplot, barplot und heatmap zeichnen in ein Matplotlib-Axes, akzeptieren ax= zur Auswahl dieses Axes und geben es zurück. Funktionen auf Figure-Ebene, relplot, displot, catplot und lmplot, erstellen eine eigene Figure, können sie mit col und row in Teilgrafiken aufteilen und geben ein seaborn-Objekt vom Typ FacetGrid zurück.

Bei Funktionen auf Figure-Ebene wird die Größe pro Teilgrafik festgelegt: height ist die Höhe jeder Teilgrafik in Zoll und aspect ihr Verhältnis von Breite zu Höhe, sodass jede Teilgrafik height × aspect Zoll breit ist; die Standardwerte sind 5 und 1. Da diese Funktionen eine eigene Figure erstellen, können sie nicht in ein vorhandenes Axes zeichnen: relplot, displot und catplot warnen und ignorieren ax=, während lmplot es mit einem TypeError ablehnt. Sie platzieren die Legende außerhalb der Teilgrafiken.

sns.set_theme() stellt alle folgenden Diagramme, auch reine Matplotlib-Diagramme, auf das Erscheinungsbild von seaborn um: den Stil „darkgrid“, den Kontext „notebook“ und die Standardpalette von seaborn. style kann „darkgrid“, „whitegrid“, „dark“, „white“ oder „ticks“ sein; context kann „paper“, „notebook“, „talk“ oder „poster“ sein und skaliert Schriften und Linien, zum Beispiel von einer Grundschriftgröße von 12 Punkt für „notebook“ auf 18 Punkt für „talk“.

palette wählt die Farben für hue, zum Beispiel palette="colorblind", "Set2" oder "viridis". In seaborn 0.13 gilt die Übergabe von palette ohne hue als veraltet; um Balken nach Kategorie zu färben, setze hue auf dieselbe Spalte wie x und ergänze legend=False: sns.barplot(data=rain, x="station", y="rain_mm", hue="station", legend=False).

Das Ergebnis lässt sich mit Matplotlib fertig gestalten:

ax = sns.scatterplot(...)
ax.set(xlabel="Temperature (°C)", ylabel="Rentals per day", title="Rentals and temperature")

. Verwende für ein Ergebnis auf Figure-Ebene die Methoden des Rasters, etwa g.set_axis_labels("Temperature (°C)", "Rentals per day"), und g.figure.suptitle("...") für einen Gesamttitel.

sns.scatterplot(data=days, x="temp_c", y="rentals", hue="weekday", size="rain_mm") zeichnet einen Punkt pro Zeile, dessen Farbe und Größe durch weitere Spalten bestimmt werden. Kombinierst du hue und style mit derselben Spalte, erhält jede Gruppe eine eigene Farbe und einen eigenen Marker, sodass sie auch in Graustufen unterscheidbar bleibt.

sns.lineplot aggregiert standardmäßig: Haben mehrere Zeilen denselben x-Wert, zeichnet die Funktion die Linie durch das arithmetische Mittel ihrer y-Werte und schattiert ein Band für das 95-%-Konfidenzintervall dieses Mittelwerts, das durch Bootstrapping berechnet wird. Durchgerechnetes Beispiel: Bei x = 1 sind die y-Werte 10, 12 und 14, bei x = 2 sind sie 20, 21 und 25; die Linie verläuft durch 12 und 22.

Das Standardband zeigt die Unsicherheit jedes Mittelwerts, nicht die Spannweite der Daten. errorbar="sd" schattiert stattdessen den Bereich einer Standardabweichung oberhalb und unterhalb des Mittelwerts, errorbar=None entfernt das Band und estimator=None zeichnet zusammen mit units= jede einzelne Datenreihe ohne Mittelwertbildung. Bei einer Zeile pro x-Wert gibt es nichts zu mitteln und kein Band.

sns.regplot(data=days, x="temp_c", y="rentals") zeichnet ein Streudiagramm mit einer nach der Methode der kleinsten Quadrate angepassten Geraden und einem schattierten 95-%-Konfidenzband für diese Gerade; order=2 passt stattdessen eine quadratische Kurve an. sns.lmplot tut dasselbe als Funktion auf Figure-Ebene und kann die Daten daher zusätzlich nach hue, col oder row aufteilen.

Eine angepasste Linie fasst die Daten anhand des gewählten Modells zusammen. Auch durch gekrümmte Daten lässt sich eine Gerade zeichnen. Betrachte deshalb die Punkte um die Linie, bevor du ihr vertraust. Ein starker Trend zeigt, dass die Variablen in diesen Daten zusammenhängen, ohne eine Ursache nachzuweisen.

sns.pairplot(df) zeichnet ein Raster mit einem Streudiagramm für jedes Paar numerischer Spalten und der Verteilung jeder Spalte auf der Diagonale: standardmäßig Histogramme, bei gesetztem hue Dichtekurven. Vier numerische Spalten ergeben ein 4 × 4-Raster mit 16 Teilgrafiken. corner=True behält nur das untere Dreieck und vars=[...] begrenzt die Spaltenauswahl. Die Funktion gibt ein PairGrid zurück.

sns.jointplot(data=days, x="temp_c", y="rentals") zeichnet ein Streudiagramm mit dem Histogramm jeder Variablen an den Rändern; kind="hex" ersetzt die Punkte durch sechseckige Klassen, was bei großen Datensätzen hilft.

sns.relplot(..., kind="scatter") und sns.relplot(..., kind="line") sind die Varianten von scatterplot und lineplot auf Figure-Ebene; das Streudiagramm ist der Standardtyp. Verwende sie, wenn derselbe Zusammenhang für jede Gruppe in einer eigenen Teilgrafik gezeigt werden soll.

sns.regplot(data=days, x="temp_c", y="rentals") zeigt einen Anstieg der Verleihzahlen von 180 bei 12 °C auf etwa 350 an den wärmsten Tagen, bei einer Korrelation von etwa 0,92. Am Tag mit 30 °C gibt es weniger Ausleihen (340) als am Tag mit 27 °C (360), sodass die Punkte oben abflachen; eine quadratische Anpassung (order=2) kann mit der Geraden verglichen werden.

Die Funktionen von seaborn für kategoriale Daten platzieren jede Kategorie an den Positionen 0, 1, 2, … auf der kategorialen Achse. Auch Zahlen werden als Bezeichnungen behandelt: Die Jahre 2020, 2021 und 2023 werden in gleichen Abständen gezeichnet, ohne Lücke für 2022. native_scale=True behält eine numerische Achse mit den tatsächlichen Abständen bei.

sns.barplot(data=rain, x="station", y="rain_mm") zeichnet einen Balken pro Station, dessen Höhe das arithmetische Mittel ihrer Zeilen ist, mit einem Fehlerbalken für das 95-%-Konfidenzintervall dieses Mittelwerts. Bei der Niederschlagstabelle betragen die Balkenhöhen für Coast 86,25, North 51,25 und Valley 27,5 mm. estimator="median" oder estimator="sum" ändert den zusammenfassenden Kennwert; errorbar="sd" ändert die Fehlerbalken und errorbar=None entfernt sie.

sns.countplot(data=trips, x="mode") zählt die Zeilen in jeder Kategorie und benötigt keine numerische Spalte; sns.barplot fasst eine numerische Spalte zusammen. Verwende countplot für „wie viele“ und barplot für „wie viel im Durchschnitt“.

sns.pointplot zeigt den Mittelwert jeder Gruppe als Punkt mit Fehlerbalken und verbindet die Punkte jeder hue-Gruppe mit einer Linie. So lassen sich Änderungen über Kategorien hinweg leicht vergleichen, zum Beispiel der mittlere Niederschlag von drei Stationen in jedem von vier Monaten.

Ein Balken für einen Mittelwert verdeckt die Streuung und die Anzahl der Beobachtungen: Ein Mittelwert aus 3 Zeilen wirkt genauso solide wie einer aus 300. Häufig ist es besser, die Daten zu zeigen: sns.stripplot zeichnet jede Beobachtung als Punkt mit einer kleinen zufälligen Verschiebung, und sns.swarmplot ordnet die Punkte so an, dass sie sich nicht überlagern. Ein Streifendiagramm kann auf demselben Axes über einem Boxplot oder Balkendiagramm gezeichnet werden.

Mit hue platzieren Balkendiagramme, Boxplots und Violinplots die Gruppen standardmäßig innerhalb jeder Kategorie nebeneinander. Punkt-, Streifen- und Schwarmdiagramme zeichnen die Gruppen an derselben Position, sofern nicht dodge=True gesetzt ist, sodass sich ihre Punkte überlagern können. Lege die Kategorienreihenfolge mit order=[...] und die Gruppenreihenfolge mit hue_order=[...] fest.

Die Ausrichtung folgt den Daten: Setze die Kategorien auf die y-Achse und die Zahlen auf die x-Achse, sns.barplot(data=rain, x="rain_mm", y="station"), um horizontale Balken mit lesbaren langen Beschriftungen zu erhalten. orient="y" (oder "h") legt dies ausdrücklich fest.

sns.catplot ist die Funktion auf Figure-Ebene für alle Diagramme für kategoriale Daten. Ihr kind kann „strip“ (Standard), „swarm“, „box“, „violin“, „boxen“, „point“, „bar“ oder „count“ sein; col oder row teilt das Diagramm in Teilgrafiken auf.

Ein Histogramm teilt die Spannweite einer numerischen Variablen in benachbarte Intervalle, sogenannte Klassen, und zeichnet über jeder Klasse einen Balken, dessen Höhe der Anzahl der Beobachtungen darin entspricht. Es zeigt die Form einer Verteilung: wo die Werte liegen, wie stark sie streuen, ob die Verteilung schief ist und ob es Lücken oder ungewöhnliche Werte gibt.

counts, edges, patches = ax.hist(data, bins=5) zeichnet das Histogramm und gibt die Anzahl in jeder Klasse sowie die Klassengrenzen zurück. Bei einer Ganzzahl als Angabe sind die Klassen vom Minimum bis zum Maximum gleich breit; standardmäßig gibt es 10 Klassen. Jede Klasse schließt ihre linke Grenze ein und ihre rechte aus, außer der letzten Klasse, die beide einschließt.

20 Pendelzeiten in Minuten: 12, 15, 18, 20, 22, 22, 25, 27, 28, 30, 31, 33, 35, 38, 40, 42, 45, 50, 55, 62. Bei bins=5 sind die Grenzen 12, 22, 32, 42, 52 und 62 und die Häufigkeiten 4, 7, 4, 3 und 2. Der Wert 22 fällt in die zweite Klasse, weil Klassen ihre rechte Grenze ausschließen; 62 zählt zur letzten Klasse, weil diese ihn einschließt.

Anzahl und Position der Klassen verändern das Bild. Dieselben 20 Zeiten ergeben mit den Grenzen [10, 20, 30, 40, 50, 60, 70] die Häufigkeiten 3, 6, 5, 3, 2 und 1. Zu wenige Klassen verdecken die Form; zu viele ergeben ein gezacktes Diagramm mit vielen fast leeren Klassen. Probiere mehrere Einstellungen aus und bevorzuge runde Klassengrenzen, die Leser deuten können, etwa Schritte von 10 Minuten.

density=True in Matplotlib oder stat="density" in seaborn skaliert die Balken so, dass ihre Gesamtfläche 1 beträgt: Jede Höhe ist Häufigkeit ÷ (n × Klassenbreite). Bei den Pendeldaten mit fünf Klassen von je 10 Minuten beträgt die Höhe des zweiten Balkens 7 ÷ (20 × 10) = 0,035 pro Minute. Eine Dichtehöhe ist keine Wahrscheinlichkeit; Höhe × Klassenbreite ist der Anteil der Beobachtungen in der Klasse.

sns.histplot(data=commutes, x="minutes") zeichnet ein Histogramm mit seaborn; bins und binwidth steuern die Klassen. stat wählt die Höhe: „count“ (Standard), „probability“ oder „proportion“ (die Höhen summieren sich zu 1), „percent“ (die Höhen summieren sich zu 100) und „density“ (Fläche 1). Für die fünf Pendelzeitklassen ergibt „probability“ 0,2, 0,35, 0,2, 0,15 und 0,1.

Zum Vergleich von Gruppen legt sns.histplot(data=commutes, x="minutes", hue="mode") je ein Histogramm pro Gruppe übereinander; multiple="stack" stapelt sie, multiple="dodge" stellt sie nebeneinander und element="step" zeichnet Umrisse, die sich bei Überlagerung besser lesen lassen. Gruppen unterschiedlicher Größe lassen sich mit stat="density", common_norm=False angemessen vergleichen; dadurch wird jede Gruppe auf eine Fläche von 1 skaliert.

Eine Kerndichteschätzung (KDE) ist eine glatte Kurve, die die Form der Verteilung schätzt; die Fläche darunter beträgt 1. sns.kdeplot(data=commutes, x="minutes") zeichnet sie und sns.histplot(..., kde=True) ergänzt sie in einem Histogramm. Ein bw_adjust über 1 macht die Kurve glatter, ein Wert unter 1 detailreicher.

Eine KDE-Kurve reicht über den kleinsten und größten Wert hinaus. Daher kann sie für Zeiten, die nicht negativ sein können, eine Dichte unter 0 Minuten zeigen. cut=0 begrenzt die Kurve auf den Wertebereich der Daten. Bei kleinen Stichproben kann die Kurve eine Form nahelegen, die die Daten nicht stützen.

In pandas zeichnet commutes["minutes"].plot.hist(bins=5, edgecolor="white") ein Histogramm (standardmäßig 10 Klassen) und df.hist() zeichnet für jede numerische Spalte ein Histogramm in einem Raster. In seaborn ist sns.displot die Variante auf Figure-Ebene: kind="hist" (Standard), kind="kde" oder kind="ecdf". Eine empirische Verteilungsfunktion (ECDF) zeigt für jeden Wert den Anteil der Beobachtungen, die höchstens diesen Wert haben.

Ein Boxplot fasst eine Verteilung zusammen: Die Box reicht vom ersten Quartil (Q1) bis zum dritten Quartil (Q3), eine Linie darin markiert den Median, Whisker reichen zu den kleinsten und größten typischen Werten und Punkte jenseits der Whisker werden einzeln als mögliche Ausreißer dargestellt. Der Interquartilsabstand IQR = Q3 − Q1 ist die Länge der Box und umfasst die mittlere Hälfte der Daten.

Standardmäßig verwenden Matplotlib, pandas und seaborn whis=1.5: Die Ausreißergrenzen sind Q1 − 1,5 × IQR und Q3 + 1,5 × IQR. Jeder Whisker endet beim äußersten Datenwert innerhalb seiner Ausreißergrenze, nicht an der Grenze selbst. Jeder Wert außerhalb der Ausreißergrenzen wird als eigener Punkt gezeichnet.

11 Lieferzeiten in Minuten: 14, 16, 17, 18, 19, 20, 21, 22, 24, 25, 41. Matplotlib berechnet Q1 = 17,5, Median = 20 und Q3 = 23, also IQR = 5,5. Die Ausreißergrenzen sind 17,5 − 8,25 = 9,25 und 23 + 8,25 = 31,25. Der untere Whisker endet bei 14, der obere bei 25 und 41 wird als Ausreißerpunkt gezeichnet.

Quartile hängen von der Methode ab. Die Grafikbibliotheken verwenden lineare Interpolation zwischen sortierten Werten, die Standardeinstellung von NumPy und pandas. Sie ergibt oben 17,5 und 23. Bei der Rechnung von Hand mit den Medianen der unteren und oberen Hälfte ohne den Gesamtmedian ergeben sich für dieselben Daten Q1 = 17 und Q3 = 24. Beide Methoden sind gültig; daher können kleine Unterschiede zwischen einer Rechnung von Hand und einem Diagramm entstehen.

Zeichne die Zusammenfassung mit der Bibliothek, die du verwendest: ax.boxplot([north, coast], tick_labels=["North", "Coast"]) in Matplotlib (vor Version 3.9 hieß das Argument labels); rain.boxplot(column="rain_mm", by="station") in pandas, wobei auch der Gesamttitel „Boxplot grouped by station“ hinzugefügt wird; sns.boxplot(data=rain, x="station", y="rain_mm") in seaborn, mit hue für eine zweite Gruppierung. whis=(0, 100) zeichnet die Whisker bis zum Minimum und Maximum, und showfliers=False blendet die Ausreißerpunkte aus.

Nebeneinanderstehende Boxplots erlauben einen Gruppenvergleich auf einen Blick: Vergleiche die Mediane, die Boxlängen (Streuung der mittleren Hälfte) und die Überlappung der Boxen. Ein Median nahe einem Ende der Box oder ein Whisker, der deutlich länger als der andere ist, deutet auf eine schiefe Verteilung hin.

Eine Box zeigt nur fünf Zahlen und die Ausreißer. Sie zeigt nicht die Anzahl der Beobachtungen, und sehr unterschiedliche Verteilungsformen können dieselbe Box haben: Eine Verteilung mit zwei getrennten Gipfeln und eine mit einem einzigen Gipfel können dieselben Werte für Q1, Median und Q3 haben. Zeichnest du die Punkte darüber, sns.stripplot(data=rain, x="station", y="rain_mm", color="black", alpha=0.5), oder verwendest du einen Violinplot, wird dies sichtbar.

sns.violinplot(data=rain, x="station", y="rain_mm") zeichnet für jede Gruppe eine gespiegelte Dichtekurve mit einem kleinen Boxplot darin (inner="box", die Standardeinstellung); inner="quart" markiert stattdessen die Quartile durch Linien. Bei einem hue mit zwei Ausprägungen setzt split=True je eine Gruppe auf eine Seite der Violine. Wie eine KDE kann die Violine über die Daten hinausreichen; cut=0 begrenzt sie auf das beobachtete Minimum und Maximum.

Ein Punkt, der durch die 1,5 × IQR-Regel als Ausreißer markiert wird, ist im Vergleich zu den übrigen Daten ungewöhnlich. Das ist ein Grund, den Wert zu untersuchen. Prüfe ihn: Es kann sich um einen Eingabefehler oder einen echten, wichtigen Wert handeln, etwa eine durch eine Straßensperrung verzögerte Lieferung. Punkte nur deshalb zu entfernen, weil das Diagramm sie markiert, verzerrt die Analyse.

Eine Heatmap zeigt eine Zahlentabelle als Raster farbiger Zellen: Zeilen und Spalten stehen für zwei Kategorien oder in Klassen eingeteilte Variablen, und die Farbe jeder Zelle steht für ihren Wert. Sie eignet sich für Muster in zweidimensionalen Tabellen, etwa Besucherzahlen nach Wochentag und Tageszeit, sowie für Korrelationsmatrizen.

sns.heatmap(table) nimmt eine Tabelle im Breitformat, verwendet deren Index als Zeilenbeschriftungen und deren Spalten als Spaltenbeschriftungen und ergänzt eine Farbleiste als Schlüssel. Die Tabelle stammt meist aus pivot_table: visits.pivot_table(index="day", columns="slot", values="visitors", aggfunc="mean").

Ein Museum zählt Besucher pro Halbtag. Samstagvormittag 120 und 140, Samstagnachmittag 200; Sonntagvormittag 90, Sonntagnachmittag 160; Montagvormittag 40, Montagnachmittag 70 und 90. Die Pivot-Tabelle der Mittelwerte enthält für Montag 40 und 80, Samstag 130 und 200, Sonntag 90 und 160, jeweils für Vormittag und Nachmittag. sns.heatmap(pt, annot=True, fmt=".0f", cmap="Blues") zeigt die Zelle mit den meisten Besuchern, den Samstagnachmittag, am dunkelsten. Die Pivotierung sortiert die Tage alphabetisch nach ihren englischen Kürzeln (Mon, Sat, Sun); pt.reindex(["Sat", "Sun", "Mon"]) würde eine gewählte Reihenfolge wiederherstellen.

annot=True schreibt jeden Wert in seine Zelle und fmt legt das Zahlenformat fest. Die Standardeinstellung ".2g" behält zwei signifikante Stellen, sodass 43,25 als „43“ und 1.234 als „1.2e+03“ angezeigt wird. Verwende fmt=".0f" für ganze Zahlen oder fmt=".2f" für zwei Nachkommastellen; fmt="d" funktioniert nur für ganzzahlige Daten und löst bei Gleitkommazahlen einen ValueError aus.

Eine Korrelations-Heatmap beginnt mit corr = df.corr(numeric_only=True), einer quadratischen, symmetrischen Tabelle, deren definierte Koeffizienten von −1 bis 1 reichen. Numerische Spalten, deren Werte nicht konstant sind, haben 1 auf der Diagonale; bei konstanten Spalten sind die Korrelationen nicht definiert. Ab pandas 2 ist numeric_only standardmäßig False, sodass df.corr() einen Fehler auslöst, wenn die Tabelle eine Textspalte enthält. Zeichne sie mit sns.heatmap(corr, annot=True, fmt=".2f", cmap="vlag", vmin=-1, vmax=1, center=0).

Acht Tage mit Temperatur (°C), Fahrradverleihzahlen, Niederschlag (mm) und Windgeschwindigkeit (km/h). Die Korrelationsmatrix ergibt für Temperatur und Verleihzahlen 0,92, für Verleihzahlen und Niederschlag −0,82, für Niederschlag und Wind 0,75 und für Temperatur und Wind −0,38. Mit der Farbskala „vlag“ erscheint das stark positiv korrelierte Paar tiefrot, das stark negativ korrelierte Paar tiefblau und das schwach korrelierte Paar Temperatur und Wind in einem blassen Farbton nahe der weißen Mitte.

Ohne vmin und vmax reichen die Farben vom kleinsten bis zum größten Wert der jeweiligen Tabelle. Daher kann dieselbe Farbe in zwei Heatmaps unterschiedliche Werte bedeuten. Lege zum Vergleich von Heatmaps die Grenzen fest und verwende für Korrelationen vmin=-1, vmax=1. Eine sequenzielle Farbskala wie „rocket“ (Standard von seaborn), „viridis“ oder „Blues“ eignet sich für Werte von niedrig bis hoch; eine divergierende Farbskala wie „vlag“, „coolwarm“ oder „RdBu_r“ eignet sich für Werte oberhalb und unterhalb eines Bezugswerts wie 0, wobei center auf dem aussagekräftigen Mittelpunkt liegt. Ist center gesetzt und kein cmap angegeben, verwendet seaborn das divergierende „icefire“.

Nützliche Optionen: linewidths=0.5 zeichnet dünne Linien zwischen den Zellen, square=True macht die Zellen quadratisch, cbar_kws={"label": "Visitors"} beschriftet die Farbleiste und fehlende Werte (NaN) bleiben leer. mask=np.triu(np.ones_like(corr, dtype=bool)) blendet das obere Dreieck und die Diagonale einer Korrelationsmatrix aus, die das untere Dreieck wiederholen.

In Matplotlib zeichnet im = ax.imshow(values, cmap="viridis"); fig.colorbar(im, ax=ax) eine Heatmap eines 2-dimensionalen Arrays, mit Zeile 0 oben; „viridis“ ist die Standardfarbskala von Matplotlib. imshow beschriftet die Achsen mit Zeilen- und Spaltennummern, lege Namen daher selbst fest: ax.set_xticks(range(len(cols)), labels=cols). ax.pcolormesh ist eine Alternative für Zellen unterschiedlicher Größe.

Ein Korrelationskoeffizient misst nur die Stärke eines linearen Zusammenhangs. Eine Korrelation nahe 0 schließt einen starken gekrümmten Zusammenhang nicht aus, und ein einzelner Ausreißer kann einen Koeffizienten stark erhöhen oder senken. Prüfe die zugehörigen Streudiagramme, zum Beispiel mit einem Pairplot, bevor du eine Korrelations-Heatmap interpretierst.

Small Multiples sind mehrere Diagramme desselben Typs, je eines für eine Teilmenge der Daten. Sie werden mit denselben Skalen nebeneinander gezeichnet, sodass sich die Teilmengen vergleichen lassen. In Matplotlib werden sie als Raster von Axes-Objekten in einer Figure erstellt.

fig, axes = plt.subplots(2, 3, figsize=(12, 6)) gibt eine Figure und ein 2 × 3-NumPy-Array von Axes-Objekten zurück. axes[0, 0] ist die Teilgrafik oben links und axes[1, 2] die unten rechts. Bei einer Zeile oder einer Spalte ist das Array eindimensional, sodass plt.subplots(1, 3) die Axes-Objekte axes[0], axes[1] und axes[2] ergibt. axes.flat durchläuft alle Teilgrafiken zeilenweise.

Das Array selbst kann nicht zeichnen: axes.plot(...) löst AttributeError: 'numpy.ndarray' object has no attribute 'plot' aus. Wähle zuerst eine Teilgrafik per Index aus, wie in axes[0, 1].plot(...).

sharex=True und sharey=True geben allen Teilgrafiken dieselben x- beziehungsweise y-Achsengrenzen. Dadurch bedeuten gleiche Höhen in jeder Teilgrafik gleiche Werte, und nur die äußeren Teilgrafiken zeigen Teilstrichbeschriftungen. Ohne gemeinsame Achsen skaliert jede Teilgrafik nach ihren eigenen Daten, sodass ein kleiner Wertebereich genauso groß aussehen kann wie ein großer.

fig, axes = plt.subplots(2, 2, sharey=True, layout="constrained"), dann for ax, (name, grp) in zip(axes.flat, rain.groupby("station")): ax.plot(grp["month_num"], grp["rain_mm"], marker="o"); ax.set_title(name). Die drei Stationen füllen drei der vier Teilgrafiken; axes[1, 1].axis("off") blendet die leere vierte aus.

Beschriftungen benachbarter Teilgrafiken können sich überlappen. layout="constrained" in plt.subplots oder plt.figure passt die Abstände automatisch an; fig.tight_layout(), nach dem Zeichnen aufgerufen, ist die ältere Alternative. fig.suptitle("Monthly rainfall by station") ergänzt einen Titel für die gesamte Figure und fig.supxlabel(...) und fig.supylabel(...) ergänzen gemeinsame Achsenbeschriftungen.

Teilgrafiken unterschiedlicher Größe: plt.subplots(1, 2, gridspec_kw={"width_ratios": [2, 1]}) macht die linke Teilgrafik doppelt so breit wie die rechte. fig, axd = plt.subplot_mosaic([["top", "top"], ["left", "right"]]) gibt ein Dictionary von Axes-Objekten zurück, hier eine breite Teilgrafik axd["top"] über zwei kleineren.

Diagramme von pandas und Funktionen von seaborn auf Axes-Ebene können mit ax= ausgewählte Teilgrafiken füllen: wide["North"].plot(ax=axes[0, 0]) oder sns.histplot(data=commutes, x="minutes", ax=axes[0, 1]). So lassen sich Diagramme aus allen drei Bibliotheken in einer Figure kombinieren.

Bei der Facettierung wird dasselbe Diagramm für jede Ausprägung einer kategorialen Variablen einmal gezeichnet, jeweils in einer eigenen Teilgrafik mit gemeinsamen Achsen. Die Funktionen von seaborn auf Figure-Ebene tun dies mit col= (Teilgrafiken nebeneinander), row= (Teilgrafiken untereinander) und col_wrap= (nach dieser Anzahl von Spalten eine neue Zeile beginnen).

sns.relplot(data=rain, x="month_num", y="rain_mm", col="station", col_wrap=2, kind="line", height=3, aspect=1.5) zeichnet drei Teilgrafiken, zwei in der ersten und eine in der zweiten Zeile. Jede Teilgrafik ist 3 Zoll hoch und 3 × 1,5 = 4,5 Zoll breit, sodass die Figure etwa 9 × 6 Zoll groß ist.

row und col zusammen erzeugen ein Raster mit einer Teilgrafik pro Kombination von Ausprägungen: Zwei Jahreszeiten als Zeilen und drei Stationen als Spalten ergeben 2 × 3 = 6 Teilgrafiken. col_wrap lässt sich nicht mit row kombinieren.

Dieselben Argumente funktionieren für jeden Diagrammtyp: sns.displot(data=commutes, x="minutes", col="mode") ergibt ein Histogramm pro Verkehrsmittel und sns.catplot(data=rain, x="station", y="rain_mm", col="season", kind="box") ergibt Boxplots pro Jahreszeit.

Teilgrafiken teilen standardmäßig ihre x- und y-Achsen, sodass sich Höhen zwischen ihnen vergleichen lassen. Wenn jede Teilgrafik nach ihren eigenen Daten skaliert wird, werden Details innerhalb kleiner Gruppen sichtbar, der Vergleich zwischen Teilgrafiken kann auf einen Blick aber irreführend sein. Übergib bei relplot und displot facet_kws={"sharey": False}; catplot nimmt sharey=False direkt entgegen. Wird es zusätzlich in facet_kws übergeben, löst dies einen TypeError aus.

sns.FacetGrid erstellt das Raster direkt und zeichnet dann in jede Teilgrafik: g = sns.FacetGrid(commutes, col="mode", height=3); g.map_dataframe(sns.histplot, x="minutes"); g.add_legend(). g.map(plt.scatter, "temp_c", "rentals") übergibt die benannten Spalten als Positionsargumente an eine Zeichenfunktion.

Passe das Raster mit seinen Methoden an: g.set_titles("{col_name}") setzt die Titel der Teilgrafiken anhand der Namen der Ausprägungen, g.set_axis_labels("Month", "Rainfall (mm)") beschriftet alle Achsen und g.set(ylim=(0, 120)) wendet eine Axes-Einstellung auf jede Teilgrafik an. Mit g.axes_dict["Coast"] oder g.axes.flat erreichst du einzelne Axes-Objekte, und g.figure.suptitle("Rainfall by station", y=1.02) ergänzt einen Gesamttitel über den Teilgrafiken.

hue und col teilen beide nach einer Variablen auf. hue legt die Gruppen in einem Axes übereinander, was bei wenigen Gruppen einen direkten Vergleich erleichtert; col trennt sie, sodass die Darstellung lesbar bleibt, wenn sich Linien oder Punkte überlagern würden oder es viele Gruppen gibt. Beide lassen sich gleichzeitig verwenden, zum Beispiel col="station", hue="season".

Funktionen auf Figure-Ebene zeichnen nicht in ein vorhandenes Axes (relplot, displot und catplot ignorieren ax= mit einer Warnung, lmplot lehnt es ab) und akzeptieren nicht Matplotlibs figsize (die Übergabe löst einen Fehler aus): Lege die Größe des Rasters mit height und aspect fest. Um ein facettiertes Diagramm neben anderen Diagrammen in einer Matplotlib-Figure zu platzieren, erstelle die Teilgrafiken stattdessen mit plt.subplots und Funktionen auf Axes-Ebene.

ax.text(x, y, "text") schreibt Text an eine Position in Datenkoordinaten, also in denselben Einheiten wie die dargestellten Werte. ha („left“, „center“, „right“) und va („top“, „center“, „bottom“) richten den Text an diesem Punkt aus; fontsize und color gestalten ihn.

Mit transform=ax.transAxes sind die Positionen stattdessen Anteile des Axes: (0|0) ist die untere linke und (1|1) die obere rechte Ecke. ax.text(0.02, 0.95, "n = 20", transform=ax.transAxes, va="top") hält einen Hinweis unabhängig von Daten und Achsengrenzen in der oberen linken Ecke. Text in Datenkoordinaten verschiebt sich bei geänderten Achsengrenzen und kann außerhalb des Zeichenbereichs landen.

ax.annotate("Wettest month", xy=(1, 110), xytext=(2, 115), arrowprops=dict(arrowstyle="->")) schreibt den Text an xytext und zeichnet einen Pfeil zum Punkt xy; beide Angaben sind standardmäßig Datenkoordinaten. textcoords="offset points" macht xytext zu einem Versatz von xy in Punkt, zum Beispiel xytext=(10, 10) für 10 Punkt nach rechts und oben.

Referenzlinien erstrecken sich über das ganze Axes: ax.axhline(50, color="gray", linestyle="--", label="Target") zeichnet eine horizontale Linie bei y = 50 und ax.axvline(...) eine vertikale. ax.axvspan(6, 8, alpha=0.2) schattiert den Bereich von x = 6 bis x = 8, zum Beispiel eine Ferienzeit. ax.hlines(y, xmin, xmax) zeichnet horizontale Linien über einen begrenzten Bereich.

Im Histogramm der 20 Pendelzeiten beträgt das arithmetische Mittel 650 ÷ 20 = 32,5 Minuten und der Median 30,5 Minuten. ax.axvline(32.5, color="black", linestyle="--"); ax.text(33.5, 6.5, "mean 32.5 min") markiert den Mittelwert, der rechts vom Median liegt, weil einzelne lange Pendelzeiten ihn erhöhen.

Balkenwerte: ax.bar_label(bars, fmt="%.0f") beschriftet die von ax.bar zurückgegebenen Balken. Bei Balken, die von pandas oder seaborn gezeichnet wurden, stehen die Balken in ax.containers, sodass ax.bar_label(ax.containers[0]) die erste Datenreihe beschriftet. padding=3 verschiebt die Beschriftungen um 3 Punkt von den Balkenenden weg.

Formen stammen aus matplotlib.patches: ax.add_patch(Rectangle((x, y), width, height, fill=False, edgecolor="red")) umrandet einen Bereich in Datenkoordinaten; Circle und Polygon funktionieren genauso.

Text lässt sich mit f-Strings aus den Daten berechnen, sodass Beschriftungen bei Änderungen der Daten korrekt bleiben: ax.text(..., f"mean {commutes['minutes'].mean():.1f} min"). Annotationen werden über den Daten gezeichnet; platziere sie in leeren Bereichen und verwende nur wenige, damit sie Wichtiges hervorheben.

fig.savefig("rainfall.png") speichert die Figure; die Dateiendung legt das Format fest: PNG und JPEG sind Rastergrafiken aus Pixeln, während SVG und PDF Vektorgrafiken aus Formen sind. format="pdf" legt das Format ausdrücklich fest.

Rastergrafiken haben eine feste Anzahl von Pixeln und werden beim Vergrößern unscharf; Vektordateien bleiben bei jeder Größe scharf und eignen sich für Berichte, Druck und Dokumente. PNG ist ein gutes Rasterformat für Diagramme im Web und auf Präsentationsfolien. Die JPEG-Kompression ist verlustbehaftet und lässt dünne Linien und Text unscharf werden, daher eignet sie sich schlecht für Diagramme.

Pixelgröße = Figure-Größe in Zoll × dpi (Punkte pro Zoll). fig, ax = plt.subplots(figsize=(8, 5)), mit dpi=150 gespeichert, ergibt 8 × 150 mal 5 × 150 = 1.200 × 750 Pixel. Ohne dpi verwendet savefig den dpi-Wert der Figure, standardmäßig 100, sodass dieselbe Figure 800 × 500 Pixel groß wird. Bei Vektorformaten beeinflusst dpi nur eingebettete Rasterteile.

Text- und Linienbreiten werden in Punkt festgelegt (1 Punkt = 1/72 Zoll), bezogen auf die Größe der Figure in Zoll. Ein höherer dpi-Wert fügt Pixel hinzu, ohne die relative Größe des Textes zum Diagramm zu ändern; ein größeres figsize macht den Text dagegen relativ kleiner. Wähle figsize für die endgültige Anzeigegröße und dpi für die Schärfe.

bbox_inches="tight" schneidet leere Ränder ab und schließt Elemente ein, die über die Figure hinausragen, etwa eine außerhalb des Axes platzierte Legende; das gespeicherte Bild ist dann etwas kleiner oder größer als Figure-Größe × dpi. pad_inches=0.1 legt den verbleibenden Rand fest.

transparent=True speichert ohne Hintergrund, was sich für Folien mit farbigem Hintergrund eignet; facecolor="white" erzwingt einen weißen Hintergrund. Das ist wichtig, wenn sonst ein dunkles Notebook-Gestaltungsschema in der Datei erscheinen würde.

plt.savefig speichert die aktuelle Figure, rufe es daher vor einem blockierenden plt.show() auf: Nach dem Schließen des Fensters verwaltet pyplot die Figure nicht mehr, und ein späteres plt.savefig(...) speichert eine neue, leere Figure. In einem Jupyter-Notebook gibt pyplot die Figure auch am Ende der Zelle frei, sodass plt.savefig in einer späteren Zelle ein leeres Bild speichert. Beide Probleme lassen sich vermeiden, indem du die Figure in einer Variablen behältst: fig.savefig(...) funktioniert auch nach plt.show() oder in einer späteren Notebook-Zelle.

Ergebnisse von seaborn werden auf dieselbe Weise gespeichert: ein Diagramm auf Axes-Ebene über seine Figure mit ax.figure.savefig("box.png", dpi=200) und ein Raster auf Figure-Ebene mit g.savefig("facets.png", dpi=200), das standardmäßig enge Begrenzungsrahmen verwendet.

for name, grp in rain.groupby("station"):
    grp = grp.sort_values("month_num")
    fig, ax = plt.subplots(figsize=(6, 4))
    ax.plot(grp["month_num"], grp["rain_mm"], marker="o")
    ax.set(title=name, xlabel="Month", ylabel="Rainfall (mm)")
    fig.savefig(f"rain_{name}.png", dpi=150, bbox_inches="tight")
    plt.close(fig)

. Das Schließen jeder Figure hält den Speicherbedarf gering und vermeidet die Warnung über mehr als 20 offene Figures.