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

> Python-Datenvisualisierung mit Matplotlib und Seaborn meistern. Praxisorientiertes Tutorial mit Diagrammen, Styling, Subplots und häufigen Interviewfragen für Data-Analytics-Positionen 2026.

- Published: 2026-04-22
- Updated: 2026-04-22
- Author: SharpSkill
- Tags: python, matplotlib, seaborn, data-visualization, data-analytics, interview
- Reading time: 9 min

---

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+.

> **Interview-Tipp**
>
> Die meisten Datenanalyse-Interviews beinhalten eine Live-Coding-Runde, in der Bewerber innerhalb von 15 Minuten eine Visualisierung aus einem Datensatz erstellen müssen. Die folgenden Muster lassen sich direkt auf diese Übungen anwenden.

## 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.

```bash
# 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:

```python
# 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.

```python
# 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.

```python
# 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.

> **Häufiger Interview-Fehler**
>
> Bewerber verwenden oft `plt.plot()` für alles, anstatt die objektorientierte API zu nutzen. Wenn ein Interviewer darum bittet, eine zweite y-Achse hinzuzufügen oder einen einzelnen Subplot anzupassen, stößt der pyplot-Ansatz an seine Grenzen. Die OO-API mit `fig, ax = plt.subplots()` sollte immer die erste Wahl sein.

## 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:

```python
# 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.

```python
# 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.

```python
# 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.

> **Versionshinweis**
>
> Seaborn 0.13 hat `set_style()` und `set_palette()` als separate Aufrufe als veraltet markiert. Die einheitliche Funktion `set_theme()` ersetzt beide. Ältere Stack-Overflow-Antworten verweisen noch auf die veraltete API — in Interviews 2026 sollte diese vermieden werden.

## 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.

```python
# 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

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/de/blog/data-analytics/python-matplotlib-seaborn-data-visualization-interview