Spalten in Pandas umbenennen: Der komplette Guide mit Beispielen

Wie benenne ich Spalten mit .rename() um?

Die Methode .rename() ist der flexibelste Weg, eine pandas-DataFrame-Umbenennung durchzuführen – und die, zu der du am häufigsten greifst. 

Sie nimmt ein Dictionary, das alte auf neue Namen abbildet, lässt alle nicht genannten Spalten unangetastet und gibt standardmäßig ein neues DataFrame zurück, statt das Original zu verändern. Dadurch ist .rename() sicher in Method-Chains und leichter zu debuggen.

Das Dictionary-Muster sieht so aus:

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

Wenn Dictionaries für dich neu sind, lies zur Auffrischung unser Tutorial zu Python-Dictionary-Methoden.

Hinweis zum früheren copy-Parameter

Kurz vorweg: Pandas 3.0 hat den copy-Parameter deprecatet und Copy-on-Write als Standardverhalten eingeführt. Praktisch heißt das, du musst dir keine Sorgen mehr machen, ob .rename() eine teure Kopie deiner Daten erzeugt. Pandas regelt das lazy im Hintergrund. Der wichtigste Parameter, über den du noch nachdenken musst, ist inplace – dazu gleich mehr im dritten Unterabschnitt.

Eine einzelne Spalte umbenennen

Stell dir vor, du hast Kundendaten aus einem Legacy-CRM geladen. Die Spaltennamen sind Abkürzungen, die 2008 Sinn ergaben, heute aber nicht mehr. Das ist der einfachste Umbenennungsfall: ein alter Name, ein neuer Name, im 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)

Jetzt benenne cust_id_nbr in etwas Lesbareres um:

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

Das ursprüngliche customers-DataFrame bleibt unverändert. .rename() hat ein neues DataFrame zurückgegeben, das wir customers_renamed zugewiesen haben. Die beiden nicht genannten Spalten (first_nm, signup_dt) bleiben gleich.

Mehrere Spalten umbenennen

Das Dictionary skaliert natürlich. Um mehrere Spalten in pandas umzubenennen, fügst du einfach weitere Key-Value-Paare hinzu:

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

print(customers_clean)

Es gibt auch eine alternative Syntax mit den Argumenten mapper und axis statt dem Keyword columns:

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

Das axis=1 sagt pandas, dass du Spalten (und nicht mit axis=0 die Zeilenindizes) anvisierst. Beide Formen liefern dasselbe Ergebnis. In der Praxis dominiert columns={...}, weil es auf einen Blick klarer ist – dabei bleiben wir im weiteren Verlauf.

Ein nützliches Detail: Wenn du einen Key übergibst, der keiner existierenden Spalte entspricht, ignoriert .rename() ihn stillschweigend. Das ist praktisch bei wiederverwendbaren Funktionen für leicht unterschiedliche Schemas – kann aber Tippfehler verschleiern. Mit errors='raise' lässt du pandas bei unbekannten Spaltennamen einen Fehler werfen.

inplace vs. neues DataFrame zurückgeben

Standardmäßig gibt .rename() ein neues DataFrame zurück und lässt das Original in Ruhe. Wenn du das bestehende DataFrame direkt ändern willst, übergib inplace=True:

# Gibt ein neues DataFrame zurück (Standard)
customers_v2 = customers.rename(columns={"first_nm": "first_name"})

# Ändert customers direkt, gibt None zurück
customers.rename(columns={"first_nm": "first_name"}, inplace=True)

print(customers)

Welche Variante ist besser? Meist die Standardvariante, also ein neues DataFrame zurückgeben. Sie ist leichter zu debuggen, weil du das Original zum Vergleichen hast, und umgehst Alias-Probleme, die in älterem Code eine SettingWithCopyWarning auslösen.

Performance ist heute auch kein Argument mehr pro inplace. Mit Copy-on-Write als Standard in pandas 3.0+ arbeitet die Non-Inplace-Variante lazy und kopiert Daten erst bei einer tatsächlichen Änderung. Der frühere Speicher-Vorteil von inplace=True wiegt deutlich weniger.

Natürlich fühlt sich inplace=True in kurzen, explorativen Skripten weiterhin natürlich an, wenn du ein einzelnes DataFrame Schritt für Schritt bereinigst und nicht chainen willst. Für produktiven Code oder alles, was du später wieder anfasst, nimm die Standardeinstellung.

Wie benenne ich alle Spalten in pandas auf einmal um?

Manchmal willst du keine alten auf neue Namen mappen, sondern alle Spaltennamen auf einmal ersetzen. Das kommt öfter vor, als man denkt: kopflose CSVs, bei denen pandas 0, 1, 2 als Spaltennamen vergibt, Headerzeilen in einer anderen Sprache oder systemgenerierte Exports mit Namen wie Field1, Field2, Field3.

Es gibt zwei gängige Wege: direktes Zuweisen an df.columns oder .set_axis() verwenden. Beides liefert dasselbe Ergebnis. Es ist ein Trade-off zwischen Kürze und Chainability.

Eine Liste an df.columns zuweisen

Am direktesten weist du der columns-Eigenschaft eine neue Liste zu. Nimm dieses DataFrame, erstellt aus einer Liste von Listen ohne Header – wie bei einer kopflosen CSV. Pandas fällt dann auf Integer-Spaltennamen zurück:

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 Spaltennamen 0, 1 und 2 taugen nicht für Analysen. Ersetze sie, indem du der columns-Eigenschaft eine neue Liste zuweist:

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

Zwei Dinge solltest du wissen. 

1. Die Listenlänge muss exakt passen. Wenn du für ein vier-spaltiges DataFrame nur drei Namen übergibst, wirft pandas ValueError: Length mismatch (wir behandeln den Fehler später ausführlich). 

2. Die Änderung erfolgt in place. Es gibt keinen inplace-Parameter, denn die Zuweisung ist die Änderung. Wenn du eine frische Kopie willst, nutze vorher .copy() oder greife zu .set_axis() unten.

.set_axis() für Method-Chains nutzen

.set_axis() macht dasselbe, gibt aber ein neues DataFrame zurück, sodass du weiter chainen kannst. Nimm wieder ein kopfloses DataFrame, diesmal mit unaufgeräumteren Werten wie vielen Dezimalstellen und einem fehlenden Messwert:

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)

Das Argument axis=1 sagt pandas, dass du Spaltenlabels setzt (mit axis=0 würdest du den Zeilenindex setzen). Weil .set_axis() ein neues DataFrame liefert, fügt es sich nahtlos in verkettete Transformations-Pipelines ein, wie du sie in echter ETL- oder Analysearbeit schreibst. Das ist der Hauptgrund, es in der Praxis der direkten Zuweisung vorzuziehen.

Wie benenne ich Spalten in pandas per Funktionen um?

Statt jede alte Bezeichnung einer neuen zuzuordnen, kannst du eine Funktion an .rename() übergeben – pandas wendet sie dann auf jeden Spaltennamen an. Das ist ideal, wenn du eine Regel statt einer Liste hast, etwa „alles kleinschreiben“ oder „Leerzeichen durch Unterstriche ersetzen“.

Eingebaute String-Funktionen nutzen

Der einfachste Fall ist die Vereinheitlichung der Groß-/Kleinschreibung. Übergebe str.lower, str.upper oder str.title direkt an das 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())

Beachte: Wir übergeben die Funktion selbst (str.lower), ohne sie aufzurufen (str.lower()). Pandas wendet sie spaltenweise an. Praktisch für die Schreibweise – Leerzeichen und Sonderzeichen werden so aber nicht behandelt. Dafür brauchst du eine Lambda oder eine eigene Funktion.

Lambdas und Custom Functions verwenden

Für alles über reine Groß-/Kleinschreibung hinaus gibt dir eine Lambda eine schnelle Inline-Transformation. Wenn Lambdas neu für dich sind, ist unser Einsteiger-Guide zu Python-Lambdas ein guter Start.

Ein häufiges Muster ist: kleinschreiben und Leerzeichen durch Unterstriche ersetzen – in einem Schritt. Wir nehmen das vorige Beispiel:

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

Wenn die Logik komplexer wird, lagerst du sie in eine benannte Funktion aus. Hier ein Helper, der camelCase oder PascalCase in snake_case umwandelt:

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

Eine benannte Funktion ist leichter zu testen, wiederzuverwenden und zu dokumentieren als ein cleverer One-Liner. Nimm Lambdas, wenn die Logik in eine Zeile passt – und eigene Funktionen, wenn nicht.

Wie bereinige ich massenhaft unordentliche Spaltennamen in pandas?

Wenn Daten aus Tabellen, Drittanbieter-APIs oder handbearbeiteten CSVs kommen, haben Spaltennamen oft Probleme, die .rename() allein nicht elegant löst. Typische Fälle sind:

• Nachgestellter Leerraum
• Gemischte Groß-/Kleinschreibung
• Klammern
• Bindestriche
• Sonderzeichen
• Unsichtbare Unicode-Zeichen

In solchen Situationen arbeitest du am besten direkt auf df.columns mit dem .str-Accessor. Er stellt vektorisierte String-Methoden (inkl. Regex) für alle Spaltennamen gleichzeitig bereit. Das ist auch die Grundlage für sauberes Data Cleaning in Python. Saubere Spaltennamen machen jeden nachgelagerten Schritt (Filtern, Mergen, Plotten) robuster.

Leerraum und Sonderzeichen entfernen

Nimm dieses DataFrame – genau die Art von Export aus Excel, den zu viele Hände angefasst haben:

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

Vorangestellte und nachgestellte Leerzeichen sind die häufigsten und fiesesten Fehler – weil unsichtbar. Entferne sie in einer Zeile:

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

Für Sonderzeichen akzeptiert .str.replace() ein Regex-Muster. Das Muster unten behält Buchstaben, Zahlen, Unterstriche und Leerzeichen und entfernt alles andere:

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

Bindestrich, Klammern und Dollarzeichen sind weg. Beachte: Total Amount hat nun ein Leerzeichen am Ende (wo vorher ($) stand) und OrderDate hat seinen Bindestrich verloren. Genau deshalb strippen wir am Ende einer Cleaning-Pipeline noch einmal.

Auf snake_case standardisieren

Eine bewährte Praxis ist, alle Spaltennamen vor der Analyse auf snake_case zu bringen: kleingeschrieben, Wörter mit Unterstrichen getrennt, keine Sonderzeichen. Verknüpfe die .str-Methoden zu einem Ausdruck:

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()                                  # führenden/nachgestellten Leerraum entfernen
    .str.lower()                                  # alles kleinschreiben
    .str.replace(r"[^a-z0-9]+", "_", regex=True)  # Nicht-Alphanumerisches zu Unterstrichen verdichten
    .str.strip("_")                               # führende/nachgestellte Unterstriche entfernen
)

print(raw_export.columns.tolist())

Vier Zeilen – und deine Spaltennamen sind vorhersagbar, kleingeschrieben und sauber mit Unterstrichen getrennt. Dieses Muster lohnt sich als Utility-Funktion. Hast du sie einmal, kannst du sie auf jedes chaotische DataFrame anwenden.

Oft kombinierst du Umbenennen mit Spaltenentfernung. Dafür deckt das Tutorial zum Spaltenlöschen in pandas den nächsten Schritt ab.

Wie benenne ich Spalten schon beim Laden in pandas um?

Wenn du schon vor dem Laden weißt, dass du andere Spaltennamen willst, kannst du direkt in pd.read_csv() umbenennen. Übergebe eine Liste an names und setze header=0, damit pandas die bestehende Headerzeile überspringt und deine Namen verwendet:

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)

Das ist nützlich, wenn du das Schema kontrollierst und keinen separaten .rename()-Schritt in deinem Ladelogik-Block haben willst. Hat die Datei gar keine Headerzeile, lass header=0 weg und nutze nur names=[...], um Namen von Grund auf zu vergeben. Für einen tieferen Blick in die Ladeoptionen empfehle ich das Tutorial zu pandas read_csv().

Ein Hinweis: Das ist ein Alles-oder-nichts-Ansatz. Der names-Parameter ersetzt jeden Spaltennamen, daher muss die Listenlänge exakt der Spaltenanzahl entsprechen. Willst du nur wenige Spalten umbenennen, lade erst und nutze danach .rename().

Für einen geführten Rundgang durch diese Muster und weitere typische Aufräumarbeiten empfehle ich den Kurs Cleaning Data in Python.

Spalten umbenennen in Polars vs. pandas

Wenn du mit pandas und Polars arbeitest oder es planst, lohnt es sich zu wissen, wie beide das Umbenennen handhaben. Die API ist ähnlich, aber die Details unterscheiden sich – und überraschen anfangs. Polars ist eine schnelle, Rust-basierte DataFrame-Bibliothek, die in modernen Data Stacks immer häufiger wird – die in pandas erlernte Muskelmemory überträgt sich nicht immer 1:1.

Die Grundidee ist identisch: Alte auf neue Namen per Dictionary mappen. Die Unterschiede stecken im Detail. Polars ist von Haus aus immutable (kein inplace), Method-Chaining ist idiomatisch, und Umbenennen auf Spaltenebene während einer Auswahl nutzt .alias() statt eines separaten Rename-Schritts.

Gegenüberstellung

Dasselbe Umbenennen in beiden Bibliotheken

Zum Vergleich hier ein einfaches Umbenennen in beiden 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)

Zwei kleine Unterschiede: Polars .rename() nimmt das Dictionary direkt – es gibt kein columns=, da Polars nur Spalten (keine Zeilenindizes) umbenennt. Und du musst das Ergebnis neu zuweisen. inplace=True gibt es in Polars nicht; jede Operation liefert ein neues DataFrame.

Die Polars-Ausgabe zeigt außerdem dtypes inline (i64, str) und die Shape oben – ein kleines Quality-of-Life-Detail, das viele zu schätzen lernen.

Spalten beim Select umbenennen

Für Umbenennungen innerhalb einer Transformation nutzt Polars .alias() innerhalb von .select() oder .with_columns():

# Polars
import polars as pl

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

# Select und Rename in einem Ausdruck
renamed = orders_pl.select(
    pl.col("ord_id").alias("order_id"),
    pl.col("cust_nm").alias("customer_name")
)

print(renamed)

In pandas entspräche das einem .rename() nach der Spaltenauswahl. Beides ist okay – es spiegelt die jeweilige Designphilosophie wider. 

Wenn du tiefer vergleichen willst, empfehle ich das Tutorial zu Leistung: pandas vs. polars. Und wenn du Polars in deinen Werkzeugkasten aufnehmen willst, schau dir den Kurs Introduction to Polars an. 

Häufige Fehler und wie du sie behebst

Zwei Fehler tauchen beim Umbenennen in pandas immer wieder auf. So sehen sie aus, deshalb passieren sie – und so behebst du sie.

KeyError: Spaltenname nicht gefunden

Standardmäßig ignoriert .rename() Keys, die keiner existierenden Spalte entsprechen. Wenn du jedoch errors='raise' setzt, um Tippfehler zu fangen, wirft pandas einen KeyError, wenn ein Key nicht existiert:

import pandas as pd

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

# Das wirft einen Fehler
orders.rename(columns={"Order_ID": "order_id"}, errors="raise")

Die häufigsten Ursachen sind Groß-/Kleinschreibung (Order_ID vs. order_id) oder ein unsichtbares Leerzeichen am Ende ("order_id " vs. "order_id"). Prüfe bei KeyError nacheinander:

1. Exakte Schreibweise und Case
2. Versteckte Leerzeichen
3. Ob die Spalte zuvor schon umbenannt wurde

So siehst du die tatsächlichen Spaltennamen:

print(orders.columns.tolist())

# Alternative mit repr()
print([repr(c) for c in orders.columns])

Sobald du die exakten Strings siehst, fällt der Fehler meist auf. Korrigiere die Schreibweise und führe es erneut aus:

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

Wann nutzt du errors='raise' vs. das Standard-errors='ignore'? 

• Der Standard ist fehlertolerant. Praktisch in Skripten mit variierenden Schemas, wo eine fehlende Spalte nichts zum Absturz bringen soll. 

• Schalte auf errors='raise', wenn Tippfehler während der Entwicklung laut auffallen sollen – besonders in Notebooks, wo stille Fehler später stundenlanges Debuggen verursachen.

ValueError: Length mismatch bei df.columns

Wenn du eine Liste an df.columns zuweist oder .set_axis() verwendest, muss die Listenlänge exakt der Spaltenanzahl entsprechen. Andernfalls wirft pandas einen ValueError:

import pandas as pd

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

# Das wirft einen Fehler
products.columns = ["product_sku", "product_name"]

Das DataFrame hat drei Spalten, aber es wurden nur zwei neue Namen übergeben. Die Lösung: erst die Spaltenanzahl prüfen, dann zuweisen:

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

Wenn du mit DataFrames arbeitest, deren Spaltenanzahl variieren kann, ist .rename() mit Dictionary sicherer. Es fasst nur die benannten Spalten an – fehlende oder zusätzliche Spalten bringen deinen Code nicht zum Absturz.

Zum Schluss

Beim Umbenennen in pandas geht es darum, die Methode passend zum Aufgabenumfang zu wählen. Der größte praktische Gewinn entsteht, wenn du dich auf eine einheitliche Namenskonvention festlegst und sie als allerersten Schritt jeder Analyse anwendest. snake_case ist in der Python-Welt üblich. Saubere Spaltennamen kosten am Anfang Sekunden – und ersparen dir später KeyError-Überraschungen.

Nutze .rename() mit Dictionary für gezielte Umbenennungen. Wenn jede Spalte einen neuen Namen braucht, ist das Zuweisen an df.columns oder .set_axis() schneller, als ein komplettes Mapping aufzubauen. Und wenn die Umbenennung einer Regel folgt – etwa Leerraum entfernen, alles kleinschreiben, camelCase konvertieren –, dann drück die Regel einmal per Funktion aus oder nutze den .str-Accessor, statt alle Fälle einzeln aufzulisten. Polars erledigt dasselbe mit ähnlicher API, aber sein immutables, chain-first Design führt dich zu leicht anderen Gewohnheiten. 

Um deine DataFrame-Kompetenzen weiter auszubauen, empfehle ich als Nächstes den Kurs Data Manipulation with pandas. Wenn du einen strukturierten Lernpfad willst, deckt der Data Analyst in Python-Lernpfad DataFrame-Manipulation zusammen mit dem restlichen Analysten-Toolkit ab.