Klimaatstreepjescode maken met Python

Wat is een klimaatstreepjescode?

De klimaatstreepjescode (in het Engels vaak climate stripes genoemd) is een zeer compacte manier om temperatuurverandering door de tijd te visualiseren. In plaats van een traditionele grafiek met lijnen of punten, wordt ieder jaar weergegeven als een verticale kleurstrook.

In onderstaande afbeelding zie je het eindresultaat dat we in deze tutorial stap voor stap gaan maken: een klimaatstreepjescode waarin ieder jaar wordt weergegeven als één gekleurde strook.

Hierin is dus één kleurstrook per jaar te zien.

• Blauw staat voor relatief koude jaren
• Rood staat voor relatief warme jaren

Technisch gezien is een klimaatstreepjescode een heatmap met één rij en veel kolommen: iedere kolom stelt één jaar voor en de kleur geeft de temperatuur weer. Hierdoor kun je trends vaak in één oogopslag herkennen.

In deze tutorial laten we stap voor stap zien hoe je zelf een klimaatstreepjescode maakt met Python. Daarbij gebruiken we:

• open data van het KNMI
• pandas voor dataverwerking
• Matplotlib voor visualisatie

Disclaimer: Deze tutorial laat vooral zien hoe je met Python een klimaatstreepjescode kunt maken op basis van KNMI-data. De focus ligt op het visualisatieproces, niet op een volledige klimatologische of statistische analyse. Om het voorbeeld eenvoudig en begrijpelijk te houden zijn de datastappen bewust versimpeld en niet verder gevalideerd. De gebruikte aanpak is daarom bedoeld als didactisch voorbeeld, en niet als formeel gevalideerde klimaatanalyse.

1. Downloaden van open klimaatdata van het KNMI

De dataset die we gebruiken bevat maand- en jaargemiddelde temperaturen voor weerstation De Bilt (station 260). Dit station wordt vaak gebruikt als referentie voor lange temperatuurreeksen in Nederland, omdat het een lange en veelgebruikte meetreeks heeft.

Het doel van deze tutorial is niet alleen om de visualisatie te maken, maar ook om te laten zien hoe je ruwe tekstdata omzet naar een analyseerbare dataset.

Bronvermelding data: Koninklijk Nederlands Meteorologisch Instituut (KNMI).

In het onderstaande codeblok downloaden we het databestand rechtstreeks van de KNMI-website. Het bestand is een tekstbestand met daarin:

• uitleg over de dataset
• beschrijving van de kolommen
• een tabel met maand- en jaargemiddelde temperaturen

Door de inhoud van het bestand te printen, zien we precies hoe de ruwe data eruitziet.

import requests

url = "https://cdn.knmi.nl/knmi/map/page/klimatologie/gegevens/maandgegevens/mndgeg_260_tg.txt"
text = requests.get(url).text

print(text)

Deze gegevens mogen vrij worden gebruikt mits de volgende bronvermelding wordt gegeven:
KONINKLIJK NEDERLANDS METEOROLOGISCH INSTITUUT (KNMI)

These data can be used freely provided that the following source is acknowledged:
ROYAL NETHERLANDS METEOROLOGICAL INSTITUTE

MAAND- en JAARGEMIDDELDE TEMPERATUREN (0.1 graden Celsius)
MONTHLY AND YEARLY MEAN TEMPERATURES (0.1 degrees Celsius)

STN = stationsnummer / WMO-number = 06... (235=De Kooy,240=Schiphol,260=De Bilt,270=Leeuwarden,280=Eelde,
      290=Twenthe,310=Vlissingen,344=Rotterdam,370=Eindhoven,380=Maastricht)

STN,YYYY,   JAN,   FEB,   MAR,   APR,   MAY,   JUN,   JUL,   AUG,   SEP,   OCT,   NOV,   DEC,  YEAR

260,1901,    -3,   -10,    35,    89,   120,   144,   184,   164,   144,   102,    52,    29,    88
260,1902,    45,    -4,    52,    84,    92,   155,   153,   146,   129,    85,    37,     8,    82
...
260,2024,    39,    82,    90,   108,   155,   158,   181,   193,   158,   121,    69,    61,   118
260,2025,    34,    39,    71,   115,   141,   183,   190,   182,   150,   120,    78,    61,   114

In de output zien we onder andere:

• beschrijvende tekst van het KNMI
• uitleg over het formaat van de dataset
• uiteindelijk de tabel met temperatuurdata

Elke rij in de tabel bevat:

• een stationnummer (STN)
• een jaar (YYYY)
• maandtemperaturen (JAN t/m DEC)
• een jaargemiddelde temperatuur (YEAR)

De temperaturen zijn opgeslagen in tienden van graden Celsius (0.1 °C).

2. Opschonen van het tekstbestand

Het tekstbestand bevat eerst uitleg en pas daarna de tabel. Voor verdere verwerking willen we alleen de tabel zelf.

Daarom doen we het volgende:

• We splitsen de tekst op in losse regels.
• We zoeken de regel waarin de kolomnamen staan (STN,YYYY).
• Vanaf die regel nemen we alle resterende regels mee.

Het resultaat is een stuk tekst dat alleen de tabeldata bevat.

text_lines = text.splitlines()

start_line = None
for index, text_line in enumerate(text_lines):
    if text_line.strip().startswith("STN,YYYY"):
        start_line = index
        break

data_text = "\n".join(text_lines[start_line:])

print(data_text)

STN,YYYY,   JAN,   FEB,   MAR,   APR,   MAY,   JUN,   JUL,   AUG,   SEP,   OCT,   NOV,   DEC,  YEAR

260,1901,    -3,   -10,    35,    89,   120,   144,   184,   164,   144,   102,    52,    29,    88
260,1902,    45,    -4,    52,    84,    92,   155,   153,   146,   129,    85,    37,     8,    82
...
260,2024,    39,    82,    90,   108,   155,   158,   181,   193,   158,   121,    69,    61,   118
260,2025,    34,    39,    71,   115,   141,   183,   190,   182,   150,   120,    78,    61,   114

In de output zien we nu direct de tabel met temperatuurdata. Elke regel bevat: stationnummer, jaar, maandwaarden..., jaargemiddelde

Bijvoorbeeld: 260,1901,...,88

Dit betekent:

• station 260 (De Bilt)
• jaar 1901
• jaargemiddelde temperatuur 8.8°C (88 / 10)

De dataset bevat temperatuurdata van 1901 tot en met 2025.

3. Omzetten naar een pandas DataFrame

In het volgende codeblok zetten we de tabel om naar een pandas DataFrame.

Dit is een van de meest gebruikte datastructuren in Python voor data-analyse. Het lijkt sterk op een Excel-spreadsheet of SQL-tabel.

Een belangrijk detail is de sep parameter (sep=r"\s*,\s*"). Hiermee zorgen we ervoor dat pandas de waarden splitst op komma’s, ongeacht eventuele spaties eromheen.

import pandas as pd
import io

df_raw = pd.read_csv(
    io.StringIO(data_text),
    sep=r"\s*,\s*",
    engine="python",
)

df_raw

Het DataFrame bevat nu kolommen zoals:

• STN
• YYYY
• JAN t/m DEC
• YEAR

Elke rij bevat dus alle temperatuurinformatie voor één jaar.

De belangrijkste kolommen voor onze visualisatie zijn:

• YYYY: het jaar
• YEAR: jaargemiddelde temperatuur

Voor de klimaatstreepjescode hebben we namelijk alleen één temperatuurwaarde per jaar nodig.

4. Selecteren en transformeren van jaargemiddelde temperaturen

In het volgende codeblok maken we een compacte dataset met alleen jaartemperaturen.

Stap voor stap:

• We selecteren alleen de kolommen YYYY en YEAR.
• We zetten de waarden expliciet om naar numerieke waarden.
• We hernoemen de kolommen naar duidelijkere namen.
• We zetten de temperatuur om van 0.1°C naar °C.
• We sorteren de data op jaar.
• We verwijderen rijen met ontbrekende waarden. Hierdoor voorkomen we dat ontbrekende data later problemen veroorzaakt in de visualisatie.

# Select columns
df_year = df_raw[["YYYY", "YEAR"]].copy()

# Set column data types
df_year["YYYY"] = pd.to_numeric(df_year["YYYY"])
df_year["YEAR"] = pd.to_numeric(df_year["YEAR"])

# Rename columns
df_year = df_year.rename(columns={"YYYY": "year", "YEAR": "temp_0p1c"})

# Calculate temperature in degrees Celsius
df_year["temp_c"] = df_year["temp_0p1c"] / 10

# Sort by year
df_year = df_year.sort_values("year").reset_index(drop=True)

# Drop missing data
df_year = df_year.dropna()

df_year

De resulterende tabel bevat nu slechts drie kolommen:

Dit is precies de dataset die we nodig hebben voor onze visualisatie.

5. Visualiseren van de data met Matplotlib

Nu maken we de eerste versie van de klimaatstreepjescode.

De belangrijkste stap is: plt.imshow(...)

Omdat we een lijst met temperatuurwaarden gebruiken ([df_year["temp_c"]]), ontstaat een matrix met één rij en veel kolommen. imshow() kan zo'n matrix direct visualiseren als een afbeelding.

Elke kolom wordt ingekleurd volgens de temperatuur.

import matplotlib.pyplot as plt

plt.figure(figsize=(12, 3))
im = plt.imshow(
    [df_year["temp_c"]],
    aspect="auto",
    cmap="RdBu_r",
)

plt.axis("off")
plt.title(
    f"Klimaatstreepjescode, De Bilt, {df_year['year'].min()}-{df_year['year'].max()}",
)
plt.show()

Hier gebruiken we de colormap RdBu_r. Dit is een divergerende kleurenkaart waarin blauw staat voor lagere waarden en rood voor hogere waarden. De _r betekent dat de kleurvolgorde is omgekeerd.

De kleuren geven de temperatuur weer:

• blauw: koudere jaren
• rood: warmere jaren

Je ziet meteen een duidelijk patroon:

• vroege jaren zijn vaker blauw
• latere jaren worden steeds roder

Dit suggereert een stijgende temperatuurtrend over de tijd.

6. Verbeteren van de grafiek

In dit codeblok maken we de grafiek informatiever.

Verbeteringen:

• decenniumlabels op de x-as
• kleurenschaal (colorbar) onder de grafiek
• duidelijkere titel en labels

Hierdoor wordt de grafiek beter interpreteerbaar.

import matplotlib.pyplot as plt

fig, (ax, cax) = plt.subplots(
    2, 1, figsize=(12, 4),
    gridspec_kw={"height_ratios": [12, 1], "hspace": 0.3}
)

im = ax.imshow([
    df_year["temp_c"]],
    aspect="auto",
    cmap="RdBu_r",
)

is_decade = df_year["year"] % 10 == 0
decades = df_year[is_decade]
ax.set_xticks(decades.index, decades["year"])

ax.set_yticks([])
ax.set_ylabel("Gemiddelde jaartemperatuur (°C)")
ax.set_title(
    f"Klimaatstreepjescode, De Bilt, {df_year['year'].min()}-{df_year['year'].max()}",
)

fig.colorbar(im, cax=cax, orientation="horizontal")

plt.show()

De kleurenschaal laat zien welke temperatuur bij welke kleur hoort.

De decenniumlabels maken het eenvoudiger om te zien wanneer veranderingen plaatsvinden.

Conclusie

In deze tutorial hebben we stap voor stap:

• temperatuurdata van het KNMI gedownload
• de tabel uit een tekstbestand gehaald
• de data omgezet naar een pandas DataFrame
• jaargemiddelden geselecteerd en getransformeerd
• en deze gevisualiseerd als klimaatstreepjescode

Klimaatstreepjescodes laten zien hoe krachtig eenvoudige datavisualisaties kunnen zijn. Met relatief weinig code kun je een visualisatie maken die:

• tientallen jaren klimaatdata samenvat
• trends onmiddellijk zichtbaar maakt
• intuïtief te begrijpen is

Voor data-analisten en data scientists is dit een mooi voorbeeld van hoe je:

• open data
• Python
• datavisualisatie

kunt combineren om inzichten toegankelijk te maken.

Daarnaast laat deze tutorial zien dat een groot deel van data-analyse bestaat uit het structureren van ruwe data voordat je er visualisaties of modellen op loslaat. Met slechts een paar Python packages kun je dus al snel krachtige analyses en visualisaties maken.

Wil je op professioneel niveau met Python leren werken?

Schrijf je dan in voor onze Python cursus voor data science, Python advanced training, onze machine learning cursus, of voor onze data science opleiding en leer met vertrouwen te programmeren en visualiseren in Python. Nadat je een van onze trainingen hebt gevolgd kun je zelfstandig verder aan de slag. Je kunt ook altijd even contact opnemen als je een vraag hebt.

Download één van onze opleidingsbrochures voor meer informatie