Redenumirea coloanelor în pandas: un ghid complet cu exemple

Cum redenumesc coloane cu .rename()?

Metoda .rename() este cea mai flexibilă modalitate de a face o operațiune de tip pandas DataFrame rename column și cea la care vei apela cel mai des. 

Primește un dicționar care map-ează numele vechi la numele noi, lasă neatinse coloanele pe care nu le menționezi și, implicit, returnează un nou DataFrame în loc să-l modifice pe cel original. Asta face ca .rename() să fie sigur de folosit în lanțuri de metode și ușor de urmărit la depanare.

Modelul de dicționar arată așa:

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

Dacă ești nou în lumea dicționarelor, îți recomand să parcurgi tutorialul despre metodele dicționarelor în Python pentru o recapitulare.

Notă despre vechiul parametru copy

O scurtă notă înainte de exemple. Pandas 3.0 a deprecat parametrul copy și a făcut Copy-on-Write comportamentul implicit. În practică, asta înseamnă că nu mai trebuie să te îngrijorezi dacă .rename() face o copie costisitoare a datelor. Pandas gestionează asta „leneș” în spate. Principala opțiune rămasă de luat în calcul este inplace, pe care o acoperim în a treia subsecțiune.

Redenumirea unei singure coloane

Imaginează-ți că tocmai ai încărcat înregistrări de clienți exportate dintr-un CRM vechi. Denumirile coloanelor sunt abreviate într-un mod care avea sens pentru cineva care a proiectat baza de date în 2008, dar nu și pentru tine. Aceasta este cea mai simplă operațiune pandas rename column: un nume vechi, un nume nou, într-un dicționar:

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)

Acum, redenumește cust_id_nbr într-un nume mai lizibil:

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

DataFrame-ul customers original rămâne neschimbat. .rename() a returnat un nou DataFrame, pe care l-am asignat la customers_renamed. Cele două coloane pe care nu le-am menționat (first_nm, signup_dt) au rămas la fel.

Redenumirea mai multor coloane

Dicționarul se scalează natural. Pentru o sarcină de tip pandas rename multiple columns, adaugă mai multe perechi cheie-valoare în mapare:

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

print(customers_clean)

Există și o sintaxă alternativă care folosește argumentele mapper și axis în locul cuvântului cheie columns:

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

axis=1 îi spune lui pandas că vizezi coloanele (spre deosebire de axis=0 pentru etichetele indexului de rând). Ambele forme produc același rezultat. Majoritatea codului din „lumea reală” folosește columns={...} pentru că se citește mai clar dintr-o privire, așa că vom rămâne la acest model pentru restul tutorialului.

Un detaliu util este că, dacă transmiți o cheie care nu se potrivește cu nicio coloană existentă, .rename() o ignoră în tăcere în mod implicit. E convenabil când scrii o funcție reutilizabilă care ar putea gestiona DataFrame-uri cu scheme ușor diferite, dar poate ascunde și greșeli de tastare. Pentru a face pandas să arunce o eroare la nume de coloane necunoscute, treci errors='raise'.

Folosirea lui inplace vs. returnarea unui nou DataFrame

Implicit, .rename() returnează un nou DataFrame și îl lasă pe cel original neatins. Dacă vrei să modifice direct DataFrame-ul existent, treci inplace=True:

# Returnează un nou DataFrame (implicit)
customers_v2 = customers.rename(columns={"first_nm": "first_name"})

# Modifică direct customers, returnează None
customers.rename(columns={"first_nm": "first_name"}, inplace=True)

print(customers)

Deci pe care să-l folosești? În cele mai multe cazuri, varianta implicită, care returnează un nou DataFrame, e alegerea mai bună. E și mai ușor de depanat, deoarece încă ai DataFrame-ul original de inspectat când ceva nu merge. Și ocolește problemele de aliasing care produceau un SettingWithCopyWarning în codul mai vechi.

Nici performanța nu mai e un motiv să preferi inplace. Odată cu Copy-on-Write, acum implicit în pandas 3.0+, varianta non-inplace folosește copiere leneșă. Nu-ți dublează efectiv datele până când nu se modifică ceva. Vechiul argument că inplace=True economisește memorie este mult mai slab decât era.

Singurul loc unde inplace=True încă se simte natural este în scripturi scurte, exploratorii, unde cureți un singur DataFrame pas cu pas și nu te interesează chain-urile. Pentru cod de producție sau orice vei reveni ulterior, preferă implicitul.

Cum redenumesc toate coloanele dintr-o dată în pandas?

Uneori nu vrei să map-ezi nume vechi la nume noi. Vrei pur și simplu să înlocuiești toate numele de coloane dintr-o dată. Asta apare mai des decât te-ai aștepta, ca în CSV-uri fără antet unde pandas a atribuit 0, 1, 2 drept nume de coloane, seturi de date unde rândul de antet e într-o altă limbă sau exporturi generate de sistem cu nume precum Field1, Field2, Field3.

Există două moduri comune de a face asta. Fie atribui direct la df.columns, fie folosești .set_axis(). Produc același rezultat. Compromisul este între concizie și posibilitatea de a le înlănțui.

Atribuirea unei liste la df.columns

Abordarea cea mai directă este să atribui o listă nouă atributului columns. Ia acest DataFrame, construit dintr-o listă de liste fără informații de antet, genul pe care îl obții când citești un CSV fără antet. Pandas revine la nume de coloane întregi:

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)

Numele de coloane 0, 1 și 2 sunt inutile pentru analiză. Înlocuiește-le atribuind o listă nouă de nume atributului columns:

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

Două lucruri de știut despre această abordare. 

1. Lungimea listei trebuie să se potrivească exact. Dacă transmiți trei nume pentru un DataFrame cu patru coloane, pandas ridică ValueError: Length mismatch (vom acoperi această eroare mai târziu). 

2. Modifică DataFrame-ul in place. Nu există un parametru inplace aici pentru că atribuirea este chiar modificarea. Dacă vrei o copie nouă, folosește întâi .copy() sau apelează la .set_axis() mai jos.

Folosirea .set_axis() pentru chaining

Metoda .set_axis() face același lucru, dar returnează un nou DataFrame, astfel încât o poți înlănțui cu alte operațiuni. Ia un DataFrame similar fără antet, dar de data asta cu niște date mai neîngrijite, precum zecimale în plus și o citire lipsă:

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)

Argumentul axis=1 îi spune lui pandas că setezi etichete de coloană (folosește axis=0 pentru a seta indexul rândurilor). Pentru că .set_axis() returnează un nou DataFrame, se potrivește natural în tipul de pipeline-uri transformare-înlanțuite pe care le scrii în ETL sau cod de analiză reale. Acesta e principalul motiv să o preferi față de atribuirea directă în producție.

Cum redenumesc coloane folosind funcții în pandas?

În loc să map-ezi fiecare nume vechi la unul nou, poți trece o funcție la .rename(), iar pandas o va aplica fiecărui nume de coloană. Acesta este instrumentul potrivit când ai o regulă, nu o listă. De exemplu, „transformă totul în lowercase” sau „înlocuiește fiecare spațiu cu un underscore”.

Folosirea funcțiilor string încorporate

Cazul cel mai simplu este standardizarea capitalizării. Transmite str.lower, str.upper sau str.title direct argumentului 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())

Observă că transmitem funcția în sine (str.lower), nu o apelăm (str.lower()). Pandas o aplică fiecărui nume de coloană pe rând. Este un scurtătură curată pentru standardizarea cassei, dar nu gestionează spațiile sau caracterele speciale. Pentru asta, vei dori un lambda sau o funcție personalizată.

Folosirea lambdelor și a funcțiilor personalizate

Pentru orice dincolo de schimbări de caz, un lambda îți oferă o modalitate rapidă de a exprima transformarea inline. Dacă nu ai folosit lambde înainte, ghidul pentru începători despre funcțiile lambda în Python este un bun punct de pornire.

Un tipar comun este să pui totul cu litere mici și să înlocuiești spațiile cu underscore-uri într-un singur pas. Folosim exemplul anterior:

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

Când logica devine mai complexă, extrage-o într-o funcție numită. Ia în considerare acest helper care convertește denumiri de coloane camelCase sau PascalCase în 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())

O funcție numită ca aceasta e mai ușor de testat, refolosit între notebook-uri și documentat decât un one-liner isteț. Apelează la lambde când logica încape pe un rând și la funcții personalizate când nu încape.

Cum curăț în masă denumirile dezordonate ale coloanelor în pandas?

Când datele vin din foi de calcul, API-uri terțe sau CSV-uri editate manual, denumirile coloanelor au adesea probleme pe care .rename() singur nu le poate rezolva elegant. Mă refer la probleme precum:

• Spații la final
• Cazuri mixte
• Paranteze
• Cratime
• Caractere speciale
• Caractere Unicode invizibile

Pentru aceste situații, abordarea cea mai curată este să operezi direct pe df.columns folosind accessorul .str, care expune metode string vectorizate (inclusiv regex) peste toate numele de coloane dintr-o dată. Aceasta este și fundația unui data cleaning solid în Python. Curățarea numelor de coloane face fiecare pas ulterior (filtrare, îmbinare, plotare) mai puțin predispus la erori.

Eliminarea spațiilor și a caracterelor speciale

Ia acest DataFrame, cu genul de denumiri pe care le-ai obține dintr-un export Excel atins de prea multe mâini:

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

Spațiile la început și la sfârșit sunt cele mai comune și mai frustrante probleme, pentru că sunt invizibile. Elimină-le într-un singur rând:

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

Pentru caractere speciale, .str.replace() acceptă un pattern regex. Patternul de mai jos păstrează litere, cifre, underscore-uri și spații și elimină restul:

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

Cratima, parantezele și semnul dolar au dispărut. Observă că Total Amount are acum un spațiu la final (de unde era ($)), iar OrderDate și-a pierdut cratima complet. Exact de aceea eliminăm din nou la finalul unui pipeline de curățare.

Standardizarea la snake_case

O bună practică frecventă este să convertești toate numele de coloane la snake_case înainte să începi orice analiză: litere mici, cuvinte separate prin underscore, fără caractere speciale. Înlănțuie metodele .str pentru a ajunge acolo într-o singură expresie:

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()                                  # elimină spațiile la început/sfârșit
    .str.lower()                                  # transformă totul în litere mici
    .str.replace(r"[^a-z0-9]+", "_", regex=True)  # comprimă non-alfanumericele în underscore-uri
    .str.strip("_")                               # elimină underscore-urile de la început/sfârșit
)

print(raw_export.columns.tolist())

Patru rânduri, iar numele coloanelor tale sunt previzibile, cu litere mici și separate prin underscore. Acest tipar merită salvat ca funcție utilitară. Odată ce îl ai, îl poți arunca pe orice DataFrame dezordonat care-ți intră pe ușă. 

De multe ori vei vrea să combini redenumirea cu eliminarea de coloane. Pentru asta, tutorialul despre eliminarea coloanelor în pandas acoperă următorul pas.

Cum redenumesc coloane când încarc datele în pandas?

Dacă știi deja că vrei alte nume de coloane înainte chiar de a încărca fișierul, poți face redenumirea direct în interiorul pd.read_csv(). Transmite o listă de nume parametrului names și setează header=0 pentru a-i spune lui pandas să ignore rândul de antet existent și să folosească în schimb numele tale:

import pandas as pd
from io import StringIO

# Simulăm un fișier CSV pentru demonstrație
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"""

# Redenumește coloanele la încărcare, sărind peste antetul original
transactions = pd.read_csv(
    StringIO(csv_data),
    header=0,
    names=["transaction_id", "customer_id", "amount_usd", "transaction_date"]
)
print(transactions)

Este o scurtătură utilă când controlezi schema și nu vrei un pas separat .rename() care să aglomereze codul de încărcare. Dacă fișierul nu are deloc rând de antet, omite header=0 și folosește doar names=[...] pentru a atribui de la zero numele coloanelor. Pentru o privire mai profundă asupra opțiunilor de încărcare a seturilor de date, ți-aș recomanda tutorialul pandas read_csv().

Un avertisment: acesta este un demers „totul sau nimic”. Parametrul names înlocuiește fiecare nume de coloană, așa că lungimea listei trebuie să se potrivească exact cu numărul de coloane din fișier. Dacă vrei să redenumești doar câteva coloane, încarcă mai întâi fișierul și folosește .rename() după.

Pentru un parcurs ghidat al acestor tipare alături de alte sarcini comune de curățare, îți recomand să parcurgi cursul nostru Cleaning Data in Python.

Redenumirea coloanelor în Polars vs. pandas

Dacă lucrezi atât cu pandas, cât și cu Polars, sau te aștepți să o faci, merită să știi cum gestionează fiecare redenumirea coloanelor. API-ul la nivel înalt este similar, dar detaliile diferă în moduri care te pot surprinde primele dăți. Polars este o bibliotecă rapidă de DataFrame, bazată pe Rust, tot mai des întâlnită în stack-urile moderne de date, iar automatismele pe care ți le formezi în pandas nu se transferă întotdeauna perfect.

Ideea principală este identică. Mapezi nume vechi la nume noi cu un dicționar. Diferențele sunt în detalii. Polars este imutabil prin design (fără inplace), chaining-ul este stilul idiomatic, iar redenumirea la nivel de coloană în timpul unui select folosește .alias() în locul unui pas separat de redenumire.

Comparație side-by-side

Aceeași redenumire în ambele biblioteci

Pentru comparație, iată o redenumire simplă în fiecare dintre cele două biblioteci.

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)

Două mici diferențe de observat. .rename() din Polars primește direct dicționarul. Nu există cuvântul cheie columns= pentru că Polars suportă doar redenumirea coloanelor (nu și a indexului de rând). Și trebuie să reasignezi rezultatul. Nu există inplace=True în Polars. Fiecare operațiune returnează un nou DataFrame.

Ieșirea Polars afișează și dtypurile inline (i64, str) și forma sus, unul dintre micile plusuri de „quality of life” pe care mulți le apreciază după ce fac trecerea. 

Redenumirea coloanelor în timpul unui select

Pentru redenumire în timpul unei transformări, Polars folosește .alias() în interiorul .select() sau .with_columns():

# Polars
import polars as pl

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

# Selectează și redenumește într-o singură expresie
renamed = orders_pl.select(
    pl.col("ord_id").alias("order_id"),
    pl.col("cust_nm").alias("customer_name")
)

print(renamed)

În pandas, echivalentul ar fi un .rename() după o selecție de coloane. Niciuna dintre abordări nu e „mai bună”. Ele reflectă filosofia de design a fiecărei biblioteci. 

Dacă vrei o comparație mai profundă între cele două, ți-aș recomanda tutorialul pandas versus polars performance. Iar dacă vrei să adaugi polars în trusa ta, îți recomand cursul nostru Introduction to Polars course. 

Erori comune și cum le remediezi

Două erori apar în mod repetat la redenumirea coloanelor în pandas. Iată cum arată, de ce apar și cum le repari.

KeyError: numele coloanei nu a fost găsit

Implicit, .rename() ignoră în tăcere cheile care nu se potrivesc cu vreo coloană existentă. Dar dacă treci errors='raise' pentru a prinde greșelile de tastare, vei primi un KeyError când o cheie nu există:

import pandas as pd

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

# Aceasta ridică o eroare
orders.rename(columns={"Order_ID": "order_id"}, errors="raise")

Cea mai frecventă cauză este o scăpare legată de sensibilitatea la majuscule (Order_ID versus order_id) sau un spațiu invizibil la final ("order_id " versus "order_id"). Când dai de un KeyError, verifică trei lucruri, în ordine:

1. Ortografia exactă și cazurile
2. Spațiile ascunse
3. Dacă coloana a fost deja redenumită anterior

Pentru a verifica numele de coloane reale:

print(orders.columns.tolist())

# Folosește repr() ca alternativă
print([repr(c) for c in orders.columns])

Odată ce vezi șirurile exacte pe care le deține pandas, greșeala e de obicei evidentă. Apoi corectează ortografia și rulează din nou:

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

Acum întrebarea este când să folosești errors='raise' versus implicitul errors='ignore'. 

• Implicitul e îngăduitor. E util în scripturi care procesează DataFrame-uri cu scheme variabile, unde o coloană lipsă nu ar trebui să blocheze nimic. 

• Comută la errors='raise' când vrei ca greșelile de tastare să iasă la suprafață zgomotos în timpul dezvoltării, mai ales în notebook-uri unde eșecurile silențioase cauzează ore de depanare confuză ulterior.

ValueError: length mismatch cu df.columns

Când atribui o listă la df.columns sau folosești .set_axis(), lungimea listei trebuie să se potrivească exact cu numărul de coloane. Dacă nu, pandas ridică un ValueError:

import pandas as pd

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

# Aceasta ridică o eroare
products.columns = ["product_sku", "product_name"]

DataFrame-ul are trei coloane, dar au fost furnizate doar două nume noi. Remediul este să verifici numărul de coloane înainte de atribuire:

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

Dacă lucrezi cu DataFrame-uri unde numărul de coloane poate varia, e mai sigur să folosești .rename() cu un dicționar. Atinge doar coloanele pe care le numești, astfel încât o coloană lipsă sau în plus nu-ți va bloca codul.

Gânduri finale

Redenumirea coloanelor în pandas se rezumă la alegerea metodei care corespunde cu amploarea sarcinii tale. Indiferent de abordarea pe care o alegi, cel mai mare câștig practic este să stabilești o singură convenție de denumire și să o aplici ca prim pas în fiecare analiză. snake_case este ceea ce folosește majoritatea codului Python. Numele de coloane curate îți consumă câteva secunde la început și te feresc de surprize KeyError pentru restul proiectului.

Folosește .rename() cu un dicționar pentru redenumiri țintite. Când fiecare coloană are nevoie de un nume nou, atribuirea la df.columns sau folosirea .set_axis() este mai rapidă decât construirea unui dicționar cu fiecare mapare vechi-nou. Iar dacă redenumirea urmează o regulă, precum eliminarea spațiilor, transformarea în litere mici, conversia camelCase, atunci trecerea unei funcții sau folosirea accessorului .str îți permite să exprimi regula o singură dată în loc să enumeri cazuri. Polars gestionează aceeași muncă cu un API similar, dar stilul său imutabil, orientat spre chaining, te împinge către alte obiceiuri. 

Pentru a-ți dezvolta în continuare abilitățile legate de DataFrame-uri, ți-aș recomanda cursul Data Manipulation with pandas ca pas următor. Dacă vrei o cale de învățare structurată, traseul de carieră Data Analyst in Python acoperă manipularea DataFrame-urilor alături de restul trusei unui analist.