Renommer des colonnes dans pandas : guide complet avec exemples

Comment renommer des colonnes avec .rename() ?

La méthode .rename() est la façon la plus flexible de renommer des colonnes d’un DataFrame pandas, et celle que vous utiliserez le plus souvent. 

Elle prend un dictionnaire qui fait correspondre anciens et nouveaux noms, laisse intactes les colonnes non mentionnées, et par défaut renvoie un nouveau DataFrame sans modifier l’original. Cela rend .rename() sûre dans des chaînages de méthodes et plus simple à raisonner en débogage.

Le schéma du dictionnaire ressemble à ceci :

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

Si vous débutez avec les dictionnaires, je vous recommande notre tutoriel sur les méthodes des dictionnaires Python pour une piqûre de rappel.

Note sur l’ancien paramètre copy

Avant les exemples, une précision rapide. Pandas 3.0 a déprécié le paramètre copy et a fait du Copy-on-Write le comportement par défaut. En pratique, vous n’avez plus à vous soucier du coût d’une copie dans .rename(). Pandas gère cela paresseusement sous le capot. Le principal paramètre restant est inplace, que nous verrons dans la troisième sous-section.

Renommer une seule colonne

Imaginez que vous venez de charger des fiches clients exportées d’un ancien CRM. Les noms de colonnes sont abrégés d’une façon qui avait du sens pour la base en 2008, mais pas pour vous. Voici l’opération la plus simple : un ancien nom, un nouveau, dans un dictionnaire :

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)

Renommez maintenant cust_id_nbr en quelque chose de plus lisible :

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

Le DataFrame customers d’origine est inchangé. .rename() a renvoyé un nouveau DataFrame, que nous avons affecté à customers_renamed. Les deux colonnes non mentionnées (first_nm, signup_dt) sont restées identiques.

Renommer plusieurs colonnes

Le dictionnaire passe naturellement à l’échelle. Pour renommer plusieurs colonnes, ajoutez simplement d’autres paires clé‑valeur au mapping :

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

print(customers_clean)

Il existe aussi une syntaxe alternative utilisant les arguments mapper et axis à la place du mot-clé columns :

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

axis=1 indique à pandas que vous ciblez les colonnes (par opposition à axis=0 pour l’index des lignes). Les deux formes produisent le même résultat. La plupart des codes dans la nature utilisent columns={...} car la lecture est plus immédiate ; nous garderons donc ce modèle pour la suite.

Un détail utile : si vous passez une clé qui ne correspond à aucune colonne existante, .rename() l’ignore silencieusement par défaut. Pratique quand vous écrivez une fonction réutilisable qui peut traiter des DataFrames aux schémas légèrement différents, mais cela peut aussi masquer des fautes de frappe. Pour que pandas lève une erreur sur les noms inconnus, passez errors='raise'.

Utiliser inplace vs. renvoyer un nouveau DataFrame

Par défaut, .rename() renvoie un nouveau DataFrame et laisse l’original intact. Si vous souhaitez modifier directement le DataFrame existant, passez inplace=True :

# Renvoie un nouveau DataFrame (par défaut)
customers_v2 = customers.rename(columns={"first_nm": "first_name"})

# Modifie customers directement, renvoie None
customers.rename(columns={"first_nm": "first_name"}, inplace=True)

print(customers)

Alors, que choisir ? Dans la plupart des cas, le comportement par défaut (retourner un nouveau DataFrame) est préférable. C’est aussi plus facile à déboguer, car vous conservez l’original à inspecter si quelque chose se passe mal. Et cela évite les problèmes d’aliasing qui déclenchent un SettingWithCopyWarning dans d’anciens codes.

La performance n’est plus une bonne raison de préférer inplace. Avec le Copy-on-Write, désormais par défaut en pandas 3.0+, la version non‑inplace utilise une copie paresseuse : les données ne sont réellement dupliquées qu’en cas de modification. L’argument historique selon lequel inplace=True économise de la mémoire est bien moins pertinent.

Le seul cas où inplace=True reste naturel est dans de courts scripts exploratoires où vous nettoyez un DataFrame pas à pas sans besoin de chaînage. Pour du code de production ou destiné à être relu, préférez le défaut.

Comment renommer toutes les colonnes d’un coup dans pandas ?

Parfois, vous ne voulez pas faire correspondre anciens et nouveaux noms. Vous souhaitez simplement remplacer tous les noms en une fois. C’est plus fréquent qu’on ne le pense : CSV sans en‑tête où pandas attribue 0, 1, 2 comme noms de colonnes, jeux de données dont l’en‑tête est dans une autre langue, exports générés par un système avec des noms comme Field1, Field2, Field3.

Deux approches courantes : affecter directement df.columns, ou utiliser .set_axis(). Le résultat est identique. Le compromis se fait entre concision et chaînabilité.

Affecter une liste à df.columns

L’approche la plus directe consiste à affecter une nouvelle liste à l’attribut columns. Prenez ce DataFrame, construit à partir d’une liste de listes sans en‑tête, typique d’un CSV sans header. Pandas retombe sur des noms de colonnes entiers :

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)

Les noms 0, 1 et 2 ne servent à rien pour l’analyse. Remplacez‑les en affectant une nouvelle liste de noms à l’attribut columns :

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

Deux points à connaître avec cette approche. 

1. La longueur de la liste doit correspondre exactement. Si vous passez trois noms pour un DataFrame à quatre colonnes, pandas lève ValueError: Length mismatch (nous détaillerons cette erreur plus loin). 

2. Cela modifie le DataFrame en place. Il n’y a pas de paramètre inplace ici car l’affectation est la modification. Si vous souhaitez une copie, utilisez d’abord .copy() ou préférez .set_axis() ci‑dessous.

Utiliser .set_axis() pour chaîner les méthodes

La méthode .set_axis() fait la même chose, mais renvoie un nouveau DataFrame afin que vous puissiez la chaîner avec d’autres opérations. Prenez un DataFrame similaire sans en‑tête, mais cette fois avec des données un peu plus brouillonnes (décimales superflues, valeur manquante) :

import pandas as pd

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)

L’argument axis=1 indique à pandas que vous définissez les libellés de colonnes (utilisez axis=0 pour l’index des lignes). Comme .set_axis() renvoie un nouveau DataFrame, elle s’intègre naturellement dans des pipelines de transformations chaînées, typiques de l’ETL ou de vos analyses. C’est la principale raison de la préférer à l’affectation directe en production.

Comment renommer des colonnes en utilisant des fonctions dans pandas ?

Au lieu d’associer chaque ancien nom à un nouveau, vous pouvez passer une fonction à .rename(), et pandas l’appliquera à chaque nom de colonne. C’est l’outil adapté quand vous avez une règle plutôt qu’une liste. Par exemple : « mettre tout en minuscules » ou « remplacer chaque espace par un underscore ».

Utiliser les fonctions de chaîne intégrées

Le cas le plus simple est une standardisation de la casse. Passez str.lower, str.upper ou str.title directement à l’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())

Notez que nous passons la fonction elle‑même (str.lower), sans l’appeler (str.lower()). Pandas l’applique à chaque nom de colonne. C’est un raccourci propre pour uniformiser la casse, mais cela ne gère ni les espaces ni les caractères spéciaux. Pour cela, préférez une lambda ou une fonction personnalisée.

Utiliser des lambdas et des fonctions personnalisées

Pour tout ce qui dépasse un simple changement de casse, une lambda permet d’exprimer rapidement la transformation en ligne. Si vous n’avez jamais utilisé de lambda, notre guide pour débuter avec les fonctions lambda est un bon point de départ.

Un motif courant est de passer en minuscules et de remplacer les espaces par des underscores en une étape. Reprenons l’exemple précédent :

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

Quand la logique devient plus complexe, sortez‑la dans une fonction nommée. Considérez cet utilitaire qui convertit des noms en camelCase ou PascalCase vers le 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())

Une fonction nommée est plus simple à tester, à réutiliser entre notebooks, et à documenter qu’une astuce en une ligne. Utilisez une lambda si la logique tient en une ligne, et une fonction dédiée sinon.

Comment nettoyer en masse des noms de colonnes brouillonnes dans pandas ?

Quand les données viennent de feuilles Excel, d’APIs tierces ou de CSV modifiés à la main, les noms de colonnes présentent souvent des problèmes que .rename() ne règle pas élégamment. Je parle de :

• Espaces en fin de chaîne
• Casse mélangée
• Parenthèses
• Traits d’union
• Caractères spéciaux
• Caractères Unicode invisibles

Dans ces situations, l’approche la plus propre est d’agir directement sur df.columns avec l’accesseur .str, qui expose des méthodes vectorisées sur chaînes (y compris regex) pour tous les noms à la fois. C’est aussi la base d’un bon nettoyage de données en Python. Des noms propres rendent toutes les étapes suivantes (filtrage, jointure, visualisation) moins sujettes aux erreurs.

Supprimer espaces et caractères spéciaux

Considérez ce DataFrame, avec des noms typiques d’un export Excel manipulé par trop de personnes :

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

Les espaces en début et fin sont les plus fréquents et frustrants, car invisibles. Supprimez‑les en une ligne :

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

Pour les caractères spéciaux, .str.replace() accepte un motif regex. Le motif ci‑dessous conserve lettres, chiffres, underscores et espaces, et supprime le reste :

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

Le tiret, les parenthèses et le signe dollar ont disparu. Notez que Total Amount a désormais un espace final (là où se trouvait ($)), et OrderDate a perdu son tiret. Voilà pourquoi on termine par un strip dans un pipeline de nettoyage.

Standardiser en snake_case

Une bonne pratique courante est de convertir tous les noms de colonnes en snake_case avant toute analyse : minuscules, mots séparés par des underscores, pas de caractères spéciaux. Chaînez les méthodes .str pour y parvenir en une seule expression :

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()                                  # supprimer les espaces en début/fin
    .str.lower()                                  # tout passer en minuscules
    .str.replace(r"[^a-z0-9]+", "_", regex=True)  # remplacer blocs non alphanum. par des underscores
    .str.strip("_")                               # retirer les underscores de début/fin
)

print(raw_export.columns.tolist())

Quatre lignes, et vos noms de colonnes sont prévisibles, en minuscules, séparés par des underscores. Ce motif mérite d’être enregistré comme fonction utilitaire. Une fois disponible, appliquez‑le à chaque DataFrame brouillon qui passe.

Vous voudrez souvent combiner renommage et suppression de colonnes. Pour cela, le tutoriel sur la suppression de colonnes avec pandas couvre l’étape suivante.

Comment renommer des colonnes lors du chargement des données dans pandas ?

Si vous savez déjà que vous voulez d’autres noms avant même de charger le fichier, vous pouvez renommer directement dans pd.read_csv(). Passez une liste de noms au paramètre names et définissez header=0 pour indiquer à pandas d’ignorer l’en‑tête existant et d’utiliser vos noms à la place :

import pandas as pd
from io import StringIO

# Simulation d'un fichier CSV pour la démonstration
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"""

# Renomme les colonnes au chargement, en ignorant l'en-tête d'origine
transactions = pd.read_csv(
    StringIO(csv_data),
    header=0,
    names=["transaction_id", "customer_id", "amount_usd", "transaction_date"]
)
print(transactions)

C’est un raccourci utile quand vous contrôlez le schéma et ne voulez pas d’un .rename() séparé qui encombre le code de chargement. Si le fichier n’a aucun en‑tête, omettez header=0 et utilisez simplement names=[...] pour définir les noms de colonnes depuis zéro. Pour aller plus loin sur les options de chargement, nous vous recommandons le tutoriel pandas read_csv().

Une mise en garde : c’est tout ou rien. Le paramètre names remplace chaque nom de colonne, donc la longueur de la liste doit correspondre exactement au nombre de colonnes du fichier. Si vous ne voulez renommer que quelques colonnes, chargez d’abord le fichier puis utilisez .rename().

Pour un accompagnement pas à pas de ces schémas, avec d’autres tâches courantes de nettoyage, suivez notre cours Cleaning Data in Python.

Renommer des colonnes dans Polars vs. pandas

Si vous travaillez à la fois avec pandas et Polars, ou que vous vous y attendez, il vaut la peine de connaître la gestion du renommage dans chacun. L’API de haut niveau est similaire, mais des détails diffèrent et peuvent surprendre au début. Polars est une bibliothèque DataFrame rapide, adossée à Rust, de plus en plus utilisée dans les stacks modernes, et les automatismes acquis avec pandas ne se transfèrent pas toujours parfaitement.

L’idée principale est identique : vous mappez anciens et nouveaux noms avec un dictionnaire. Les différences sont dans les détails. Polars est immuable par conception (pas d’inplace), le chaînage de méthodes est idiomatique, et le renommage au niveau colonne lors d’un select utilise .alias() plutôt qu’une étape de renommage séparée.

Comparaison côte à côte

Le même renommage dans les deux bibliothèques

Pour comparer, voici un renommage simple dans chacune.

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)

Deux petites différences à noter. Le .rename() de Polars prend le dictionnaire directement. Pas de mot‑clé columns= car Polars ne gère que le renommage de colonnes (pas d’index de lignes). Et vous devez réaffecter le résultat. Il n’y a pas de inplace=True dans Polars. Chaque opération renvoie un nouveau DataFrame.

La sortie Polars affiche aussi les dtypes en ligne (i64, str) et la forme en en‑tête, un petit confort apprécié après bascule.

Renommer des colonnes pendant un select

Pour renommer lors d’une transformation, Polars utilise .alias() dans .select() ou .with_columns() :

# Polars
import polars as pl

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

# Sélection et renommage en une expression
renamed = orders_pl.select(
    pl.col("ord_id").alias("order_id"),
    pl.col("cust_nm").alias("customer_name")
)

print(renamed)

Dans pandas, l’équivalent serait un .rename() après une sélection de colonnes. Aucune approche n’est « meilleure ». Elles reflètent la philosophie de chaque bibliothèque. 

Pour une comparaison plus poussée des deux, je vous recommande le tutoriel pandas versus polars : performance. Et si vous souhaitez ajouter polars à votre boîte à outils, suivez notre cours Introduction to Polars.

Erreurs fréquentes et comment les corriger

Deux erreurs reviennent souvent lors du renommage de colonnes dans pandas. Voici à quoi elles ressemblent, pourquoi elles surviennent et comment les corriger.

KeyError : nom de colonne introuvable

Par défaut, .rename() ignore silencieusement les clés ne correspondant à aucune colonne. Mais si vous passez errors='raise' pour détecter les fautes de frappe, vous obtiendrez un KeyError quand une clé n’existe pas :

import pandas as pd

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

# Provoque une erreur
orders.rename(columns={"Order_ID": "order_id"}, errors="raise")

La cause la plus fréquente est la casse (Order_ID versus order_id) ou un espace invisible en fin ("order_id " versus "order_id"). Face à un KeyError, vérifiez dans l’ordre :

1. Orthographe exacte et casse
2. Espaces cachés
3. Si la colonne n’a pas déjà été renommée plus tôt

Pour vérifier les noms réels des colonnes :

print(orders.columns.tolist())

# Utiliser repr() comme alternative
print([repr(c) for c in orders.columns])

Une fois les chaînes exactes connues, la faute saute aux yeux. Corrigez l’orthographe et relancez :

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

Reste à savoir quand utiliser errors='raise' plutôt que le défaut errors='ignore'. 

• Le défaut est indulgent. Utile dans des scripts traitant des schémas variables où l’absence d’une colonne ne doit pas faire tout échouer. 

• Passez à errors='raise' quand vous voulez faire remonter bruyamment les fautes pendant le développement, surtout en notebook où les échecs silencieux coûtent des heures de débogage.

ValueError : length mismatch avec df.columns

Quand vous affectez une liste à df.columns ou utilisez .set_axis(), la longueur doit correspondre exactement au nombre de colonnes. Sinon, pandas lève un ValueError :

import pandas as pd

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

# Provoque une erreur
products.columns = ["product_sku", "product_name"]

Le DataFrame a trois colonnes, mais seulement deux nouveaux noms ont été fournis. La solution consiste à vérifier le nombre de colonnes avant l’affectation :

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

Si vous travaillez avec des DataFrames dont le nombre de colonnes peut varier, il est plus sûr d’utiliser .rename() avec un dictionnaire. Il ne touche qu’aux colonnes nommées, si bien qu’une colonne manquante ou en plus ne fera pas planter votre code.

Derniers conseils

Renommer des colonnes dans pandas consiste à choisir la méthode adaptée à votre besoin. Quel que soit l’outil, le plus grand gain pratique est de vous fixer une convention de nommage unique et de l’appliquer dès le départ. snake_case est le plus courant en Python. Des noms propres coûtent quelques secondes au début et vous évitent des KeyError tout le reste du projet.

Utilisez .rename() avec un dictionnaire pour des renommages ciblés. Quand chaque colonne a besoin d’un nouveau nom, affecter df.columns ou utiliser .set_axis() est plus rapide que construire un dictionnaire complet. Et si le renommage suit une règle (suppression d’espaces, tout en minuscules, conversion camelCase), passer une fonction ou utiliser l’accesseur .str vous permet d’exprimer la règle une seule fois. Polars gère la même chose avec une API proche, mais son style immuable et orienté chaînage vous amènera à d’autres habitudes. 

Pour continuer à développer vos compétences sur les DataFrames, je vous recommande le cours Data Manipulation with pandas comme prochaine étape. Si vous voulez une feuille de route structurée, le parcours Data Analyst in Python couvre la manipulation de DataFrame et le reste de la boîte à outils de l’analyste.