# Python voor Data Analytics: Matplotlib, Seaborn en visualisatie voor sollicitatiegesprekken

> Python-datavisualisatie onder de knie krijgen met Matplotlib en Seaborn. Praktische tutorial met grafieken, styling, subplots en veelgestelde interviewvragen voor data analytics-functies in 2026.

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

---

Datavisualisatie met Python behoort tot de meest geteste vaardigheden in sollicitatiegesprekken voor data analytics-functies. Hiring managers verwachten dat kandidaten overzichtelijke en leesbare grafieken uit ruwe data produceren — en hun ontwerpkeuzes onder tijdsdruk kunnen toelichten.

Deze tutorial behandelt Matplotlib 3.10 en Seaborn 0.13, de twee bibliotheken die technische interviews voor analist- en data science-posities domineren. Alle codevoorbeelden draaien direct met Python 3.12+.

> **Interview-tip**
>
> De meeste data analytics-interviews bevatten een live coding-ronde waarin kandidaten binnen 15 minuten een visualisatie uit een dataset moeten genereren. De onderstaande patronen sluiten direct aan op deze oefeningen.

## Een Python-omgeving voor datavisualisatie opzetten

Voordat er grafiekcode geschreven wordt, heeft de omgeving de juiste dependencies nodig. Een schone virtuele omgeving voorkomt versieconflicten tussen Matplotlib, Seaborn en hun gedeelde NumPy/Pandas-basis.

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

Een snelle controle bevestigt dat alles werkt:

```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__}")
```

Met de dependencies vastgelegd, richt de volgende stap zich op de Matplotlib-basis — het fundament voor elke Seaborn-grafiek.

## Matplotlib-basis: Figure, Axes en de objectgeoriënteerde API

Matplotlib biedt twee API's: de pyplot state machine en de objectgeoriënteerde (OO) interface. De OO-API biedt expliciete controle over elk element en is de standaard die verwacht wordt in professionele codebases en interviews.

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

# Voorbeeld: kwartaalomzet
quarters = ["Q1", "Q2", "Q3", "Q4"]
revenue = [42_000, 58_000, 51_000, 67_000]

# Figure en axes expliciet aanmaken
fig, ax = plt.subplots(figsize=(8, 5))

# Balken tekenen met een specifieke kleur
ax.bar(quarters, revenue, color="#2563eb", width=0.5)

# Assen duidelijk labelen — interviewers controleren dit
ax.set_xlabel("Quarter")
ax.set_ylabel("Revenue (USD)")
ax.set_title("Quarterly Revenue — 2025")

# Y-as formatteren met dollarbedragen
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))

# Bovenste en rechter randen verwijderen voor een strakker uiterlijk
ax.spines[["top", "right"]].set_visible(False)

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

Belangrijke details waar interviewers op letten: expliciete `fig, ax`-creatie in plaats van `plt.plot()`, leesbare aslabels, geformatteerde tick-waarden en verwijderde overbodige randelementen (onnodige spines). Deze kleine keuzes signaleren productieklaar denken.

## Subplots bouwen voor vergelijkende analyse

In interviews wordt regelmatig gevraagd om meerdere metrics naast elkaar te vergelijken. De functie `subplots()` handelt dit af met een rasterindeling.

```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]

# Twee naast elkaar geplaatste grafieken met onafhankelijke y-assen
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5), sharey=False)

# Linker paneel: gebruikersgroei als lijngrafiek
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)

# Rechter paneel: omzet als staafgrafiek
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()
```

Het gebruik van `sharey=False` laat elk paneel onafhankelijk schalen — omzet in dollars en gebruikersaantallen hebben verschillende ordes van grootte. De `suptitle` voegt een overkoepelende titel boven beide subplots toe.

> **Veelgemaakte interviewfout**
>
> Kandidaten gebruiken vaak `plt.plot()` voor alles in plaats van de objectgeoriënteerde API. Wanneer een interviewer vraagt om een tweede y-as toe te voegen of een enkel subplot aan te passen, schiet de pyplot-aanpak tekort. De OO-API met `fig, ax = plt.subplots()` moet altijd de standaardkeuze zijn.

## Statistische Seaborn-grafieken: van distributie tot correlatie

Seaborn bouwt voort op Matplotlib en is gespecialiseerd in statistische visualisatie. Waar Matplotlib handmatige configuratie vereist, leidt Seaborn redelijke standaardinstellingen af uit de datastructuur.

Een distributieanalyse — een van de meest voorkomende interviewopdrachten — vereist slechts één functieaanroep:

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

# Salarisgegevens simuleren voor twee afdelingen
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 om salarisverdeelingen te vergelijken
fig, ax = plt.subplots(figsize=(10, 5))
sns.kdeplot(
    data=data,
    x="salary",
    hue="department",        # Automatische splitsing per categorie
    fill=True,               # Gearceerd gebied onder de curve
    alpha=0.4,
    palette=["#2563eb", "#dc2626"],
    ax=ax                    # Koppelen aan onze expliciete axes
)

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()
```

De `hue`-parameter splitst de data automatisch, en `fill=True` maakt overlappende gebieden zichtbaar. Dit patroon — distributies groeperen per categorie — komt in vrijwel elk analytics-interview voor.

## Seaborn-heatmaps voor correlatiematrices

Correlatie-heatmaps onthullen relaties tussen numerieke variabelen in één oogopslag. Interviewers gebruiken ze om te testen of kandidaten multicollineariteit kunnen herkennen of sterke feature-relaties kunnen identificeren.

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

# E-commerce metrics simuleren
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-correlatie berekenen
corr_matrix = df.corr()

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(
    corr_matrix,
    annot=True,              # Correlatiewaarden in cellen tonen
    fmt=".2f",               # Twee decimalen
    cmap="RdBu_r",           # Divergerend kleurenpalet gecentreerd op 0
    vmin=-1, vmax=1,         # Vaste schaal voor consistentie
    square=True,             # Vierkante cellen
    linewidths=0.5,
    ax=ax
)

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

Het divergerende `RdBu_r`-kleurenpalet maakt positieve correlaties blauw en negatieve rood — een conventie die interviewers verwachten. De instelling `vmin=-1` en `vmax=1` zorgt ervoor dat de kleurschaal interpreteerbaar blijft ongeacht het werkelijke databereik.

## Grafieken stijlen voor professionele presentaties

De standaarduitvoer van Matplotlib ziet er gedateerd uit. Een paar configuratieregels transformeren grafieken in presentatiewaardige visualisaties die tijdens interviews oog voor detail aantonen.

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

# Seaborns ingebouwde thema toepassen
sns.set_theme(
    style="whitegrid",       # Schone achtergrond met rasterlijnen
    palette="muted",         # Professioneel kleurenpalet
    font_scale=1.1           # Iets grotere tekst
)

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

Het toepassen van `sns.set_theme()` aan het begin van een script zorgt voor consistente styling in alle daaropvolgende grafieken. Tijdens interviews bespaart dit kostbare tijd die anders aan per-grafiek formatting besteed zou worden.

> **Versie-opmerking**
>
> Seaborn 0.13 heeft `set_style()` en `set_palette()` als aparte aanroepen gedeprecieerd. De uniforme functie `set_theme()` vervangt beide. Oudere Stack Overflow-antwoorden verwijzen nog naar de gedeprecieerde API — vermijd het gebruik hiervan in interviews in 2026.

## Veelgestelde interviewvragen over datavisualisatie

Naast het programmeren toetsen interviewers ook het conceptuele begrip van best practices in visualisatie. De onderstaande vragen komen consistent terug in interviews voor data analytics en data science.

**Wanneer moet een staafgrafiek worden gebruikt in plaats van een lijngrafiek?**
Staafgrafieken tonen vergelijkingen tussen discrete categorieën (afdelingen, producttypen, regio's). Lijngrafieken tonen trends over continue of geordende intervallen (tijdreeksen, sequentiële metingen). Het gebruik van een lijngrafiek voor ongeordende categorieën suggereert een valse relatie tussen aangrenzende datapunten.

**Wat maakt een grafiek misleidend?**
Afgekapte y-assen, dubbele y-assen met verschillende schalen, 3D-effecten op 2D-data en selectief gekozen tijdsperioden vervormen de perceptie. De oplossing: begin de y-as bij nul voor staafgrafieken, label assen expliciet en vermijd decoratieve elementen die de data verhullen.

**Hoe beïnvloedt de keuze van kleurenpalet de data-interpretatie?**
Sequentiële paletten (licht-naar-donker) zijn geschikt voor geordende data zoals temperatuur of omzet. Divergerende paletten (twee tinten die samenkomen in een neutraal centrum) benadrukken afwijkingen van een middenpunt, zoals winst/verlies of correlatiecoëfficiënten. Categorische paletten gebruiken onderscheidende tinten voor ongerelateerde groepen. Kleurenblindvriendelijke paletten (zoals Seaborns `colorblind` of `muted`) waarborgen toegankelijkheid — een detail dat senior kandidaten onderscheidt.

**Wat is het verschil tussen `plt.show()` en `plt.savefig()`?**
`plt.show()` rendert de figuur naar een interactief venster en wist daarna de figuurstatus. `plt.savefig()` schrijft de figuur naar een bestand zonder deze te wissen. Het aanroepen van `savefig()` na `show()` produceert een leeg bestand — een veelvoorkomende bug. De juiste volgorde: eerst `savefig()`, dan `show()`.

## Alles samenbrengen: end-to-end interview-oefening

Een typische thuisopdracht of live coding-oefening combineert het laden van data, opschoning en meerdere grafiektypen. Het volgende voorbeeld weerspiegelt echte interviewopdrachten van analytics-teams.

```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 maanden productdata simuleren
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))

# Paneel 1: Omzettrend
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)

# Paneel 2: Klantengroei
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)

# Paneel 3: Verlooppercentage met drempelwaardenlijn
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()
```

Deze oefening demonstreert drie grafiektypen in een uniform layout, correcte asformattering, een referentielijn voor churn-doelstellingen en consistente styling. Dit zijn precies de elementen waarop interviewers beoordelen.

## Conclusie

- De objectgeoriënteerde Matplotlib-API (`fig, ax = plt.subplots()`) biedt volledige controle en is de verwachte standaard in professionele omgevingen en interviews
- Seaborns `hue`-parameter en ingebouwde statistische functies (KDE, heatmaps) verwerken gegroepeerde analyses met minimale code
- Correlatie-heatmaps met divergerende kleurenpaletten en vaste schalen (`vmin=-1, vmax=1`) zijn een vast onderdeel van analytics-interviews
- Roep altijd `savefig()` aan vóór `show()` om lege uitvoerbestanden te voorkomen
- Strakke styling — verwijderde spines, geformatteerde tick-labels, expliciete titels — communiceert productieklaar denken naar interviewers
- Oefen het bouwen van multi-paneel dashboards onder tijdsdruk: de meeste live coding-rondes reserveren 10-15 minuten per visualisatieopdracht

---

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