Seaborn Histogram: Verteilungsdiagramme in Python erstellen

Name

Soren Atelier

Updated on 9.2.2026

Das Verständnis der Verteilung Ihrer Daten ist entscheidend für statistische Analysen und Entscheidungsfindung. Dennoch haben viele Datenfachleute Schwierigkeiten, klare, informative Verteilungsdiagramme zu erstellen, die Muster und Ausreißer aufdecken. Generische Plotting-Tools erfordern oft umfangreiche Anpassungen und erzeugen visuell unattraktive Ergebnisse.

Die Histogram-Funktionen von Seaborn lösen dieses Problem, indem sie eine High-Level-Schnittstelle zur Erstellung schöner Verteilungsdiagramme mit minimalem Code bereitstellen. Die Bibliothek wählt automatisch geeignete Standardwerte für Bin-Größen, Farben und Styling aus und gibt Ihnen gleichzeitig bei Bedarf eine fein abgestimmte Kontrolle.

Dieser Leitfaden behandelt alles, was Sie brauchen, um Histogramme in seaborn zu meistern, von grundlegenden Diagrammen bis zu fortgeschrittenen Anpassungstechniken. Sie lernen, wie Sie sns.histplot() und sns.displot() verwenden, Binning-Strategien steuern, KDE-Kurven überlagern, mehrere Verteilungen vergleichen und häufige Fallstricke vermeiden.

Was ist ein Histogram?

Ein Histogram zeigt die Verteilung einer kontinuierlichen Variablen an, indem der Datenbereich in Bins unterteilt und die Anzahl der Beobachtungen in jedem Bin gezählt wird. Die Höhe jedes Balkens repräsentiert die Häufigkeit oder Dichte der Datenpunkte innerhalb dieses Bin-Bereichs.

Histogramme helfen Ihnen dabei, Folgendes zu identifizieren:

• Die zentrale Tendenz (wo sich die meisten Werte gruppieren)
• Die Streuung und Variabilität der Daten
• Schiefe und Ausreißer
• Multi-modale Verteilungen (mehrere Spitzen)

Seaborn bietet zwei Hauptfunktionen zum Erstellen von Histogrammen: histplot() für Achsen-Level-Diagramme und displot() für Figuren-Level-Diagramme mit automatischer Facetting-Unterstützung.

Grundlegendes Histogram mit sns.histplot()

Die Funktion histplot() ist das primäre Werkzeug zum Erstellen von Histogrammen in seaborn. Sie bietet eine einfache Schnittstelle mit leistungsstarken Anpassungsoptionen.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
# Beispieldaten generieren
np.random.seed(42)
data = np.random.normal(100, 15, 1000)
 
# Grundlegendes Histogram erstellen
sns.histplot(data=data)
plt.title('Grundlegendes Seaborn Histogram')
plt.xlabel('Wert')
plt.ylabel('Anzahl')
plt.show()

Dies erstellt ein Histogram mit automatisch bestimmten Bin-Größen basierend auf der Freedman-Diaconis-Regel, die Details und Rauschen ausbalanciert.

Für Daten in einem DataFrame:

import pandas as pd
 
# DataFrame erstellen
df = pd.DataFrame({
    'values': np.random.normal(100, 15, 1000),
    'category': np.random.choice(['A', 'B', 'C'], 1000)
})
 
# Histogram aus DataFrame plotten
sns.histplot(data=df, x='values')
plt.show()

Steuerung von Bins: Größe, Anzahl und Bereich

Die Bin-Auswahl beeinflusst dramatisch, wie Ihr Histogram Muster offenbart. Zu wenige Bins vereinfachen die Verteilung zu stark, während zu viele Bins Rauschen erzeugen.

Anzahl der Bins angeben

# Histogram mit 30 Bins erstellen
sns.histplot(data=data, bins=30)
plt.title('Histogram mit 30 Bins')
plt.show()

Bin-Breite festlegen

# Spezifische Bin-Breite festlegen
sns.histplot(data=data, binwidth=5)
plt.title('Histogram mit Bin-Breite = 5')
plt.show()

Bin-Kanten definieren

# Benutzerdefinierte Bin-Kanten
bin_edges = [70, 80, 90, 100, 110, 120, 130]
sns.histplot(data=data, bins=bin_edges)
plt.title('Histogram mit benutzerdefinierten Bin-Kanten')
plt.show()

Bin-Bereich steuern

# Histogram-Bereich begrenzen
sns.histplot(data=data, binrange=(80, 120))
plt.title('Histogram mit begrenztem Bereich (80-120)')
plt.show()

KDE-Overlay hinzufügen

Kernel Density Estimation (KDE) bietet eine glatte Schätzung der Wahrscheinlichkeitsdichtefunktion und hilft Ihnen, die Gesamtform der Verteilung zu sehen.

# Histogram mit KDE-Overlay
sns.histplot(data=data, kde=True)
plt.title('Histogram mit KDE-Overlay')
plt.show()

Sie können auch nur die KDE-Kurve anzeigen:

# Nur KDE (keine Histogram-Balken)
sns.kdeplot(data=data)
plt.title('Nur KDE-Kurve')
plt.show()

Oder mehrere Visualisierungen kombinieren:

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# Nur Histogram
sns.histplot(data=data, ax=axes[0])
axes[0].set_title('Nur Histogram')
 
# Nur KDE
sns.kdeplot(data=data, ax=axes[1])
axes[1].set_title('Nur KDE')
 
# Beide kombiniert
sns.histplot(data=data, kde=True, ax=axes[2])
axes[2].set_title('Histogram + KDE')
 
plt.tight_layout()
plt.show()

Den stat-Parameter verstehen

Der stat-Parameter steuert, welche Statistik für jedes Bin berechnet wird, und beeinflusst die Interpretation der y-Achse.

fig, axes = plt.subplots(2, 3, figsize=(15, 8))
 
stats = ['count', 'frequency', 'density', 'probability', 'percent']
 
for idx, stat_type in enumerate(stats):
    ax = axes[idx // 3, idx % 3]
    sns.histplot(data=data, stat=stat_type, kde=True, ax=ax)
    ax.set_title(f'stat="{stat_type}"')
 
# Zusätzlichen Subplot entfernen
fig.delaxes(axes[1, 2])
 
plt.tight_layout()
plt.show()

Verwenden Sie density, wenn Sie Verteilungen mit unterschiedlichen Stichprobengrößen vergleichen, da es das Histogram so normalisiert, dass die Gesamtfläche 1 ergibt.

Vergleich mehrerer Verteilungen mit hue

Der hue-Parameter ermöglicht es Ihnen, Verteilungen über verschiedene Kategorien in einem einzigen Diagramm zu vergleichen.

# Multi-Kategorie-Daten erstellen
df = pd.DataFrame({
    'values': np.concatenate([
        np.random.normal(90, 10, 500),
        np.random.normal(105, 12, 500),
        np.random.normal(100, 8, 500)
    ]),
    'group': ['A'] * 500 + ['B'] * 500 + ['C'] * 500
})
 
# Mit hue plotten
sns.histplot(data=df, x='values', hue='group', kde=True)
plt.title('Mehrere Verteilungen nach Gruppe')
plt.show()

Overlay-Verhalten mit multiple steuern

Der multiple-Parameter bestimmt, wie mehrere Verteilungen angezeigt werden:

fig, axes = plt.subplots(2, 2, figsize=(12, 10))
 
multiple_types = ['layer', 'dodge', 'stack', 'fill']
 
for idx, mult_type in enumerate(multiple_types):
    ax = axes[idx // 2, idx % 2]
    sns.histplot(data=df, x='values', hue='group',
                 multiple=mult_type, ax=ax)
    ax.set_title(f'multiple="{mult_type}"')
 
plt.tight_layout()
plt.show()

Verwendung von sns.displot() für Figuren-Level-Diagramme

Während histplot() eine Achsen-Level-Funktion ist, ist displot() eine Figuren-Level-Funktion, die zusätzliche Funktionen wie automatisches Facetting bietet.

# Grundlegendes displot (erstellt gesamte Figur)
sns.displot(data=df, x='values', hue='group', kde=True)
plt.show()

Vorteile von displot()

1. Automatisches Facetting mit col- und row-Parametern
2. Konsistente Größe über Subplots hinweg
3. Legende außerhalb des Plots standardmäßig
4. Einfacher Wechsel zwischen Histogram, KDE und ECDF

# Facetting-Dimension hinzufügen
df['dataset'] = np.random.choice(['Train', 'Test'], len(df))
 
# Facettiertes Diagramm erstellen
sns.displot(data=df, x='values', hue='group',
            col='dataset', kde=True, height=4, aspect=1.2)
plt.show()

Plot-Typen mit kind wechseln

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# Histogram
sns.displot(data=df, x='values', kind='hist', kde=True)
plt.title('kind="hist"')
 
# KDE
sns.displot(data=df, x='values', kind='kde')
plt.title('kind="kde"')
 
# ECDF (Empirical Cumulative Distribution Function)
sns.displot(data=df, x='values', kind='ecdf')
plt.title('kind="ecdf"')
 
plt.tight_layout()
plt.show()

Funktionsvergleichstabelle

Empfehlung: Verwenden Sie histplot(), wenn Sie mehrere Subplots mit plt.subplots() erstellen. Verwenden Sie displot() für eigenständige Visualisierungen oder wenn Sie Facetting benötigen.

histplot() Parameter-Referenz

Erweiterte Anpassung

Benutzerdefinierte Farben und Styling

# Benutzerdefinierte Farben für jede Kategorie
custom_palette = {'A': '#FF6B6B', 'B': '#4ECDC4', 'C': '#45B7D1'}
 
sns.histplot(data=df, x='values', hue='group',
             palette=custom_palette, alpha=0.6,
             edgecolor='black', linewidth=1.5)
plt.title('Benutzerdefiniert gefärbtes Histogram')
plt.show()

Kantenfarben und Transparenz

# Bin-Kanten betonen
sns.histplot(data=data, bins=20, edgecolor='black',
             linewidth=2, alpha=0.7, color='skyblue')
plt.title('Histogram mit prominenten Kanten')
plt.show()

Logarithmische Skala

Für Daten, die mehrere Größenordnungen umfassen, verwenden Sie logarithmische Skalen:

# Log-normale Daten generieren
log_data = np.random.lognormal(3, 1, 1000)
 
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Lineare Skala
sns.histplot(data=log_data, ax=axes[0])
axes[0].set_title('Lineare Skala')
 
# Log-Skala
sns.histplot(data=log_data, log_scale=True, ax=axes[1])
axes[1].set_title('Log-Skala')
 
plt.tight_layout()
plt.show()

Kumulative Verteilungen

Kumulative Histogramme zeigen die laufende Summe der Beobachtungen bis zu jedem Bin:

# Kumulatives Histogram
sns.histplot(data=data, cumulative=True, stat='density',
             element='step', fill=False)
plt.title('Kumulative Verteilung')
plt.ylabel('Kumulative Dichte')
plt.show()

Dies ist nützlich, um Perzentile zu bestimmen und Verteilungen zu vergleichen.

Visuelles Element ändern

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
elements = ['bars', 'step', 'poly']
 
for ax, elem in zip(axes, elements):
    sns.histplot(data=data, element=elem, kde=True, ax=ax)
    ax.set_title(f'element="{elem}"')
 
plt.tight_layout()
plt.show()

Bivariate Histogramme (2D-Histogramme)

Seaborn kann 2D-Histogramme erstellen, um die gemeinsame Verteilung zweier Variablen zu visualisieren:

# Korrelierte 2D-Daten generieren
np.random.seed(42)
x = np.random.normal(100, 15, 1000)
y = x + np.random.normal(0, 10, 1000)
 
# 2D-Histogram
sns.histplot(x=x, y=y, bins=30, cbar=True)
plt.title('2D-Histogram (Bivariate Verteilung)')
plt.show()

Mit KDE für bivariate Analyse kombinieren

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
 
# 2D-Histogram
sns.histplot(x=x, y=y, bins=30, cbar=True, ax=axes[0])
axes[0].set_title('2D-Histogram')
 
# KDE-Konturdiagramm
sns.kdeplot(x=x, y=y, fill=True, cmap='viridis', ax=axes[1])
axes[1].set_title('2D-KDE-Diagramm')
 
plt.tight_layout()
plt.show()

Bivariat mit Hue

# Kategorie hinzufügen
categories = np.random.choice(['Gruppe 1', 'Gruppe 2'], 1000)
 
sns.histplot(x=x, y=y, hue=categories, bins=20)
plt.title('2D-Histogram mit Hue')
plt.show()

Häufige Fehler und wie man sie vermeidet

Fehler 1: Zu viele oder zu wenige Bins verwenden

Problem: Überglättung verbirgt Muster, während zu viele Bins Rauschen erzeugen.

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# Zu wenige Bins
sns.histplot(data=data, bins=5, ax=axes[0])
axes[0].set_title('Zu wenige Bins (5) - Übergeglättet')
 
# Gute Anzahl
sns.histplot(data=data, bins=30, ax=axes[1])
axes[1].set_title('Geeignete Bins (30)')
 
# Zu viele Bins
sns.histplot(data=data, bins=100, ax=axes[2])
axes[2].set_title('Zu viele Bins (100) - Verrauscht')
 
plt.tight_layout()
plt.show()

Lösung: Beginnen Sie mit automatischer Bin-Auswahl und passen Sie dann basierend auf Ihren Datenmerkmalen an. Verwenden Sie Sturges-Regel (bins = log2(n) + 1) für Normalverteilungen oder Freedman-Diaconis-Regel für schiefe Daten.

Fehler 2: Verteilungen mit unterschiedlichen Stichprobengrößen vergleichen

Problem: Rohe Zählungen erschweren den Vergleich von Verteilungen mit unterschiedlichen Gesamtbeobachtungen.

# Unterschiedliche Stichprobengrößen
small_sample = np.random.normal(100, 15, 200)
large_sample = np.random.normal(100, 15, 2000)
 
df_samples = pd.DataFrame({
    'value': np.concatenate([small_sample, large_sample]),
    'sample': ['Klein (n=200)'] * 200 + ['Groß (n=2000)'] * 2000
})
 
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Falsch: count verwenden
sns.histplot(data=df_samples, x='value', hue='sample',
             stat='count', ax=axes[0])
axes[0].set_title('Falsch: Count (Schwer zu vergleichen)')
 
# Richtig: density verwenden
sns.histplot(data=df_samples, x='value', hue='sample',
             stat='density', common_norm=False, ax=axes[1])
axes[1].set_title('Richtig: Density (Einfach zu vergleichen)')
 
plt.tight_layout()
plt.show()

Lösung: Verwenden Sie stat='density' oder stat='probability' und setzen Sie common_norm=False.

Fehler 3: Überlappende Verteilungen ignorieren

Problem: Der Standard-Layer-Modus mit hoher Opazität macht Überlappungen unsichtbar.

fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Schlecht: undurchsichtige Balken verbergen Überlappungen
sns.histplot(data=df, x='values', hue='group',
             alpha=1.0, ax=axes[0])
axes[0].set_title('Schlecht: Undurchsichtige Balken')
 
# Gut: Transparenz zeigt Überlappungen
sns.histplot(data=df, x='values', hue='group',
             alpha=0.5, ax=axes[1])
axes[1].set_title('Gut: Transparente Balken')
 
plt.tight_layout()
plt.show()

Lösung: Verwenden Sie alpha=0.5 für Transparenz oder multiple='dodge', um Balken nebeneinander zu platzieren.

Fehler 4: Achsen nicht richtig beschriften

Problem: Unklar, was die y-Achse repräsentiert, besonders bei Verwendung unterschiedlicher stat-Werte.

# Gute Praxis: klare Beschriftungen
sns.histplot(data=data, stat='density', kde=True)
plt.title('Verteilung der Werte')
plt.xlabel('Wert')
plt.ylabel('Dichte')
plt.show()

Lösung: Beschriften Sie Achsen immer klar, besonders die y-Achse bei Verwendung von stat='density' oder stat='probability'.

Fehler 5: Veraltetes distplot() verwenden

Problem: Alter Code verwendet distplot(), das veraltet und weniger flexibel ist.

# Alter Weg (veraltet)
# sns.distplot(data)  # Nicht verwenden
 
# Neuer Weg
sns.histplot(data=data, kde=True)
plt.show()

Lösung: Migrieren Sie zu histplot() für Histogramme oder kdeplot() für KDE-Kurven.

Daten interaktiv mit PyGWalker visualisieren

Während seaborn hervorragende statische Histogram-Visualisierungen bietet, bietet PyGWalker eine interaktive Alternative, mit der Sie Verteilungen dynamisch erkunden können. PyGWalker transformiert Ihren pandas DataFrame in eine interaktive Tableau-ähnliche Oberfläche, in der Sie Histogramme erstellen, Binning anpassen und zwischen Visualisierungstypen wechseln können, ohne Code zu schreiben.

import pygwalker as pyg
import pandas as pd
import numpy as np
 
# Beispieldaten erstellen
df = pd.DataFrame({
    'values': np.random.normal(100, 15, 1000),
    'category': np.random.choice(['A', 'B', 'C'], 1000),
    'score': np.random.uniform(0, 100, 1000)
})
 
# Interaktiven Explorer starten
pyg.walk(df)

PyGWalker-Vorteile für Histogram-Analysen:

• Drag-and-Drop-Oberfläche: Erstellen Sie Histogramme, indem Sie Variablen auf Regale ziehen
• Dynamisches Binning: Passen Sie Bin-Anzahlen interaktiv mit Schiebereglern an
• Multi-Variablen-Exploration: Wechseln Sie schnell zwischen Variablen, um Verteilungen zu vergleichen
• Export-Funktionen: Speichern Sie Erkenntnisse als Bilder oder teilen Sie interaktive Berichte
• Keine Programmierung erforderlich: Nicht-technische Teammitglieder können Daten selbstständig erkunden

Besuchen Sie github.com/Kanaries/pygwalker (opens in a new tab), um mit interaktiver Datenvisualisierung zu beginnen.

Praxisbeispiel: Analyse von Prüfungsergebnissen

Wenden wir Histogram-Techniken an, um Prüfungsergebnisverteilungen über verschiedene Klassen hinweg zu analysieren:

# Realistische Prüfungsdaten generieren
np.random.seed(42)
n_students = 500
 
exam_data = pd.DataFrame({
    'score': np.concatenate([
        np.random.normal(75, 10, 200),  # Klasse A
        np.random.normal(68, 15, 150),  # Klasse B
        np.random.normal(82, 8, 150)    # Klasse C
    ]),
    'class': ['Klasse A'] * 200 + ['Klasse B'] * 150 + ['Klasse C'] * 150,
    'study_hours': np.random.uniform(0, 40, n_students)
})
 
# Ergebnisse auf gültigen Bereich beschränken
exam_data['score'] = exam_data['score'].clip(0, 100)
 
# Umfassende Visualisierung erstellen
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
 
# Gesamtverteilung mit KDE
sns.histplot(data=exam_data, x='score', kde=True,
             bins=30, ax=axes[0, 0])
axes[0, 0].set_title('Gesamtergebnisverteilung')
axes[0, 0].axvline(exam_data['score'].mean(), color='red',
                    linestyle='--', label=f'Mittelwert: {exam_data["score"].mean():.1f}')
axes[0, 0].legend()
 
# Klassen vergleichen
sns.histplot(data=exam_data, x='score', hue='class',
             stat='density', common_norm=False,
             alpha=0.5, bins=25, ax=axes[0, 1])
axes[0, 1].set_title('Ergebnisverteilung nach Klasse')
 
# Gestapelte Ansicht für Proportionen
sns.histplot(data=exam_data, x='score', hue='class',
             multiple='stack', bins=25, ax=axes[1, 0])
axes[1, 0].set_title('Gestapelte Verteilung (Gesamtzahlen)')
 
# Kumulative Verteilungen
sns.histplot(data=exam_data, x='score', hue='class',
             stat='density', element='step', fill=False,
             cumulative=True, common_norm=False, ax=axes[1, 1])
axes[1, 1].set_title('Kumulative Verteilung nach Klasse')
 
plt.tight_layout()
plt.show()
 
# Zusammenfassende Statistiken ausgeben
print(exam_data.groupby('class')['score'].describe())

Dieses Beispiel demonstriert:

• Gesamtverteilungsanalyse mit Mittelwert-Referenzlinie
• Dichtevergleich normalisiert für unterschiedliche Klassengrößen
• Gestapelte Visualisierung, die den Beitrag jeder Klasse zeigt
• Kumulative Verteilungen für Perzentilanalyse

FAQ

Wie wähle ich die richtige Anzahl von Bins für mein Histogram?

Die optimale Anzahl von Bins hängt von Ihrer Datengröße und -verteilung ab. Die automatische Bin-Auswahl von Seaborn (basierend auf der Freedman-Diaconis-Regel) funktioniert für die meisten Fälle gut. Für manuelle Auswahl verwenden Sie Sturges-Regel: bins = log2(n) + 1 für Normalverteilungen (typischerweise 10-20 Bins für 1000 Samples) oder Quadratwurzel-Regel: bins = sqrt(n) für allgemeine Daten. Experimentieren Sie mit verschiedenen Werten und wählen Sie denjenigen, der Muster offenbart, ohne übermäßiges Rauschen zu erzeugen. Verwenden Sie binwidth anstelle von bins, wenn Sie konsistente Bin-Größen über mehrere Plots zum Vergleich benötigen.

Was ist der Unterschied zwischen histplot und displot in seaborn?

histplot() ist eine Achsen-Level-Funktion, die auf ein bestimmtes matplotlib-Achsen-Objekt plottet und somit für die Erstellung komplexer Multi-Plot-Figuren mit plt.subplots() geeignet ist. displot() ist eine Figuren-Level-Funktion, die eine gesamte Figur erstellt und automatisches Facetting mit col- und row-Parametern unterstützt. Verwenden Sie histplot(), wenn Sie Histogramme in bestehende matplotlib-Figuren mit mehreren Subplots integrieren. Verwenden Sie displot() für eigenständige Visualisierungen oder wenn Sie facettierte Plots über mehrere kategoriale Variablen erstellen müssen. Beide Funktionen unterstützen dieselben Kernparameter zur Steuerung von Bins, KDE, Hue und Statistiken.

Sollte ich stat='density' oder stat='probability' für mein Histogram verwenden?

Verwenden Sie stat='density', wenn die Histogram-Fläche 1 ergeben soll, was es mit Wahrscheinlichkeitsdichtefunktionen vergleichbar macht und ideal zum Überlagern theoretischer Verteilungen ist. Verwenden Sie stat='probability' (oder stat='percent'), wenn Sie die y-Achse als Anteil der Daten in jedem Bin interpretieren möchten, wobei alle Bin-Höhen 1 (oder 100%) ergeben. Wählen Sie stat='density' zum Vergleichen von Verteilungen mit unterschiedlichen Stichprobengrößen oder bei statistischen Analysen. Wählen Sie stat='probability' für intuitivere Interpretation in Präsentationen oder bei der Erklärung von Ergebnissen an nicht-technische Zielgruppen.

Wie erstelle ich ein Histogram mit mehreren überlappenden Verteilungen?

Verwenden Sie den hue-Parameter, um eine kategoriale Variable anzugeben, die Ihre Daten in Gruppen aufteilt. Steuern Sie das Overlay-Verhalten mit dem multiple-Parameter: verwenden Sie 'layer' (Standard) für transparente überlappende Balken, 'dodge' für nebeneinander stehende Balken, 'stack' für vertikal gestapelte Balken, die Gesamtwerte zeigen, oder 'fill' für normalisierte gestapelte Balken, die Proportionen zeigen. Setzen Sie alpha=0.5, um überlappende Bereiche sichtbar zu machen. Verwenden Sie beim Vergleich von Verteilungen mit unterschiedlichen Stichprobengrößen immer stat='density' oder stat='probability' mit common_norm=False, um einen fairen Vergleich zu gewährleisten. Fügen Sie KDE-Kurven mit kde=True hinzu, um die Gesamtform jeder Verteilung hervorzuheben.

Warum ist seaborns distplot veraltet und was sollte ich stattdessen verwenden?

Seaborn hat distplot() in Version 0.11.0 als veraltet markiert, da es mehrere Funktionalitäten in einer einzigen Funktion mit inkonsistenter Parameterbenennung kombinierte. Die Ersatzfunktionen bieten klarere Schnittstellen und mehr Flexibilität: verwenden Sie histplot() für Histogramme, kdeplot() für Kernel-Dichteschätzung, ecdfplot() für empirische kumulative Verteilungsfunktionen und rugplot() für Rug-Plots. Diese neuen Funktionen bieten bessere Parameternamen, mehr Anpassungsoptionen, native Unterstützung für Hue-basierte Gruppierung und konsistentes Verhalten mit anderen seaborn-Funktionen. Um alten Code zu migrieren, ersetzen Sie sns.distplot(data) durch sns.histplot(data, kde=True) für den häufigsten Anwendungsfall.

Fazit

Seaborn-Histogramme bieten eine leistungsstarke und flexible Möglichkeit, Datenverteilungen mit minimalem Code zu visualisieren. Die Funktion histplot() bietet eine feinkörnige Kontrolle über Binning, Statistiken und Gruppierung, während displot() facettierte Visualisierungen vereinfacht. Durch die Beherrschung von Parametern wie bins, stat, hue und multiple können Sie Verteilungsdiagramme in Publikationsqualität erstellen, die Muster, Ausreißer und Unterschiede zwischen Gruppen aufdecken.

Wichtige Erkenntnisse:

• Verwenden Sie automatische Bin-Auswahl für die erste Erkundung und passen Sie dann für Klarheit an
• Wenden Sie stat='density' an, wenn Sie Verteilungen mit unterschiedlichen Stichprobengrößen vergleichen
• Nutzen Sie hue- und multiple-Parameter, um mehrere Verteilungen effektiv zu vergleichen
• Fügen Sie KDE-Overlays hinzu, um glatte Verteilungsformen zu zeigen
• Wählen Sie histplot() für die Integration mit matplotlib-Subplots und displot() für eigenständige facettierte Plots

Ob Sie Prüfungsergebnisse, wissenschaftliche Messungen oder Geschäftsmetriken analysieren, Seaborn-Histogramme helfen Ihnen, Ihre Datenverteilung zu verstehen und Erkenntnisse effektiv zu kommunizieren. Kombinieren Sie diese Techniken mit interaktiven Tools wie PyGWalker für umfassende explorative Datenanalysen.