Convertir les types de données Pandas

Pourquoi convertir les types de colonnes

Quand Pandas charge un fichier, il inspecte chaque colonne et lui attribue un type automatiquement. Ce mécanisme fonctionne bien dans les cas simples, mais il a des limites : une colonne de nombres qui contient une seule cellule vide devient float64 au lieu d'int64. Une colonne de dates reste en object si le format n'est pas reconnu. Une colonne avec peu de valeurs uniques est traitée comme texte au lieu d'une catégorie optimisée.

Corriger les types dès le début du traitement évite des erreurs silencieuses dans les calculs et réduit souvent la mémoire utilisée.

Conversion générique avec astype()

astype() est la méthode universelle pour changer le type d'une colonne. Elle fonctionne sur une Series ou sur un DataFrame entier via un dictionnaire.

import pandas as pd

data = {
    "id":       ["1", "2", "3", "4"],   # nombres lus comme texte
    "prix":     ["45.9", "22.5", "189", "79.99"],
    "actif":    [1, 0, 1, 1],           # entiers à convertir en bool
}
df = pd.DataFrame(data)

# Convertir une colonne spécifique
df["id"]    = df["id"].astype(int)
df["prix"]  = df["prix"].astype(float)
df["actif"] = df["actif"].astype(bool)

# Convertir plusieurs colonnes en une passe
df = df.astype({"id": int, "prix": float})

print(df.dtypes)

astype() lève une erreur si la conversion est impossible — par exemple tenter de convertir la chaîne "abc" en entier. Si votre colonne contient des valeurs non convertibles mêlées à des valeurs valides, utilisez plutôt pd.to_numeric() avec le paramètre errors="coerce".

Convertir en numérique avec to_numeric()

pd.to_numeric() est plus robuste qu'astype() pour les colonnes qui contiennent des valeurs mixtes ou des chaînes non numériques. Le paramètre errors="coerce" remplace les valeurs non convertibles par NaN au lieu de lever une erreur.

import pandas as pd

data = {
    "montant": ["1500", "2300", "N/A", "890", "erreur", "4200"]
}
df = pd.DataFrame(data)

# errors="coerce" : les valeurs non convertibles deviennent NaN
df["montant"] = pd.to_numeric(df["montant"], errors="coerce")

print(df)
print(df["montant"].dtype)          # float64
print(df["montant"].isnull().sum()) # 2 (N/A et erreur)

C'est le comportement attendu sur des données réelles : les valeurs inexploitables sont transformées en NaN, que vous pourrez ensuite remplir ou supprimer avec les méthodes vues dans la page sur les valeurs manquantes. errors="ignore" laisse les valeurs problématiques telles quelles, et errors="raise" (défaut) lève une erreur dès la première valeur invalide.

Convertir en datetime avec to_datetime()

Les dates lues comme texte doivent être converties explicitement pour débloquer les calculs temporels. pd.to_datetime() reconnaît la plupart des formats courants automatiquement.

import pandas as pd

data = {
    "date_iso": ["2026-01-15", "2026-02-03", "2026-03-27"],
    "date_fr":  ["15/01/2026", "03/02/2026", "27/03/2026"]
}
df = pd.DataFrame(data)

# Format ISO reconnu automatiquement
df["date_iso"] = pd.to_datetime(df["date_iso"])

# Format français : préciser le format explicitement
df["date_fr"] = pd.to_datetime(df["date_fr"], format="%d/%m/%Y")

# Extraire des composantes une fois converti
df["année"] = df["date_iso"].dt.year
df["mois"]  = df["date_iso"].dt.month

print(df.dtypes)
print(df[["date_iso", "année", "mois"]])

Quand le format n'est pas reconnu automatiquement, précisez-le avec format="%d/%m/%Y". Les codes suivent la convention Python strftime : %d pour le jour, %m pour le mois, %Y pour l'année à 4 chiffres. Un format explicite est aussi plus rapide qu'une détection automatique sur de grands fichiers.

Convertir en type catégoriel

Une colonne avec peu de valeurs répétées — département, statut, catégorie produit — consomme beaucoup de mémoire en object car Pandas stocke chaque chaîne individuellement. Le type category stocke chaque valeur unique une seule fois et utilise des entiers en interne.

import pandas as pd

data = {
    "nom":    ["Alice", "Bob", "Clara", "David", "Eva", "Frank"],
    "dept":   ["RH", "Tech", "Tech", "Finance", "RH", "Tech"],
    "statut": ["actif", "inactif", "actif", "actif", "inactif", "actif"]
}
df = pd.DataFrame(data)

# Occupation mémoire avant conversion
print(df.memory_usage(deep=True).sum(), "octets")

# Convertir en catégoriel
df["dept"]   = df["dept"].astype("category")
df["statut"] = df["statut"].astype("category")

# Occupation mémoire après conversion
print(df.memory_usage(deep=True).sum(), "octets")

# Lister les catégories disponibles
print(df["dept"].cat.categories)   # ['Finance', 'RH', 'Tech']

Sur un DataFrame de millions de lignes avec quelques dizaines de valeurs uniques, le gain mémoire peut atteindre 50 à 90 %. Le type catégoriel accélère aussi certaines opérations comme groupby(). L'accesseur .cat permet de lister les catégories, de les réordonner ou de tester si un ordre a été défini.

Par carabde | Mis à jour le 26 avril 2026