Kolommen hernoemen in pandas: een complete gids met voorbeelden

Hoe hernoem ik kolommen met .rename()?

De methode .rename() is de meest flexibele manier om een pandas DataFrame-kolom te hernoemen, en degene die je het vaakst zult gebruiken. 

Hij neemt een dictionary die oude namen aan nieuwe namen koppelt, laat alle kolommen die je niet noemt ongemoeid, en retourneert standaard een nieuw DataFrame in plaats van het origineel te wijzigen. Dit maakt .rename() veilig in method-chains en makkelijk te begrijpen bij het debuggen.

Het dictionary-patroon ziet er zo uit:

sales_data.rename(columns={"old_name": "new_name"})

Als dictionaries nieuw voor je zijn, raad ik aan om onze tutorial over Python-dictionarymethoden door te nemen als opfrisser.

Opmerking over de oude copy-parameter

Eén snelle noot vóór de voorbeelden. Pandas 3.0 heeft de copy-parameter uitgefaseerd en Copy-on-Write als standaardgedrag gemaakt. In de praktijk betekent dit dat je je geen zorgen meer hoeft te maken of .rename() een dure kopie van je data maakt. Pandas handelt dat lui af onder de motorkap. De belangrijkste parameter om over na te denken is inplace, die we in de derde subsectie behandelen.

Eén kolom hernoemen

Stel dat je zojuist klantrecords hebt geladen uit een legacy-CRM. De kolomnamen zijn afgekort op een manier die logisch was voor de ontwerper van de database in 2008, maar niet voor jou. Dit is de eenvoudigste pandas-hernoemoperatie: één oude naam, één nieuwe naam, in een dictionary:

import pandas as pd

customers = pd.DataFrame({
    "cust_id_nbr": [4521, 4522, 4523, 4524],
    "first_nm": ["Abe", "Rick", "Pat", "Kim"],
    "signup_dt": ["2008-03-12", "2008-03-15", "2008-03-18", "2008-03-21"]
})

print(customers)

Hernoem nu cust_id_nbr naar iets leesbaarders:

customers_renamed = customers.rename(columns={"cust_id_nbr": "customer_id"})
print(customers_renamed)

Het originele customers-DataFrame is ongewijzigd. .rename() retourneerde een nieuw DataFrame, dat we aan customers_renamed hebben toegekend. De twee kolommen die we niet noemden (first_nm, signup_dt) gingen ongewijzigd mee.

Meerdere kolommen hernoemen

Het dictionary-patroon schaalt natuurlijk mee. Om meerdere kolommen te hernoemen in pandas, voeg je gewoon meer key-valueparen toe aan de mapping:

customers_clean = customers.rename(columns={
    "cust_id_nbr": "customer_id",
    "first_nm": "first_name",
    "signup_dt": "signup_date"
})

print(customers_clean)

Er is ook een alternatieve syntaxis die de argumenten mapper en axis gebruikt in plaats van het keyword columns:

customers.rename(mapper={"cust_id_nbr": "customer_id"}, axis=1)

De axis=1 vertelt pandas dat je je op kolommen richt (in tegenstelling tot axis=0 voor rij-indexlabels). Beide vormen leveren hetzelfde resultaat op. De meeste code in het wild gebruikt columns={...} omdat dat in één oogopslag duidelijker leest, dus we houden ons aan dat patroon voor de rest van de tutorial.

Een handig detail is dat als je een key doorgeeft die met geen enkele bestaande kolom overeenkomt, .rename() die standaard stilzwijgend negeert. Dat is handig wanneer je een herbruikbare functie schrijft die DataFrames met licht verschillende schema's kan verwerken, maar het kan ook typefouten verbergen. Om pandas een fout te laten geven bij onbekende kolomnamen, geef je errors='raise' mee.

Gebruik van inplace vs. een nieuw DataFrame retourneren

Standaard retourneert .rename() een nieuw DataFrame en laat het origineel met rust. Als je het bestaande DataFrame direct wilt aanpassen, geef dan inplace=True door:

# Retourneert een nieuw DataFrame (standaard)
customers_v2 = customers.rename(columns={"first_nm": "first_name"})

# Past customers direct aan, retourneert None
customers.rename(columns={"first_nm": "first_name"}, inplace=True)

print(customers)

Welke moet je gebruiken? In de meeste gevallen is de standaard — een nieuw DataFrame retourneren — de betere keuze. Het is ook makkelijker te debuggen, omdat je het originele DataFrame nog hebt om te inspecteren als er iets misgaat. En het omzeilt de aliasingproblemen die een SettingWithCopyWarning in oudere code veroorzaken.

Prestatie is tegenwoordig ook geen reden meer om inplace te prefereren. Met Copy-on-Write, nu de standaard in pandas 3.0+, gebruikt de niet-inplaceversie luie kopieën. Je data wordt pas gedupliceerd wanneer er iets wordt gewijzigd. Het oude argument dat inplace=True geheugen bespaart, is veel zwakker dan vroeger.

De enige plek waar inplace=True nog natuurlijk aanvoelt, is in korte, verkennende scripts waarin je één DataFrame stap voor stap opschoont en je niet om chaining geeft. Voor productcode of iets dat je later nog eens bekijkt, heeft de standaard de voorkeur.

Hoe hernoem ik alle kolommen tegelijk in pandas?

Soms wil je geen oude namen naar nieuwe mappen. Je wilt gewoon elke kolomnaam in één keer vervangen. Dat komt vaker voor dan je denkt, zoals bij CSV's zonder header waar pandas 0, 1, 2 als kolomnamen toewijst, datasets waar de headerregel in een andere taal is, of systeemsgegenereerde exports met namen als Field1, Field2, Field3.

Er zijn twee gangbare manieren om dit te doen. Ofwel direct toewijzen aan df.columns, of .set_axis() gebruiken. Ze leveren hetzelfde resultaat op. Het afwegingspunt is beknoptheid versus chainbaarheid.

Een lijst toewijzen aan df.columns

De meest directe aanpak is een nieuwe lijst toewijzen aan het attribuut columns. Neem dit DataFrame, gebouwd uit een lijst van lijsten zonder headerinformatie, zoals wat je krijgt bij het inlezen van een CSV zonder header. Pandas valt terug op gehele kolomnamen:

import pandas as pd

sensor_readings = pd.DataFrame([
    [1.2, 22.5, 1013],
    [1.5, 22.7, 1012],
    [1.3, 22.6, 1013]
])

print(sensor_readings)

Die kolomnamen 0, 1 en 2 zijn waardeloos voor analyse. Vervang ze door een nieuwe lijst met namen aan het columns-attribuut toe te wijzen:

sensor_readings.columns = ["wind_speed", "temperature_c", "pressure_hpa"]
print(sensor_readings)

Twee dingen om te weten over deze aanpak. 

1. De lijstlengte moet exact overeenkomen. Geef drie namen voor een DataFrame met vier kolommen, en pandas geeft ValueError: Length mismatch (we behandelen deze fout later in detail). 

2. Het wijzigt het DataFrame in place. Er is hier geen inplace-parameter omdat de toewijzing de wijziging is. Als je een frisse kopie wilt, gebruik dan eerst .copy() of kies hieronder voor .set_axis().

.set_axis() gebruiken voor method-chaining

De methode .set_axis() doet hetzelfde, maar retourneert een nieuw DataFrame zodat je het kunt chainen met andere bewerkingen. Neem een vergelijkbaar DataFrame zonder header, maar nu met wat rommeliger data zoals extra decimalen en een ontbrekende meting:

raw_sensor = pd.DataFrame([
    [1.234, 22.567, 1013],
    [1.512, 22.789, 1012],
    [None,  22.601, 1013],
    [1.345, 22.612, 1013]
])

sensor_clean = (
    raw_sensor
    .set_axis(["wind_speed_mps", "temp_celsius", "pressure_hpa"], axis=1)
    .round(1)
    .dropna()
)

print(sensor_clean)

Het argument axis=1 vertelt pandas dat je kolomlabels instelt (gebruik axis=0 om in plaats daarvan de rij-index te zetten). Omdat .set_axis() een nieuw DataFrame retourneert, past het natuurlijk in de soort chained transformatiepijplijnen die je in echte ETL- of analysecode schrijft. Dat is de hoofdreden om het in productie te verkiezen boven directe toewijzing.

Hoe hernoem ik kolommen met functies in pandas?

In plaats van elke oude naam naar een nieuwe te mappen, kun je een functie doorgeven aan .rename(), en pandas past die toe op elke kolomnaam. Dit is het juiste gereedschap wanneer je een regel hebt in plaats van een lijst. Bijvoorbeeld: "maak alles lowercase" of "vervang elke spatie door een underscore".

Ingebouwde stringfuncties gebruiken

Het eenvoudigste geval is het standaardiseren van hoofd-/kleine letters. Geef str.lower, str.upper of str.title direct door aan het argument columns:

import pandas as pd

orders = pd.DataFrame({
    "Order ID": [1001, 1002, 1003],
    "Customer Name": ["Abe", "Rick", "Pat"],
    "Total Amount": [49.99, 120.00, 75.50]
})

orders_lower = orders.rename(columns=str.lower)
print(orders_lower.columns.tolist())

Let op dat we de functie zelf doorgeven (str.lower), en haar niet aanroepen (str.lower()). Pandas past haar één voor één toe op elke kolomnaam. Dit is een nette shortcut voor case-standaardisatie, maar behandelt geen spaties of speciale tekens. Daarvoor wil je een lambda of een aangepaste functie.

Lambda's en aangepaste functies gebruiken

Voor alles voorbij hoofd-/kleineletters biedt een lambda een snelle manier om de transformatie inline uit te drukken. Als je nog niet met lambda's hebt gewerkt, is onze beginnersgids over Python-lambdafuncties een goed startpunt.

Een veelvoorkomend patroon is in één stap lowercasing en spaties vervangen door underscores. We gebruiken het vorige voorbeeld:

orders_snake = orders.rename(columns=lambda col: col.lower().replace(" ", "_"))
print(orders_snake.columns.tolist())

Wanneer de logica uitgebreider wordt, til die dan uit naar een benoemde functie. Kijk naar deze helper die camelCase- of PascalCase-kolomnamen omzet naar snake_case:

import re

def to_snake_case(name: str) -> str:
    """Convert camelCase or PascalCase to snake_case."""
    s1 = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", name)
    s2 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s1)
    return s2.lower()

api_response = pd.DataFrame({
    "userId": [1, 2, 3],
    "firstName": ["Abe", "Rick", "Pat"],
    "accountCreatedAt": ["2024-01-01", "2024-01-02", "2024-01-03"]
})

api_clean = api_response.rename(columns=to_snake_case)
print(api_clean.columns.tolist())

Een benoemde functie als deze is eenvoudiger te testen, opnieuw te gebruiken tussen notebooks en te documenteren dan een slimme one-liner. Gebruik lambda's wanneer de logica op één regel past, en aangepaste functies wanneer dat niet zo is.

Hoe maak ik rommelige kolomnamen in bulk schoon in pandas?

Wanneer data uit spreadsheets, externe API's of met de hand bewerkte CSV's komt, hebben kolomnamen vaak problemen die .rename() alleen niet elegant kan oplossen. Ik heb het over problemen zoals:

• Afsluitende witruimte
• Gemengde casing
• Haakjes
• Koppelteken
• Speciale tekens
• Onzichtbare Unicode-tekens

Voor dit soort situaties is de schoonste aanpak om direct op df.columns te opereren met de .str-accessor, die gevectoriseerde stringmethoden (inclusief regex) aanbiedt over alle kolomnamen in één keer. Dit is ook de basis van degelijk data opschonen in Python. Kolomnamen opschonen maakt elke volgende stap (filteren, mergen, plotten) minder foutgevoelig.

Witruimte en speciale tekens strippen

Neem dit DataFrame, met de soort namen die je krijgt uit een Excel-export waar te veel mensen aan hebben gezeten:

import pandas as pd

raw_export = pd.DataFrame({
    "  Order ID ": [1001, 1002, 1003],
    "Customer Name (Full)": ["Abe", "Rick", "Pat"],
    "Total Amount ($)": [49.99, 120.00, 75.50],
    "Order-Date": ["2024-03-12", "2024-03-15", "2024-03-18"]
})

print(raw_export.columns.tolist())

Leidende en afsluitende spaties zijn de meest voorkomende en frustrerende issues, omdat ze onzichtbaar zijn. Strip ze in één regel:

raw_export.columns = raw_export.columns.str.strip()
print(raw_export.columns.tolist())

Voor speciale tekens accepteert .str.replace() een regex-patroon. Het onderstaande patroon houdt letters, cijfers, underscores en spaties, en verwijdert al het andere:

raw_export.columns = raw_export.columns.str.replace(r"[^a-zA-Z0-9_ ]", "", regex=True)
print(raw_export.columns.tolist())

Het koppelteken, de haakjes en het dollarteken zijn verdwenen. Merk op dat Total Amount nu een spatie aan het einde heeft (op de plek waar ($) stond), en OrderDate zijn koppelteken volledig is kwijtgeraakt. Precies daarom strippen we aan het einde van een schoonmaakpipeline nog eens.

Standaardiseren naar snake_case

Een veelgebruikte best practice is om alle kolomnamen om te zetten naar snake_case voordat je met analyse begint: lowercase, woorden gescheiden door underscores, geen speciale tekens. Chain de .str-methoden om daar in één expressie te komen:

raw_export = pd.DataFrame({
    "  Order ID ": [1001, 1002, 1003],
    "Customer Name (Full)": ["Abe", "Rick", "Pat"],
    "Total Amount ($)": [49.99, 120.00, 75.50],
    "Order-Date": ["2024-03-12", "2024-03-15", "2024-03-18"]
})

raw_export.columns = (
    raw_export.columns
    .str.strip()                                  # verwijder leidende/afsluitende witruimte
    .str.lower()                                  # alles lowercase
    .str.replace(r"[^a-z0-9]+", "_", regex=True)  # klap niet-alfanumeriek samen tot underscores
    .str.strip("_")                               # verwijder leidende/afsluitende underscores
)

print(raw_export.columns.tolist())

Vier regels, en je kolomnamen zijn voorspelbaar, lowercase en met underscores gescheiden. Dit patroon is het bewaren als utilityfunctie waard. Als je het eenmaal hebt, kun je het op elk rommelig DataFrame loslaten dat binnenkomt. 

Vaak wil je hernoemen ook combineren met kolommen verwijderen. Daarvoor behandelt de tutorial over kolommen droppen in pandas de volgende stap.

Hoe hernoem ik kolommen tijdens het laden van data in pandas?

Als je al vóór het laden weet dat je andere kolomnamen wilt, kun je het hernoemen direct binnen pd.read_csv() doen. Geef een lijst met namen door aan de parameter names en zet header=0 om pandas te vertellen de bestaande headerregel over te slaan en in plaats daarvan jouw namen te gebruiken:

import pandas as pd
from io import StringIO

# Simulating a CSV file for demonstration
csv_data = """txnId,custId,amt,date
1001,C01,49.99,2024-01-15
1002,C02,125.00,2024-01-16
1003,C01,79.50,2024-01-17"""

# Renames columns at load time, skipping the original header
transactions = pd.read_csv(
    StringIO(csv_data),
    header=0,
    names=["transaction_id", "customer_id", "amount_usd", "transaction_date"]
)
print(transactions)

Dit is een handige shortcut wanneer je het schema beheert en geen aparte .rename()-stap in je laadcode wilt hebben. Als het bestand helemaal geen headerregel heeft, laat dan header=0 weg en gebruik gewoon names=[...] om kolomnamen vanaf nul toe te wijzen. Voor een diepere kijk op de opties voor het laden van datasets raad ik de tutorial pandas read_csv() aan.

Eén kanttekening: dit is alles-of-niets. De parameter names vervangt elke kolomnaam, dus de lijstlengte moet exact overeenkomen met het aantal kolommen in het bestand. Als je maar enkele kolommen wilt hernoemen, laad dan eerst het bestand en gebruik daarna .rename().

Voor een begeleide walkthrough van deze patronen naast andere veelvoorkomende opschoontaken, raad ik je aan onze cursus Cleaning Data in Python te volgen.

Kolommen hernoemen in Polars vs. pandas

Als je met zowel pandas als Polars werkt, of dat verwacht te doen, is het de moeite waard te weten hoe beide het hernoemen van kolommen afhandelen. De API op hoofdlijnen is vergelijkbaar, maar de details wijken af op manieren die je de eerste keren kunnen verrassen. Polars is een snelle, door Rust aangedreven DataFrame-bibliotheek die steeds gangbaarder wordt in moderne datastacks, en het spiergeheugen dat je in pandas opbouwt, draagt niet altijd vlekkeloos over.

Het hoofdidee is identiek. Je mappt oude namen naar nieuwe met een dictionary. De verschillen zitten in de details. Polars is per ontwerp immutable (geen inplace), method-chaining is de idiomatische stijl, en hernoemen op kolomniveau tijdens een select gebruikt .alias() in plaats van een aparte rename-stap.

Vergelijking naast elkaar

Dezelfde hernoeming in beide bibliotheken

Ter vergelijking volgt hier een eenvoudige hernoeming in beide bibliotheken.

Pandas:

# Pandas
import pandas as pd

orders_pd = pd.DataFrame({
    "ord_id": [1001, 1002, 1003],
    "cust_nm": ["Abe", "Rick", "Pat"]
})

orders_pd = orders_pd.rename(columns={"ord_id": "order_id", "cust_nm": "customer_name"})
print(orders_pd)

Polars:

# Polars
import polars as pl

orders_pl = pl.DataFrame({
    "ord_id": [1001, 1002, 1003],
    "cust_nm": ["Abe", "Rick", "Pat"]
})

orders_pl = orders_pl.rename({"ord_id": "order_id", "cust_nm": "customer_name"})
print(orders_pl)

Twee kleine verschillen om op te merken. Polars' .rename() neemt de dictionary direct. Er is geen keyword columns= omdat Polars alleen het hernoemen van kolommen ondersteunt (geen rij-index). En je moet het resultaat opnieuw toekennen. Er is geen inplace=True in Polars. Elke bewerking retourneert een nieuw DataFrame.

De Polars-uitvoer toont ook dtypes inline (i64, str) en de shape bovenaan, wat een van de kleine quality-of-life-dingen is die mensen prettig vinden zodra ze overstappen. 

Kolommen hernoemen tijdens een select

Voor hernoemen tijdens een transformatie gebruikt Polars .alias() binnen .select() of .with_columns():

# Polars
import polars as pl

orders_pl = pl.DataFrame({
    "ord_id": [1001, 1002, 1003],
    "cust_nm": ["Abe", "Rick", "Pat"]
})

# Select and rename in one expression
renamed = orders_pl.select(
    pl.col("ord_id").alias("order_id"),
    pl.col("cust_nm").alias("customer_name")
)

print(renamed)

In pandas zou het equivalent een .rename() zijn na een kolomselectie. Geen van beide is beter. Ze weerspiegelen de ontwerpfilosofie van elke bibliotheek. 

Als je een diepere vergelijking van de twee wilt, zou ik de tutorial pandas versus polars performance aanraden. En als je polars aan je gereedschapskist wilt toevoegen, raad ik onze cursus Introduction to Polars aan. 

Veelvoorkomende fouten en hoe je ze oplost

Twee fouten komen herhaaldelijk voor bij het hernoemen van pandaskolommen. Zo zien ze eruit, zo ontstaan ze, en zo los je ze op.

KeyError: kolomnaam niet gevonden

Standaard negeert .rename() stilletjes keys die met geen enkele bestaande kolom overeenkomen. Maar als je errors='raise' meegeeft om typefouten te vangen, krijg je een KeyError wanneer een key niet bestaat:

import pandas as pd

orders = pd.DataFrame({
    "order_id": [1001, 1002, 1003],
    "customer_name": ["Abe", "Rick", "Pat"]
})

# This raises an error
orders.rename(columns={"Order_ID": "order_id"}, errors="raise")

De meest voorkomende oorzaak is een vergissing met hoofd-/kleine letters (Order_ID versus order_id) of een onzichtbare spatie op het einde ("order_id " versus "order_id"). Wanneer je een KeyError krijgt, controleer drie dingen in deze volgorde:

1. Exacte spelling en casing
2. Verborgen witruimte
3. Of de kolom eerder al is hernoemd

Om de daadwerkelijke kolomnamen te verifiëren:

print(orders.columns.tolist())

# Use repr() as an alternative
print([repr(c) for c in orders.columns])

Zodra je de exacte strings ziet die pandas vasthoudt, is de typefout meestal duidelijk. Corrigeer dan de spelling en run opnieuw:

orders = orders.rename(columns={"order_id": "Order_ID"}, errors="raise")
print(orders.columns.tolist())

Dan is de vraag: wanneer gebruik je errors='raise' versus de standaard errors='ignore'. 

• De standaard is vergevingsgezind. Handig in scripts die DataFrames met wisselende schema's verwerken, waar een ontbrekende kolom niets mag laten crashen. 

• Schakel over op errors='raise' wanneer je wilt dat typefouten luidruchtig naar boven komen tijdens ontwikkeling, vooral in notebooks waar stille mislukkingen uren aan verward debuggen verderop veroorzaken.

ValueError: length mismatch bij df.columns

Wanneer je een lijst toewijst aan df.columns of .set_axis() gebruikt, moet de lijstlengte exact overeenkomen met het aantal kolommen. Zo niet, dan geeft pandas een ValueError:

import pandas as pd

products = pd.DataFrame({
    "sku": ["A100", "A101", "A102"],
    "name": ["Widget", "Gadget", "Gizmo"],
    "price": [9.99, 14.99, 19.99]
})

# This raises an error
products.columns = ["product_sku", "product_name"]

Het DataFrame heeft drie kolommen, maar er zijn slechts twee nieuwe namen opgegeven. De oplossing is om vóór het toewijzen het aantal kolommen te controleren:

print(len(products.columns))
products.columns = ["product_sku", "product_name", "product_price"]
print(products.columns.tolist())

Als je werkt met DataFrames waar het aantal kolommen kan variëren, is het veiliger om .rename() met een dictionary te gebruiken. Dat raakt alleen de kolommen die je noemt, dus een ontbrekende of extra kolom laat je code niet crashen.

Tot slot

Kolommen hernoemen in pandas komt neer op het kiezen van de methode die past bij de scope van je taak. Welke aanpak je ook kiest, de grootste praktische winst is het vastleggen van één naamgevingsconventie en die als eerste stap in elke analyse toepassen. snake_case is wat de meeste Python-code gebruikt. Schone kolomnamen kosten een paar seconden aan het begin en besparen je de rest van het project KeyError-verrassingen.

Gebruik .rename() met een dictionary voor gerichte hernoemingen. Wanneer elke kolom een nieuwe naam nodig heeft, is toewijzen aan df.columns of .set_axis() sneller dan een dictionary bouwen met elke oud-naar-nieuw mapping. En als het hernoemen een regel volgt, zoals witruimte strippen, alles lowercasing, camelCase converteren, dan kun je met een functie of de .str-accessor de regel één keer uitdrukken in plaats van gevallen op te sommen. Polars doet hetzelfde werk met een vergelijkbare API, maar de immutabele, chain-first stijl stuurt je naar andere gewoontes. 

Wil je je DataFrame-vaardigheden verder uitbouwen, dan raad ik de cursus Data Manipulation with pandas aan als volgende stap. Als je een gestructureerd leerpad wilt, behandelt de Data Analyst in Python-carrièretrack DataFrame-manipulatie naast de rest van de analystoolkit.