Seaborn Barplot: Der vollständige Leitfaden zu Balkendiagrammen in Python

Name

Soren Atelier

Updated on 9.2.2026

Sie müssen Durchschnittswerte über Kategorien hinweg vergleichen. Vielleicht ist es der durchschnittliche Umsatz nach Region, mittlere Testergebnisse nach Klassenzimmer oder die mediane Antwortzeit nach Server. Eine rohe Zahlentabelle zwingt Sie, Zeilen zu scannen und im Kopf zu rechnen. Ein gut konstruiertes Balkendiagramm macht die Antwort auf einen Blick offensichtlich -- und Pythons seaborn-Bibliothek lässt Sie eines mit einem einzigen Funktionsaufruf erstellen.

Das Problem ist, dass sns.barplot() einen überraschend umfangreichen Satz an Parametern hat. Gruppierung mit hue, Kontrolle der Fehlerbalken, Neuordnung von Kategorien, Auswahl von Farbpaletten, horizontale Darstellung -- jeder dieser Aspekte bringt Anfänger und selbst erfahrene Benutzer ins Stolpern, die die Funktion eine Weile nicht benutzt haben. Schlecht konfigurierte Balkendiagramme führen Leser in die Irre oder sehen einfach schlecht aus.

Dieser Leitfaden deckt jeden praktischen Anwendungsfall für sns.barplot() ab. Jeder Codeblock ist zum Kopieren und Einfügen bereit, verwendet echte oder realistische Datensätze und erzeugt saubere Ausgaben. Am Ende werden Sie wissen, wie Sie publikationsreife Balkendiagramme erstellen, den Unterschied zwischen barplot und countplot verstehen und einen schnellen Weg zur interaktiven Exploration mit PyGWalker haben.

Was sns.barplot() macht

sns.barplot() zeichnet ein Balkendiagramm, bei dem die Höhe (oder Länge) jedes Balkens die zentrale Tendenz einer numerischen Variable für jede Kategorie darstellt. Standardmäßig berechnet es den Mittelwert und zeichnet ein 95%-Konfidenzintervall als Fehlerbalken auf jeden Balken.

Dies unterscheidet es von einem einfachen zählbasierten Balkendiagramm. Es ist eine statistische Visualisierung: Es aggregiert Ihre Daten vor dem Plotten.

Grundlegende Syntax

import seaborn as sns
import matplotlib.pyplot as plt
 
sns.barplot(data=df, x="category_column", y="numeric_column")
plt.show()

Wichtige Parameter auf einen Blick:

Einfaches vertikales Balkendiagramm

Beginnen Sie mit dem integrierten tips-Datensatz. Dieser DataFrame enthält Restaurantrechnungen, Trinkgelder und Kundenattribute.

import seaborn as sns
import matplotlib.pyplot as plt
 
tips = sns.load_dataset("tips")
 
plt.figure(figsize=(8, 5))
sns.barplot(data=tips, x="day", y="total_bill")
plt.title("Average Total Bill by Day")
plt.ylabel("Average Total Bill ($)")
plt.xlabel("Day of Week")
plt.tight_layout()
plt.show()

Jeder Balken zeigt den Mittelwert von total_bill für diesen Tag. Die schwarzen Linien oben sind 95%-Konfidenzintervalle, die Ihnen ein Gefühl dafür geben, wie stark der Mittelwert variieren könnte. Donnerstag hat die niedrigste durchschnittliche Rechnung, während Sonntag tendenziell höher liegt.

Um die Aggregationsfunktion zu ändern, übergeben Sie estimator:

import numpy as np
 
sns.barplot(data=tips, x="day", y="total_bill", estimator=np.median)
plt.title("Median Total Bill by Day")
plt.show()

Horizontales Balkendiagramm

Horizontale Balken funktionieren besser, wenn Kategoriebeschriftungen lang sind oder wenn Sie viele Kategorien haben. Es gibt zwei Möglichkeiten, einen horizontalen Barplot zu erstellen.

Option 1: x und y tauschen.

plt.figure(figsize=(8, 5))
sns.barplot(data=tips, x="total_bill", y="day")
plt.title("Average Total Bill by Day (Horizontal)")
plt.xlabel("Average Total Bill ($)")
plt.ylabel("")
plt.tight_layout()
plt.show()

Wenn die numerische Spalte auf x und die kategoriale Spalte auf y liegt, zeichnet seaborn automatisch horizontale Balken.

Option 2: Den orient-Parameter verwenden.

sns.barplot(data=tips, x="total_bill", y="day", orient="h")
plt.show()

Beide Ansätze liefern das gleiche Ergebnis. Das Tauschen von x und y ist das häufigere Muster.

Gruppiertes (Hue) Balkendiagramm

Der hue-Parameter teilt jeden Kategoriebalken in Unterbalken basierend auf einer zweiten kategorialen Variable auf. Dies ist essentiell für den Vergleich von Untergruppen nebeneinander.

plt.figure(figsize=(9, 5))
sns.barplot(data=tips, x="day", y="total_bill", hue="sex")
plt.title("Average Total Bill by Day and Gender")
plt.ylabel("Average Total Bill ($)")
plt.legend(title="Gender")
plt.tight_layout()
plt.show()

Jeder Tag zeigt nun zwei Balken -- einen für männlich, einen für weiblich. Die Legende ordnet Farben Gruppen zu. Sie können sofort sehen, dass männliche Kunden an den meisten Tagen tendenziell leicht höhere Durchschnittsrechnungen haben.

Bei drei oder mehr Hue-Stufen werden die Balken schmaler. Wenn die Lesbarkeit leidet, ziehen Sie einen facettierten Ansatz mit sns.catplot() in Betracht:

g = sns.catplot(data=tips, x="day", y="total_bill", hue="sex",
                col="time", kind="bar", height=4, aspect=1.2)
g.set_axis_labels("Day", "Average Total Bill ($)")
g.set_titles("{col_name}")
plt.tight_layout()
plt.show()

Dies erstellt separate Panels für Lunch und Dinner, jeweils mit gruppierten Balken nach Geschlecht -- viel einfacher zu lesen, wenn Sie mehrere Gruppierungsdimensionen haben.

Farben mit Palette anpassen

Der palette-Parameter steuert das Farbschema. Seaborn wird mit vielen eingebauten Paletten geliefert.

plt.figure(figsize=(8, 5))
sns.barplot(data=tips, x="day", y="total_bill", hue="sex",
            palette="Set2")
plt.title("Custom Palette: Set2")
plt.tight_layout()
plt.show()

Beliebte Palettenauswahl:

Sie können auch eine Liste spezifischer Hex-Farben übergeben:

sns.barplot(data=tips, x="day", y="total_bill",
            palette=["#2ecc71", "#e74c3c", "#3498db", "#f39c12"])
plt.show()

Oder verwenden Sie ein Dictionary, um bestimmte Kategorien Farben zuzuordnen:

day_colors = {"Thur": "#636e72", "Fri": "#e17055",
              "Sat": "#0984e3", "Sun": "#6c5ce7"}
sns.barplot(data=tips, x="day", y="total_bill", palette=day_colors)
plt.show()

Fehlerbalken und Konfidenzintervalle

Standardmäßig zeigt sns.barplot() ein 95%-Konfidenzintervall. Dies ist das bootstrapped CI um den Mittelwert. Sie haben volle Kontrolle darüber, was angezeigt wird.

import matplotlib.pyplot as plt
import seaborn as sns
 
tips = sns.load_dataset("tips")
 
fig, axes = plt.subplots(1, 4, figsize=(18, 4), sharey=True)
 
# 95% CI (default)
sns.barplot(data=tips, x="day", y="total_bill", errorbar=("ci", 95), ax=axes[0])
axes[0].set_title("95% CI (default)")
 
# Standard deviation
sns.barplot(data=tips, x="day", y="total_bill", errorbar="sd", ax=axes[1])
axes[1].set_title("Standard Deviation")
 
# Standard error
sns.barplot(data=tips, x="day", y="total_bill", errorbar="se", ax=axes[2])
axes[2].set_title("Standard Error")
 
# No error bars
sns.barplot(data=tips, x="day", y="total_bill", errorbar=None, ax=axes[3])
axes[3].set_title("No Error Bars")
 
plt.tight_layout()
plt.show()

Hinweis: In älteren Versionen von seaborn (vor 0.12) hieß der Parameter ci statt errorbar. Wenn Sie ci=95 in Legacy-Code sehen, macht es dasselbe. Modernes seaborn verwendet errorbar für mehr Flexibilität.

Balken sortieren

Standardmäßig erscheinen Balken in der Reihenfolge, in der die Kategorien in Ihren Daten vorkommen. Verwenden Sie den order-Parameter, um dies explizit zu steuern.

plt.figure(figsize=(8, 5))
sns.barplot(data=tips, x="day", y="total_bill",
            order=["Thur", "Fri", "Sat", "Sun"])
plt.title("Bars in Chronological Order")
plt.tight_layout()
plt.show()

Um Balken nach ihrem Wert zu sortieren (größter zuerst), berechnen Sie zunächst die Mittelwerte:

day_order = tips.groupby("day")["total_bill"].mean().sort_values(ascending=False).index
 
plt.figure(figsize=(8, 5))
sns.barplot(data=tips, x="day", y="total_bill", order=day_order)
plt.title("Days Ordered by Average Bill (Descending)")
plt.tight_layout()
plt.show()

Dieses Muster -- Sortierung nach der aggregierten Metrik -- ist eine der häufigsten Methoden, um Balkendiagramme sofort informativ zu machen.

sns.barplot() vs sns.countplot() -- Wann welches verwenden

Diese beiden Funktionen sehen ähnlich aus, dienen aber unterschiedlichen Zwecken. Die falsche zu wählen ist eine häufige Quelle der Verwirrung.

Faustregel: Wenn Sie eine numerische Spalte haben, die Sie aggregieren möchten, verwenden Sie barplot. Wenn Sie nur zählen möchten, wie viele Zeilen in jede Kategorie fallen, verwenden Sie countplot.

fig, axes = plt.subplots(1, 2, figsize=(14, 5))
 
# barplot: average tip per day
sns.barplot(data=tips, x="day", y="tip", ax=axes[0])
axes[0].set_title("sns.barplot() -- Average Tip by Day")
axes[0].set_ylabel("Average Tip ($)")
 
# countplot: number of records per day
sns.countplot(data=tips, x="day", ax=axes[1])
axes[1].set_title("sns.countplot() -- Meals per Day")
axes[1].set_ylabel("Count")
 
plt.tight_layout()
plt.show()

Anpassung mit Matplotlib

Da seaborn auf matplotlib aufbaut, haben Sie vollen Zugriff auf die Anpassungsebene von matplotlib. So fügen Sie Titel hinzu, rotieren Beschriftungen, passen Schriften an und annotieren Balken.

Titel, Beschriftungen und Rotation

plt.figure(figsize=(8, 5))
ax = sns.barplot(data=tips, x="day", y="total_bill", palette="muted")
 
ax.set_title("Average Total Bill by Day", fontsize=16, fontweight="bold")
ax.set_xlabel("Day of the Week", fontsize=12)
ax.set_ylabel("Average Bill ($)", fontsize=12)
ax.tick_params(axis='x', rotation=45)
 
plt.tight_layout()
plt.show()

Wertbeschriftungen auf Balken hinzufügen

plt.figure(figsize=(8, 5))
ax = sns.barplot(data=tips, x="day", y="total_bill", errorbar=None,
                 palette="Blues_d",
                 order=["Thur", "Fri", "Sat", "Sun"])
 
# Annotate each bar with its value
for container in ax.containers:
    ax.bar_label(container, fmt="%.1f", fontsize=11, padding=3)
 
ax.set_title("Average Total Bill by Day")
ax.set_ylabel("Average Bill ($)")
ax.set_ylim(0, 25)
plt.tight_layout()
plt.show()

Die ax.bar_label()-Methode (hinzugefügt in matplotlib 3.4) ist der sauberste Weg, Wertannotationen hinzuzufügen. Das padding-Argument steuert den Abstand von der Balkenoberkante.

Gestapelte Balken (Workaround)

Seaborn unterstützt nativ keine gestapelten Balkendiagramme. Dies ist eine bewusste Designentscheidung -- gestapelte Balken erschweren den Vergleich einzelner Segmentgrößen. Wenn Ihr Anwendungsfall sie jedoch erfordert, können Sie den Effekt mit pandas-Plotting oder einem manuellen matplotlib-Ansatz erzielen.

Mit Pandas .plot(kind="bar", stacked=True)

import pandas as pd
import matplotlib.pyplot as plt
 
tips = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv")
 
# Pivot to get counts per day and time
pivot = tips.groupby(["day", "time"]).size().unstack(fill_value=0)
 
# Reorder days
pivot = pivot.loc[["Thur", "Fri", "Sat", "Sun"]]
 
pivot.plot(kind="bar", stacked=True, figsize=(8, 5),
           color=["#3498db", "#e74c3c"], edgecolor="white")
plt.title("Meal Count by Day (Stacked by Lunch/Dinner)")
plt.ylabel("Number of Meals")
plt.xlabel("Day")
plt.xticks(rotation=0)
plt.legend(title="Time")
plt.tight_layout()
plt.show()

Manuelles Stapeln mit Matplotlib

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
tips = sns.load_dataset("tips")
pivot = tips.groupby(["day", "time"])["total_bill"].mean().unstack(fill_value=0)
pivot = pivot.loc[["Thur", "Fri", "Sat", "Sun"]]
 
days = pivot.index
lunch = pivot["Lunch"].values
dinner = pivot["Dinner"].values
 
x = np.arange(len(days))
width = 0.6
 
fig, ax = plt.subplots(figsize=(8, 5))
ax.bar(x, lunch, width, label="Lunch", color="#3498db")
ax.bar(x, dinner, width, bottom=lunch, label="Dinner", color="#e74c3c")
 
ax.set_xticks(x)
ax.set_xticklabels(days)
ax.set_ylabel("Average Total Bill ($)")
ax.set_title("Average Bill by Day (Stacked: Lunch + Dinner)")
ax.legend()
plt.tight_layout()
plt.show()

Beide Ansätze funktionieren. Die pandas-Methode ist kompakter; die matplotlib-Methode gibt Ihnen mehr Kontrolle über Positionierung und Styling.

Interaktive Balkendiagramme mit PyGWalker erstellen

Statische Balkendiagramme sind großartig für Berichte und Arbeiten. Aber während der explorativen Analyse möchten Sie oft Achsen wechseln, verschiedene Aggregationen ausprobieren, Daten filtern und Diagrammtypen vergleichen -- alles ohne jedes Mal Code umschreiben zu müssen.

PyGWalker (opens in a new tab) (Python-Binding von Graphic Walker) verwandelt jeden pandas DataFrame in eine interaktive, Tableau-ähnliche Visualisierungsoberfläche direkt in Jupyter Notebook. Sie können Balkendiagramme, gruppierte Balkendiagramme und Dutzende anderer Diagrammtypen durch Drag-and-Drop von Feldern erstellen.

pip install pygwalker

import pandas as pd
import pygwalker as pyg
 
tips = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv")
walker = pyg.walk(tips)

Sobald die Oberfläche geladen ist, können Sie:

• day auf die X-Achse und total_bill auf die Y-Achse ziehen, um sofort ein Balkendiagramm zu erstellen.
• sex oder time in den Farbkanal ziehen, um ein gruppiertes Balkendiagramm zu erhalten.
• Die Aggregation von Mittelwert zu Summe, Median oder Anzahl mit einem einzigen Klick wechseln.
• Filter anwenden (z.B. nur Samstag und Sonntag) ohne pandas-Code schreiben zu müssen.
• Ihre Diagrammkonfiguration für Reproduzierbarkeit exportieren.

Dies ist besonders nützlich während der Explorationsphase -- testen Sie schnell, welche Gruppierungen und Aggregationen die meisten Erkenntnisse liefern, und fixieren Sie dann Ihre endgültige statische Visualisierung mit sns.barplot() zum Teilen.

Häufig gestellte Fragen

Wie ändere ich die Farbe einzelner Balken in sns.barplot()?

Übergeben Sie eine Liste von Farben an den palette-Parameter. Die Listenlänge sollte der Anzahl der Kategorien entsprechen. Zum Beispiel: sns.barplot(data=tips, x="day", y="total_bill", palette=["#e74c3c", "#3498db", "#2ecc71", "#f39c12"]). Sie können auch ein Dictionary übergeben, das Kategorienamen Farben zuordnet, für explizite Kontrolle.

Was ist der Unterschied zwischen sns.barplot() und plt.bar()?

sns.barplot() arbeitet direkt mit DataFrames, berechnet automatisch eine Aggregationsstatistik (Standard: Mittelwert) und zeichnet Konfidenzintervalle. plt.bar() von matplotlib erfordert vorberechnete Balkenhöhen und -positionen -- es zeichnet genau das, was Sie übergeben, ohne Aggregation. Verwenden Sie sns.barplot() für schnelle statistische Zusammenfassungen und plt.bar() für volle manuelle Kontrolle.

Wie entferne ich Fehlerbalken aus einem seaborn Barplot?

Setzen Sie errorbar=None im Funktionsaufruf: sns.barplot(data=tips, x="day", y="total_bill", errorbar=None). In seaborn-Versionen vor 0.12 verwenden Sie stattdessen ci=None.

Kann sns.barplot() die Summe statt des Mittelwerts anzeigen?

Ja. Übergeben Sie estimator=sum an die Funktion: sns.barplot(data=tips, x="day", y="total_bill", estimator=sum). Sie können jede Funktion verwenden, die ein Array nimmt und einen Skalar zurückgibt, einschließlich numpy.median, numpy.std oder ein benutzerdefiniertes Lambda.

Wie erstelle ich einen horizontalen Barplot in seaborn?

Platzieren Sie die numerische Spalte auf der x-Achse und die kategoriale Spalte auf y: sns.barplot(data=tips, x="total_bill", y="day"). Seaborn erkennt die Ausrichtung automatisch. Sie können auch explizit orient="h" setzen.

Fazit

Der seaborn Barplot ist der schnellste Weg, aggregierte Metriken über Kategorien hinweg in Python zu visualisieren. Von einer einzelnen Zeile, die Mittelwerte mit Konfidenzintervallen zeigt, über gruppierte Vergleiche mit hue, bis hin zu vollständig gestalteten Diagrammen mit Wertannotationen -- sns.barplot() deckt den gesamten Bereich der Balkendiagramm-Anforderungen ab.

Beginnen Sie einfach: Übergeben Sie Ihren DataFrame, wählen Sie Ihre x- und y-Spalten und lassen Sie seaborn die Aggregation und das Styling übernehmen. Dann fügen Sie nach Bedarf Anpassungen hinzu -- sortieren Sie Balken nach Wert, wechseln Sie zu einem horizontalen Layout für lange Beschriftungen oder deaktivieren Sie Fehlerbalken für sauberere Präsentationsfolien.

Wenn Sie gestapelte Balken benötigen, greifen Sie direkt auf pandas oder matplotlib zurück. Wenn Sie Ihre Daten interaktiv erkunden möchten, bevor Sie sich auf eine bestimmte Diagrammkonfiguration festlegen, bietet Ihnen PyGWalker (opens in a new tab) eine Drag-and-Drop-Oberfläche, die in Jupyter ohne zusätzlichen Code funktioniert.

Alle Codebeispiele in diesem Leitfaden sind bereit zum Kopieren und Ausführen. Wählen Sie das Muster, das Ihrem Anwendungsfall am nächsten kommt, tauschen Sie Ihre Daten ein, und Sie haben in weniger als einer Minute ein klares, informatives Balkendiagramm.