Python für Datenanalyse: Matplotlib, Seaborn und Visualisierung für Vorstellungsgespräche

Die Datenvisualisierung mit Python gehört zu den am häufigsten geprüften Fähigkeiten in Vorstellungsgesprächen für Datenanalyse-Positionen. Personalverantwortliche erwarten von Bewerbern, dass sie aus Rohdaten übersichtliche und lesbare Diagramme erstellen — und ihre Designentscheidungen unter Zeitdruck erklären können.

Dieses Tutorial behandelt Matplotlib 3.10 und Seaborn 0.13, die beiden Bibliotheken, die technische Interviews für Analysten- und Data-Science-Stellen dominieren. Alle Codebeispiele laufen direkt mit Python 3.12+.

Python-Umgebung für Datenvisualisierung einrichten

Bevor Diagrammcode geschrieben wird, benötigt die Umgebung die richtigen Abhängigkeiten. Eine saubere virtuelle Umgebung vermeidet Versionskonflikte zwischen Matplotlib, Seaborn und deren gemeinsamen NumPy/Pandas-Grundlagen.

# setup.sh
python -m venv venv
source venv/bin/activate
pip install matplotlib==3.10.8 seaborn==0.13.2 pandas numpy

Ein kurzer Test bestätigt, dass alles funktioniert:

# verify_install.py
import matplotlib
import seaborn as sns
import pandas as pd

print(f"Matplotlib: {matplotlib.__version__}")
print(f"Seaborn: {sns.__version__}")
print(f"Pandas: {pd.__version__}")

Mit festgelegten Abhängigkeiten konzentriert sich der nächste Schritt auf die Matplotlib-Grundlagen — das Fundament für jedes Seaborn-Diagramm.

Matplotlib-Grundlagen: Figure, Axes und die objektorientierte API

Matplotlib bietet zwei APIs: die pyplot-Zustandsmaschine und die objektorientierte (OO) Schnittstelle. Die OO-API ermöglicht explizite Kontrolle über jedes Element und ist der Standard in professionellen Codebasen und Interviews.

# bar_chart_oo.py
import matplotlib.pyplot as plt
import numpy as np

# Beispiel: Quartalsumsätze
quarters = ["Q1", "Q2", "Q3", "Q4"]
revenue = [42_000, 58_000, 51_000, 67_000]

# Figure und Axes explizit erstellen
fig, ax = plt.subplots(figsize=(8, 5))

# Balken mit bestimmter Farbe zeichnen
ax.bar(quarters, revenue, color="#2563eb", width=0.5)

# Achsen klar beschriften — darauf achten Interviewer
ax.set_xlabel("Quarter")
ax.set_ylabel("Revenue (USD)")
ax.set_title("Quarterly Revenue — 2025")

# Y-Achse mit Dollarbeträgen formatieren
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))

# Obere und rechte Rahmenlinien für ein sauberes Erscheinungsbild entfernen
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.savefig("quarterly_revenue.png", dpi=150)
plt.show()

Wichtige Details, auf die Interviewer achten: explizite fig, ax-Erstellung statt plt.plot(), lesbare Achsenbeschriftungen, formatierte Tick-Werte und entfernte überflüssige Rahmenelemente (unnötige Spines). Diese kleinen Entscheidungen signalisieren produktionsreifes Denken.

Subplots für vergleichende Analysen erstellen

In Interviews wird häufig verlangt, mehrere Metriken nebeneinander zu vergleichen. Die Funktion subplots() übernimmt dies mit einem Rasterlayout.

# subplots_comparison.py
import matplotlib.pyplot as plt
import numpy as np

months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
users = [1200, 1350, 1500, 1420, 1680, 1820]
revenue = [24_000, 27_000, 30_000, 28_400, 33_600, 36_400]

# Zwei nebeneinander liegende Diagramme mit unabhängigen y-Achsen
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5), sharey=False)

# Linkes Feld: Nutzerwachstum als Liniendiagramm
ax1.plot(months, users, marker="o", color="#2563eb", linewidth=2)
ax1.set_title("Monthly Active Users")
ax1.set_ylabel("Users")
ax1.spines[["top", "right"]].set_visible(False)

# Rechtes Feld: Umsatz als Balkendiagramm
ax2.bar(months, revenue, color="#16a34a", width=0.5)
ax2.set_title("Monthly Revenue")
ax2.set_ylabel("Revenue (USD)")
ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
ax2.spines[["top", "right"]].set_visible(False)

fig.suptitle("Product Metrics — H1 2025", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.savefig("product_metrics.png", dpi=150)
plt.show()

Die Verwendung von sharey=False ermöglicht eine unabhängige Skalierung jedes Panels — Umsatz in Dollar und Nutzerzahlen als Zählwerte haben unterschiedliche Größenordnungen. Der suptitle fügt einen übergreifenden Titel über beiden Subplots hinzu.

Statistische Seaborn-Diagramme: Von Verteilung bis Korrelation

Seaborn baut auf Matplotlib auf und ist auf statistische Visualisierung spezialisiert. Während Matplotlib manuelle Konfiguration erfordert, leitet Seaborn sinnvolle Standardeinstellungen aus der Datenstruktur ab.

Eine Verteilungsanalyse — eine der häufigsten Interviewaufgaben — erfordert nur einen einzigen Funktionsaufruf:

# distribution_analysis.py
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Gehaltsdaten für zwei Abteilungen simulieren
np.random.seed(42)
data = pd.DataFrame({
    "salary": np.concatenate([
        np.random.normal(75_000, 12_000, 200),  # Engineering
        np.random.normal(65_000, 10_000, 150),  # Marketing
    ]),
    "department": ["Engineering"] * 200 + ["Marketing"] * 150
})

# KDE-Plot zum Vergleich der Gehaltsverteilungen
fig, ax = plt.subplots(figsize=(10, 5))
sns.kdeplot(
    data=data,
    x="salary",
    hue="department",        # Automatische Aufteilung nach Kategorie
    fill=True,               # Schattierte Fläche unter der Kurve
    alpha=0.4,
    palette=["#2563eb", "#dc2626"],
    ax=ax                    # An unsere expliziten Axes anhängen
)

ax.set_title("Salary Distribution by Department")
ax.set_xlabel("Annual Salary (USD)")
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.savefig("salary_distribution.png", dpi=150)
plt.show()

Der hue-Parameter teilt die Daten automatisch auf, und fill=True macht überlappende Bereiche sichtbar. Dieses Muster — die Gruppierung von Verteilungen nach Kategorien — taucht in nahezu jedem Analyse-Interview auf.

Seaborn-Heatmaps für Korrelationsmatrizen

Korrelations-Heatmaps zeigen Beziehungen zwischen numerischen Variablen auf einen Blick. Interviewer nutzen sie, um zu testen, ob Bewerber Multikollinearität erkennen oder starke Feature-Beziehungen identifizieren können.

# correlation_heatmap.py
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# E-Commerce-Metriken simulieren
np.random.seed(42)
n = 500
page_views = np.random.poisson(15, n)
time_on_site = page_views * 2.5 + np.random.normal(0, 5, n)
cart_adds = np.random.binomial(page_views, 0.3)
purchases = np.random.binomial(cart_adds, 0.4)

df = pd.DataFrame({
    "page_views": page_views,
    "time_on_site": time_on_site,
    "cart_adds": cart_adds,
    "purchases": purchases
})

# Pearson-Korrelation berechnen
corr_matrix = df.corr()

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(
    corr_matrix,
    annot=True,              # Korrelationswerte in Zellen anzeigen
    fmt=".2f",               # Zwei Dezimalstellen
    cmap="RdBu_r",           # Divergierende Farbpalette zentriert auf 0
    vmin=-1, vmax=1,         # Feste Skala für Konsistenz
    square=True,             # Quadratische Zellen
    linewidths=0.5,
    ax=ax
)

ax.set_title("E-commerce Metrics Correlation")
plt.tight_layout()
plt.savefig("correlation_heatmap.png", dpi=150)
plt.show()

Die divergierende RdBu_r-Farbpalette stellt positive Korrelationen blau und negative rot dar — eine Konvention, die Interviewer erwarten. Die Einstellung vmin=-1 und vmax=1 stellt sicher, dass die Farbskala unabhängig vom tatsächlichen Datenbereich interpretierbar bleibt.

Diagramme für professionelle Präsentationen gestalten

Die Standardausgabe von Matplotlib wirkt veraltet. Einige wenige Konfigurationszeilen verwandeln Diagramme in präsentationsreife Visualisierungen, die im Interview Detailbewusstsein demonstrieren.

# professional_styling.py
import matplotlib.pyplot as plt
import seaborn as sns

# Seaborns integriertes Theme anwenden
sns.set_theme(
    style="whitegrid",       # Sauberer Hintergrund mit Gitterlinien
    palette="muted",         # Professionelle Farbpalette
    font_scale=1.1           # Leicht vergrößerter Text
)

# Globale Matplotlib-Überschreibungen
plt.rcParams.update({
    "figure.facecolor": "white",
    "axes.facecolor": "white",
    "font.family": "sans-serif",
    "axes.titlesize": 14,
    "axes.labelsize": 12,
})

Die Anwendung von sns.set_theme() am Anfang eines Skripts überträgt einheitliches Styling auf jedes nachfolgende Diagramm. Im Interview spart dies wertvolle Zeit, die sonst für die Formatierung einzelner Diagramme verloren ginge.

Häufige Interview-Fragen zur Datenvisualisierung

Neben dem Programmieren prüfen Interviewer auch das konzeptionelle Verständnis von Best Practices in der Visualisierung. Die folgenden Fragen tauchen regelmäßig in Interviews für Datenanalyse und Data Science auf.

Wann sollte ein Balkendiagramm statt eines Liniendiagramms verwendet werden? Balkendiagramme zeigen Vergleiche zwischen diskreten Kategorien (Abteilungen, Produkttypen, Regionen). Liniendiagramme zeigen Trends über kontinuierliche oder geordnete Intervalle (Zeitreihen, sequenzielle Messungen). Die Verwendung eines Liniendiagramms für ungeordnete Kategorien suggeriert eine falsche Beziehung zwischen benachbarten Datenpunkten.

Was macht ein Diagramm irreführend? Abgeschnittene y-Achsen, duale y-Achsen mit unterschiedlichen Skalen, 3D-Effekte auf 2D-Daten und selektiv gewählte Zeiträume verzerren die Wahrnehmung. Die Lösung: Bei Balkendiagrammen die y-Achse bei Null beginnen lassen, Achsen explizit beschriften und dekorative Elemente vermeiden, die die Daten verschleiern.

Wie beeinflusst die Wahl der Farbpalette die Dateninterpretation? Sequenzielle Paletten (hell-zu-dunkel) eignen sich für geordnete Daten wie Temperatur oder Umsatz. Divergierende Paletten (zwei Farbtöne, die sich in einem neutralen Zentrum treffen) heben Abweichungen von einem Mittelpunkt hervor, etwa Gewinn/Verlust oder Korrelationskoeffizienten. Kategorische Paletten verwenden unterschiedliche Farbtöne für unverbundene Gruppen. Farbenblindheit-sichere Paletten (wie Seaborns colorblind oder muted) gewährleisten Barrierefreiheit — ein Detail, das erfahrene Bewerber von anderen unterscheidet.

Was ist der Unterschied zwischen plt.show() und plt.savefig()? plt.show() rendert die Figur in einem interaktiven Fenster und löscht danach den Figurzustand. plt.savefig() schreibt die Figur in eine Datei, ohne sie zu löschen. Der Aufruf von savefig() nach show() erzeugt eine leere Datei — ein häufiger Fehler. Die korrekte Reihenfolge: zuerst savefig(), dann show().

Alles zusammenführen: End-to-End Interview-Übung

Eine typische Hausaufgabe oder Live-Coding-Aufgabe kombiniert Datenladen, Bereinigung und mehrere Diagrammtypen. Das folgende Beispiel spiegelt echte Interviewaufgaben von Analytics-Teams wider.

# interview_exercise.py
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.05)

# 12 Monate Produktdaten simulieren
np.random.seed(42)
months = pd.date_range("2025-01", periods=12, freq="MS")
df = pd.DataFrame({
    "month": months,
    "revenue": np.cumsum(np.random.normal(5000, 2000, 12)) + 50_000,
    "customers": np.cumsum(np.random.poisson(50, 12)) + 500,
    "churn_rate": np.clip(np.random.normal(0.05, 0.015, 12), 0.01, 0.12)
})

fig, axes = plt.subplots(1, 3, figsize=(18, 5))

# Panel 1: Umsatztrend
axes[0].plot(df["month"], df["revenue"], marker="o", color="#2563eb")
axes[0].set_title("Revenue Trend")
axes[0].set_ylabel("Revenue (USD)")
axes[0].yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
axes[0].tick_params(axis="x", rotation=45)
axes[0].spines[["top", "right"]].set_visible(False)

# Panel 2: Kundenwachstum
axes[1].bar(df["month"], df["customers"], color="#16a34a", width=20)
axes[1].set_title("Customer Growth")
axes[1].set_ylabel("Total Customers")
axes[1].tick_params(axis="x", rotation=45)
axes[1].spines[["top", "right"]].set_visible(False)

# Panel 3: Abwanderungsrate mit Schwellenwertlinie
axes[2].plot(df["month"], df["churn_rate"], marker="s", color="#dc2626")
axes[2].axhline(y=0.05, color="gray", linestyle="--", label="Target: 5%")
axes[2].set_title("Monthly Churn Rate")
axes[2].set_ylabel("Churn Rate")
axes[2].yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x:.1%}"))
axes[2].tick_params(axis="x", rotation=45)
axes[2].spines[["top", "right"]].set_visible(False)
axes[2].legend()

fig.suptitle("Product Dashboard — FY 2025", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.savefig("interview_dashboard.png", dpi=150)
plt.show()

Diese Übung demonstriert drei Diagrammtypen in einem einheitlichen Layout, korrekte Achsenformatierung, eine Referenzlinie für Abwanderungsziele und konsistentes Styling. Genau diese Elemente werden in Interviews bewertet.

Fazit

• Die objektorientierte Matplotlib-API (fig, ax = plt.subplots()) bietet volle Kontrolle und ist der erwartete Standard in professionellen Umgebungen und Interviews
• Seaborns hue-Parameter und integrierte statistische Funktionen (KDE, Heatmaps) ermöglichen gruppierte Analysen mit minimalem Code
• Korrelations-Heatmaps mit divergierenden Farbpaletten und festen Skalen (vmin=-1, vmax=1) sind ein fester Bestandteil von Analyse-Interviews
• savefig() muss immer vor show() aufgerufen werden, um leere Ausgabedateien zu vermeiden
• Sauberes Styling — entfernte Spines, formatierte Achsenbeschriftungen, explizite Titel — signalisiert produktionsreifes Denken gegenüber Interviewern
• Das Erstellen von Multi-Panel-Dashboards unter Zeitdruck sollte geübt werden: Die meisten Live-Coding-Runden sehen 10-15 Minuten pro Visualisierungsaufgabe vor