Byta namn på kolumner i pandas: en komplett guide med exempel

Hur byter jag namn på kolumner med .rename()?

Metoden .rename() är det mest flexibla sättet att byta namn på kolumner i en pandas-DataFrame, och den du oftast kommer att använda. 

Den tar ett lexikon som mappar gamla namn till nya, lämnar alla kolumner du inte nämner orörda och returnerar som standard en ny DataFrame istället för att ändra originalet. Det gör .rename() säkert att använda i metodkedjor och lätt att resonera om vid felsökning.

Mönstret med ett lexikon ser ut så här:

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

Om du är ny på lexikon rekommenderar jag att du går igenom vår handledning om Python-dictionary-metoder som repetition.

Notis om den gamla copy-parametern

En snabb notis före exemplen. I Pandas 3.0 avvecklades parametern copy och Copy-on-Write blev standardbeteendet. I praktiken betyder det att du inte längre behöver oroa dig för om .rename() gör en dyr kopia av dina data. Pandas hanterar det lat under huven. Den huvudsakliga parametern att tänka på är inplace, som vi tar upp i den tredje delsektionen.

Byta namn på en enskild kolumn

Tänk dig att du precis har läst in kundregister exporterade från ett äldre CRM. Kolumnnamnen är förkortade på ett sätt som var logiskt för den som designade databasen 2008, men inte för dig. Detta är det enklaste pandas-uppdraget för att byta namn på kolumner: ett gammalt namn, ett nytt namn, i ett lexikon:

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)

Byt nu namn på cust_id_nbr till något mer läsbart:

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

Den ursprungliga DataFrame:en customers är oförändrad. .rename() returnerade en ny DataFrame, som vi tilldelade customers_renamed. De två kolumner vi inte nämnde (first_nm, signup_dt) följde med oförändrade.

Byta namn på flera kolumner

Lexikonet skalar naturligt. För att hantera ett uppdrag i pandas att byta namn på flera kolumner, lägg bara till fler nyckel-värde-par i mappningen:

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

print(customers_clean)

Det finns också en alternativ syntax som använder argumenten mapper och axis istället för nyckelordet columns:

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

axis=1 talar om för pandas att du siktar på kolumner (till skillnad från axis=0 för radindexetiketter). Båda formerna ger samma resultat. Den mesta koden där ute använder columns={...} eftersom det är tydligare vid en snabb anblick, så vi håller oss till det mönstret i resten av guiden.

En användbar detalj är att om du skickar in en nyckel som inte matchar någon befintlig kolumn ignorerar .rename() den tyst som standard. Det är praktiskt när du skriver en återanvändbar funktion som kan hantera DataFrames med något olika scheman, men det kan också dölja stavfel. För att få pandas att kasta ett fel vid okända kolumnnamn, skicka errors='raise'.

Använda inplace vs. att returnera en ny DataFrame

Som standard returnerar .rename() en ny DataFrame och lämnar originalet ifred. Om du vill att den ska ändra den befintliga DataFrame:en direkt, skicka inplace=True:

# Returnerar en ny DataFrame (standard)
customers_v2 = customers.rename(columns={"first_nm": "first_name"})

# Ändrar customers direkt, returnerar None
customers.rename(columns={"first_nm": "first_name"}, inplace=True)

print(customers)

Så vilken ska du använda? I de flesta fall är standarden, att returnera en ny DataFrame, det bättre valet. Det är också enklare att felsöka, eftersom du fortfarande har den ursprungliga DataFrame:en att inspektera när något går fel. Och det kringgår aliasproblem som ger en SettingWithCopyWarning i äldre kod.

Prestanda är inte längre riktigt ett skäl att föredra inplace heller. Med Copy-on-Write, som nu är standard i pandas 3.0+, använder icke-inplace-versionen lat kopiering. Den duplicerar faktiskt inte dina data förrän något ändras. Det gamla argumentet att inplace=True sparar minne är mycket svagare än det brukade vara.

Den plats där inplace=True fortfarande känns naturligt är i korta, utforskande skript där du städar en enda DataFrame steg för steg och inte bryr dig om kedjning. För produktionskod eller något du kommer att återvända till senare, föredra standarden.

Hur byter jag namn på alla kolumner på en gång i pandas?

Ibland vill du inte mappa gamla namn till nya. Du vill bara ersätta varje kolumnnamn på en gång. Det händer oftare än du tror, som huvudlösa CSV-filer där pandas tilldelade 0, 1, 2 som kolumnnamn, dataset där rubrikraden är på ett annat språk, eller systemgenererade exporter med namn som Field1, Field2, Field3.

Det finns två vanliga sätt att göra detta. Antingen tilldela direkt till df.columns, eller använd .set_axis(). De ger samma resultat. Avvägningen står mellan korthet och möjlighet till kedjning.

Tilldela en lista till df.columns

Det mest direkta tillvägagångssättet är att tilldela en ny lista till attributet columns. Ta denna DataFrame, byggd från en lista med listor utan rubrikinformation, som det du får när du läser en huvudlös CSV. Pandas faller tillbaka till heltalsnamn för kolumner:

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)

Dessa kolumnnamn 0, 1 och 2 är värdelösa för analys. Ersätt dem genom att tilldela en ny lista med namn till attributet columns:

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

Två saker att veta om detta tillvägagångssätt. 

1. Listans längd måste stämma exakt. Skicka tre namn för en DataFrame med fyra kolumner och pandas kastar ValueError: Length mismatch (vi tar upp detta fel mer i detalj senare). 

2. Det ändrar DataFrame:en på plats. Det finns ingen inplace-parameter här eftersom tilldelningen är ändringen. Om du vill ha en ny kopia, använd .copy() först eller ta till .set_axis() nedan.

Använda .set_axis() för metodkedjning

Metoden .set_axis() gör samma sak, men returnerar en ny DataFrame så att du kan kedja den med andra operationer. Ta en liknande huvudlös DataFrame, men den här gången med lite rörigare data som extra decimaler och en saknad avläsning:

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)

axis=1-argumentet talar om för pandas att du sätter kolumnetiketter (använd axis=0 för att sätta radindex istället). Eftersom .set_axis() returnerar en ny DataFrame passar den naturligt in i den typ av kedjade transformationspipelines du skriver i verklig ETL- eller analyskod. Det är huvudskälet att föredra den framför direkt tilldelning i produktion.

Hur byter jag namn på kolumner med funktioner i pandas?

Istället för att mappa varje gammalt namn till ett nytt kan du skicka en funktion till .rename(), så tillämpar pandas den på varje kolumnnamn. Detta är rätt verktyg när du har en regel snarare än en lista.  Till exempel ”gör allt till gemener” eller ”ersätt varje blanksteg med ett understreck”.

Använda inbyggda strängfunktioner

Det enklaste fallet är att standardisera versalisering. Skicka str.lower, str.upper eller str.title direkt till argumentet 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())

Observera att vi skickar själva funktionen (str.lower), inte anropar den (str.lower()). Pandas tillämpar den på varje kolumnnamn ett i taget. Detta är en smidig genväg för att standardisera versalisering, men den hanterar inte blanksteg eller specialtecken. För det vill du ha en lambda eller en egen funktion.

Använda lambda och egna funktioner

För allt bortom versalskiften ger en lambda ett snabbt sätt att uttrycka transformationen inline. Om du inte använt lambdor tidigare är vår nybörjarguide till Python-lambda-funktioner en bra start.

Ett vanligt mönster är att göra gemener och ersätta blanksteg med understreck i ett steg. Vi använder föregående exempel:

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

När logiken blir mer omfattande, lyft ut den till en namngiven funktion. Betrakta denna hjälpare som konverterar camelCase eller PascalCase-kolumnnamn till 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())

En namngiven funktion som denna är enklare att testa, återanvända mellan anteckningsböcker och dokumentera än en klurig one-liner. Ta till lambdor när logiken ryms på en rad, och egna funktioner när den inte gör det.

Hur städar jag röriga kolumnnamn i bulk i pandas?

När data kommer från kalkylblad, tredjeparts-API:er eller handredigerade CSV:er har kolumnnamn ofta problem som .rename() inte kan lösa snyggt. Jag pratar om problem som:

• Avslutande blanksteg
• Blandade versaler
• Parenteser
• Bindestreck
• Specialtecken
• Osynliga Unicode-tecken

För dessa situationer är det renast att arbeta direkt på df.columns med .str-accessorn, som exponerar vektoriserade strängmetoder (inklusive regex) över alla kolumnnamn på en gång. Detta är också grunden för solid datastädning i Python. Att städa kolumnnamn gör varje nedströmssteg (filtrering, sammanslagning, visualisering) mindre felbenäget.

Trimma blanksteg och specialtecken

Ta denna DataFrame, med den typ av namn du får från en Excel-export som för många har varit inne och ändrat i:

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

Inledande och avslutande blanksteg är de vanligaste och mest frustrerande problemen, eftersom de är osynliga. Trimma dem på en rad:

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

För specialtecken accepterar .str.replace() ett regexmönster. Mönstret nedan behåller bokstäver, siffror, understreck och blanksteg, och tar bort allt annat:

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

Bindestrecket, parenteserna och dollartecknet är borta. Notera att Total Amount nu har ett avslutande blanksteg (från där ($) brukade vara), och att OrderDate tappade sitt bindestreck helt. Det är precis därför vi trimmar igen i slutet av en städpipeline.

Standardisera till snake_case

En vanlig bästa praxis är att konvertera alla kolumnnamn till snake_case innan du börjar någon analys: gemener, ord separerade med understreck, inga specialtecken. Kedja ihop .str-metoderna för att nå dit i ett enda uttryck:

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()                                  # ta bort inledande/avslutande blanksteg
    .str.lower()                                  # gör allt till gemener
    .str.replace(r"[^a-z0-9]+", "_", regex=True)  # kollapsa icke-alfanumeriskt till understreck
    .str.strip("_")                               # ta bort eventuella inledande/avslutande understreck
)

print(raw_export.columns.tolist())

Fyra rader, och dina kolumnnamn är förutsägbara, gemena och separerade med understreck. Det här mönstret är värt att spara som en hjälpfunktion. När du väl har det kan du kasta det på varje rörig DataFrame som kommer in genom dörren. 

Du vill ofta kombinera namnbyte med kolumnborttagning också. För det täcker handledningen om att ta bort kolumner i pandas nästa steg.

Hur byter jag namn på kolumner när jag läser in data i pandas?

Om du redan vet att du vill ha andra kolumnnamn innan du ens läser in filen kan du göra namnbytet direkt i pd.read_csv(). Skicka en lista med namn till parametern names och sätt header=0 för att tala om för pandas att hoppa över den befintliga rubrikraden och använda dina namn istället:

import pandas as pd
from io import StringIO

# Simulerar en CSV-fil för 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"""

# Byter namn på kolumner vid inläsning och hoppar över den ursprungliga rubriken
transactions = pd.read_csv(
    StringIO(csv_data),
    header=0,
    names=["transaction_id", "customer_id", "amount_usd", "transaction_date"]
)
print(transactions)

Detta är en användbar genväg när du styr schemat och inte vill ha ett separat .rename()-steg som rör till din inläsningskod. Om filen inte har någon rubrikrad alls, utelämna header=0 och använd bara names=[...] för att tilldela kolumnnamn från grunden. För en djupare titt på alternativen vid inläsning av dataset rekommenderar jag handledningen pandas read_csv().

En brasklapp: Detta är ett allt-eller-inget-tilvägagångssätt. Parametern names ersätter varje kolumnnamn, så listlängden måste matcha antalet kolumner i filen exakt. Om du bara vill byta namn på några få kolumner, läs in filen först och använd .rename() i efterhand.

För en guidning genom dessa mönster tillsammans med andra vanliga städuppgifter rekommenderar jag kursen Cleaning Data in Python.

Byta namn på kolumner i Polars vs. pandas

Om du arbetar i både pandas och Polars, eller förväntar dig att göra det, är det värt att veta hur var och en hanterar namnbyte på kolumner. API:t på hög nivå är liknande, men detaljerna skiljer sig på sätt som snärjer dig de första gångerna. Polars är ett snabbt, Rust-baserat DataFrame-bibliotek som blir allt vanligare i moderna datastackar, och muskelminnet du bygger i pandas överförs inte alltid klockrent.

Huvudidén är identisk. Du mappar gamla namn till nya med ett lexikon. Skillnaderna ligger i detaljerna. Polars är oföränderligt (ingen inplace), metodkedjning är det idiomatiska sättet, och namnbyte på kolumnnivå under en select använder .alias() snarare än ett separat namnbytessteg.

Jämförelse sida vid sida

Samma namnbyte i båda biblioteken

Som jämförelse följer här ett enkelt namnbyte i respektive bibliotek.

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)

Två små skillnader att notera. Polars .rename() tar lexikonet direkt. Det finns inget columns=-nyckelord eftersom Polars bara stödjer att byta namn på kolumner (inte radindex). Och du måste tilldela resultatet igen. Det finns inget inplace=True i Polars. Varje operation returnerar en ny DataFrame.

Polars-utskriften visar också dtypes inline (i64, str) och formen högst upp, vilket är en av de små bekvämligheterna som många uppskattar när de byter. 

Byta namn på kolumner under en select

För namnbyte under en transformation använder Polars .alias() inuti .select() eller .with_columns():

# Polars
import polars as pl

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

# Välj och byt namn i ett uttryck
renamed = orders_pl.select(
    pl.col("ord_id").alias("order_id"),
    pl.col("cust_nm").alias("customer_name")
)

print(renamed)

I pandas skulle motsvarigheten vara ett .rename() efter en kolumnselektion. Inget av tillvägagångssätten är bättre. De speglar respektive biblioteks designfilosofi. 

Om du vill ha en djupare jämförelse av de två rekommenderar jag handledningen pandas versus polars prestanda. Och om du vill lägga till polars i din verktygslåda rekommenderar jag vår kurs Introduction to Polars. 

Vanliga fel och hur du åtgärdar dem

Två fel dyker upp upprepade gånger när man byter namn på pandas-kolumner. Så här ser de ut, varför de händer och hur du fixar dem.

KeyError: kolumnnamn hittades inte

Som standard ignorerar .rename() tyst nycklar som inte matchar någon befintlig kolumn. Men om du skickar errors='raise' för att fånga stavfel får du en KeyError när en nyckel inte finns:

import pandas as pd

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

# Detta kastar ett fel
orders.rename(columns={"Order_ID": "order_id"}, errors="raise")

Den vanligaste orsaken är en glidning i skiftläget (Order_ID kontra order_id) eller ett osynligt avslutande blanksteg ("order_id " kontra "order_id"). När du stöter på en KeyError, kontrollera tre saker i ordning:

1. Exakt stavning och skiftläge
2. Dolt blanksteg
3. Om kolumnen redan bytte namn tidigare

För att verifiera de faktiska kolumnnamnen:

print(orders.columns.tolist())

# Använd repr() som alternativ
print([repr(c) for c in orders.columns])

När du ser exakt vilka strängar pandas håller blir stavfelet oftast uppenbart. Rätta sedan stavningen och kör om:

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

Nu är frågan när du ska använda errors='raise' kontra standarden errors='ignore'. 

• Standardläget är förlåtande. Det är praktiskt i skript som bearbetar DataFrames med varierande scheman, där en saknad kolumn inte bör krascha något. 

• Växla till errors='raise' när du vill att stavfel ska bubbla upp tydligt under utveckling, särskilt i anteckningsböcker där tysta fel orsakar timmars förvirrande felsökning nedströms.

ValueError: length mismatch med df.columns

När du tilldelar en lista till df.columns eller använder .set_axis() måste listlängden matcha antalet kolumner exakt. Om den inte gör det kastar pandas ett ValueError:

import pandas as pd

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

# Detta kastar ett fel
products.columns = ["product_sku", "product_name"]

DataFrame:en har tre kolumner, men bara två nya namn angavs. Lösningen är att kontrollera antalet kolumner innan du tilldelar:

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

Om du arbetar med DataFrames där antalet kolumner kan variera är det säkrare att använda .rename() med ett lexikon. Det rör bara de kolumner du namnger, så en saknad eller extra kolumn kraschar inte din kod.

Avslutande tankar

Att byta namn på kolumner i pandas handlar om att välja den metod som matchar omfattningen av din uppgift. Oavsett vilket tillvägagångssätt du väljer är den största praktiska vinsten att landa i en enda namngivningskonvention och tillämpa den som första steg i varje analys. snake_case är vad de flesta Python-kodbaser använder. Rena kolumnnamn kostar några sekunder i början och sparar dig från KeyError-överraskningar resten av projektet.

Använd .rename() med ett lexikon för riktade namnbyten. När varje kolumn behöver ett nytt namn är tilldelning till df.columns eller att använda .set_axis() snabbare än att bygga ett lexikon med varje gammalt-till-nytt-par. Och om namnbytet följer en regel som att trimma blanksteg, göra allt till gemener, konvertera camelCase, så låter en funktion eller .str-accessorn dig uttrycka regeln en gång istället för att räkna upp fall. Polars hanterar samma arbete med ett liknande API, men dess oföränderliga, kedje-först-stil knuffar dig mot andra vanor. 

För att fortsätta bygga dina DataFrame-färdigheter rekommenderar jag kursen Data Manipulation with pandas som nästa steg. Om du vill ha en strukturerad inlärningsväg täcker Data Analyst in Python-karriärspåret DataFrame-manipulation tillsammans med resten av analytikerns verktygslåda.