Parcourir les aide-mémoire · Python

Technologie: PythonCatégorie: Nettoyage des donnéesNiveau: IntermédiaireMis à jour

Types de données et conversions pandas

Inspectez et convertissez les types de données pandas en toute sécurité, préservez la nullabilité, détectez les conversions en échec et évitez les changements de schéma silencieux dans les pipelines de données de production.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Inspecter les types de données d’un DataFrame
  5. 2. Convertir vers les dtypes nullables de pandas
  6. 3. Convertir explicitement une colonne avec astype()
  7. 4. Conserver les identifiants sous forme de chaînes
  8. 5. Convertir du texte numérique en toute sécurité
  9. 6. Convertir en entiers nullables
  10. 7. Convertir en flottants nullables
  11. 8. Convertir en booléens nullables
  12. 9. Convertir des dates et des horodatages
  13. 10. Analyser explicitement un format de date et heure connu
  14. 11. Convertir du texte vers le dtype string de pandas
  15. 12. Convertir du texte à faible cardinalité en catégoriel
  16. 13. Définir un type catégoriel ordonné
  17. 14. Vérifier quelles colonnes ont le dtype générique object
  18. 15. Détecter des types de valeurs Python mélangés dans une colonne
  19. 16. Trouver les valeurs dont la conversion numérique échoue
  20. 17. Retirer une mise en forme connue avant la conversion numérique
  21. 18. Convertir des chaînes de pourcentage
  22. 19. Convertir avec prudence des flottants à valeur entière
  23. 20. Convertir les clés des deux côtés avant un merge
  24. 21. Convertir avec un dictionnaire de schéma
  25. 22. Valider les dtypes obtenus
  26. 23. Comparer la mémoire avant et après la conversion
  27. 24. Éviter la coercition générique risquée
  28. 25. Convertir plusieurs colonnes de manière cohérente
  29. 26. Préserver la précision décimale lorsque l’arithmétique exacte compte
  30. Interpréter le résultat
  31. Points à vérifier
  32. Un identifiant est devenu numérique
  33. La conversion numérique crée de nouvelles valeurs nulles
  34. Une colonne d’entiers devient flottante
  35. La conversion booléenne se comporte de façon étrange
  36. Les clés de merge ont des dtypes différents
  37. La mémoire est anormalement élevée
  38. convert_dtypes() produit un résultat inattendu
  39. Notes de production
  40. Le schéma doit être explicite aux frontières du système
  41. Les échecs de conversion sont des métriques de qualité des données
  42. Les dtypes nullables sont utiles mais ne sont pas identiques aux dtypes NumPy
  43. astype() peut lever une erreur sur des valeurs invalides
  44. Les catégories exigent une sémantique stable
  45. La conversion de type peut modifier les valeurs
  46. Les conversions volumineuses allouent de la mémoire
  47. Erreurs fréquentes
  48. 1. Traiter les identifiants comme des nombres
  49. 2. Utiliser astype(int) sur des données nullables
  50. 3. Utiliser errors="coerce" sans vérifier les échecs
  51. 4. Supposer que object signifie chaîne
  52. 5. Utiliser bool() sur du texte
  53. 6. Convertir des montants en float sans tenir compte de la précision
  54. 7. Utiliser convert_dtypes() comme contrat de schéma complet
  55. 8. Convertir les clés de merge séparément sans vérifier leur sémantique
  56. Étape suivante
  57. Pour aller plus loin

Problème

Un DataFrame pandas peut se charger sans erreur et pourtant avoir un schéma incorrect.

Problèmes de production fréquents :

  • identifiants inférés comme des entiers
  • colonnes numériques chargées comme des chaînes
  • dates laissées sous forme de texte
  • booléens encodés en "Y", "N", 0 ou 1
  • colonnes d’entiers converties en virgule flottante parce qu’elles contiennent des valeurs manquantes
  • colonnes object mixtes qui masquent des données sources incohérentes
  • conversions en échec qui deviennent silencieusement des valeurs manquantes
  • jointures en échec parce que les colonnes clés utilisent des dtypes incompatibles

L’objectif est de rendre la conversion de type explicite, d’inspecter les échecs et de préserver le sens métier.

Réponse rapide

Commencez par inspecter le schéma actuel :

print(df.dtypes)
df.info()

Utilisez convert_dtypes() lorsque vous voulez les dtypes nullables de pandas :

df = df.convert_dtypes()

Pour les conversions délibérées, privilégiez les fonctions propres à chaque type :

df["customer_id"] = df["customer_id"].astype("string")

df["amount"] = pd.to_numeric(
    df["amount"],
    errors="coerce",
)

df["event_time"] = pd.to_datetime(
    df["event_time"],
    errors="coerce",
    utc=True,
)

Inspectez toujours les valeurs dont la conversion échoue avant d’écraser des colonnes sources importantes.

Code / commandes

1. Inspecter les types de données d’un DataFrame

print(df.dtypes)

Pour plus de contexte :

df.info()

Faites-le immédiatement après avoir lu un CSV, du JSON, des résultats SQL ou d’autres entrées faiblement typées.


2. Convertir vers les dtypes nullables de pandas

df = df.convert_dtypes()

Cela peut convertir les colonnes compatibles vers des types nullables de pandas tels que :

Int64
Float64
boolean
string

Utilisez-le comme étape de nettoyage lorsque la sémantique nullable est souhaitable.

Ne supposez pas qu’il comprend parfaitement votre schéma métier.

Un identifiant composé uniquement de chiffres peut tout de même nécessiter une conversion explicite en chaîne.


3. Convertir explicitement une colonne avec astype()

df["customer_id"] = (
    df["customer_id"]
    .astype("string")
)

Utilisez astype() lorsque les valeurs sources sont déjà valides pour le type cible.

Exemple :

df["quantity"] = (
    df["quantity"]
    .astype("Int64")
)

Si des valeurs invalides peuvent exister, inspectez-les d’abord ou utilisez une fonction d’analyse telle que pd.to_numeric().


4. Conserver les identifiants sous forme de chaînes

Les identifiants doivent généralement rester des chaînes, même lorsqu’ils ne contiennent que des chiffres.

df["account_id"] = (
    df["account_id"]
    .astype("string")
)

Exemples d’identifiants qui doivent généralement rester textuels :

  • identifiants client
  • numéros de compte
  • codes postaux (ZIP)
  • numéros de téléphone
  • SKU
  • identifiants de référence externes

Les convertir en nombres peut supprimer les zéros initiaux ou suggérer une signification arithmétique qui n’existe pas.


5. Convertir du texte numérique en toute sécurité

parsed_amount = pd.to_numeric(
    df["amount"],
    errors="coerce",
)

Inspectez les conversions en échec :

failed = df.loc[
    df["amount"].notna()
    & parsed_amount.isna()
]

print(failed)

N’affectez ensuite qu’après validation :

df["amount"] = parsed_amount

Cela évite de masquer des valeurs sources invalides.


6. Convertir en entiers nullables

Si des valeurs entières manquantes sont valides :

df["quantity"] = (
    pd.to_numeric(
        df["quantity"],
        errors="coerce",
    )
    .astype("Int64")
)

Utilisez Int64 de pandas, et non int64 de NumPy, lorsque la colonne doit représenter à la fois des entiers et des valeurs manquantes.


7. Convertir en flottants nullables

df["amount"] = (
    pd.to_numeric(
        df["amount"],
        errors="coerce",
    )
    .astype("Float64")
)

Vous obtenez ainsi la sémantique des flottants nullables de pandas.

Utilisez le float64 standard lorsque le comportement des types d’extension nullables n’est pas nécessaire.


8. Convertir en booléens nullables

Si la source contient déjà des valeurs de type booléen :

df["is_active"] = (
    df["is_active"]
    .astype("boolean")
)

Si la source utilise des valeurs textuelles, mappez-les explicitement.

boolean_map = {
    "Y": True,
    "N": False,
}

mapped = df["is_active"].map(boolean_map)

invalid = df.loc[
    df["is_active"].notna()
    & mapped.isna()
]

print(invalid)

Puis :

df["is_active"] = (
    mapped.astype("boolean")
)

N’utilisez pas la valeur de vérité Python (truthiness) pour convertir des chaînes arbitraires.

Par exemple :

bool("False")

vaut True, car la chaîne n’est pas vide.


9. Convertir des dates et des horodatages

parsed_time = pd.to_datetime(
    df["event_time"],
    errors="coerce",
    utc=True,
)

Inspectez les échecs :

failed = df.loc[
    df["event_time"].notna()
    & parsed_time.isna()
]

print(failed)

Puis affectez :

df["event_time"] = parsed_time

N’utilisez utc=True que lorsque la normalisation en UTC correspond à la sémantique de la source.


10. Analyser explicitement un format de date et heure connu

df["event_date"] = pd.to_datetime(
    df["event_date"],
    format="%Y-%m-%d",
    errors="coerce",
)

Les formats explicites améliorent la clarté et facilitent la détection des changements inattendus dans la source.


11. Convertir du texte vers le dtype string de pandas

df["customer_name"] = (
    df["customer_name"]
    .astype("string")
)

Pour les colonnes de texte, privilégiez si possible le dtype string de pandas plutôt que le dtype générique object.

Il offre un comportement plus cohérent vis-à-vis des valeurs manquantes.


12. Convertir du texte à faible cardinalité en catégoriel

df["status"] = (
    df["status"]
    .astype("category")
)

Cela peut réduire la mémoire utilisée par des valeurs catégorielles répétées.

Bons candidats :

  • statut
  • code pays
  • canal
  • type de produit

Mauvais candidats :

  • identifiants uniques
  • texte libre
  • références de transaction à forte cardinalité

Mesurez plutôt que de supposer un gain de mémoire.


13. Définir un type catégoriel ordonné

from pandas.api.types import CategoricalDtype

priority_type = CategoricalDtype(
    categories=[
        "low",
        "medium",
        "high",
        "critical",
    ],
    ordered=True,
)

df["priority"] = (
    df["priority"]
    .astype(priority_type)
)

Le tri respecte désormais l’ordre métier plutôt que l’ordre alphabétique.


14. Vérifier quelles colonnes ont le dtype générique object

object_cols = (
    df.select_dtypes(include="object")
    .columns
)

print(object_cols.tolist())

object peut masquer :

  • des chaînes
  • des objets Python
  • des valeurs mixtes
  • des types sources incohérents

Inspectez ces colonnes délibérément.


15. Détecter des types de valeurs Python mélangés dans une colonne

type_counts = (
    df["value"]
    .dropna()
    .map(type)
    .value_counts()
)

print(type_counts)

C’est utile lorsqu’une colonne object se comporte de manière incohérente.

Le résultat peut par exemple révéler un mélange de :

str
int
float

C’est généralement le signe qu’il faut normaliser les données sources.


16. Trouver les valeurs dont la conversion numérique échoue

parsed = pd.to_numeric(
    df["amount"],
    errors="coerce",
)

bad_values = df.loc[
    df["amount"].notna()
    & parsed.isna(),
    "amount",
]

print(
    bad_values
    .value_counts()
    .head(20)
)

Utilisez-le pour repérer des motifs tels que :

  • symboles monétaires
  • virgules
  • libellés textuels
  • valeurs sentinelles
  • saisies mal formées

17. Retirer une mise en forme connue avant la conversion numérique

Exemples de valeurs sources :

"$1,250.50"
"$99.00"

Normalisez explicitement :

clean_amount = (
    df["amount"]
    .astype("string")
    .str.replace("$", "", regex=False)
    .str.replace(",", "", regex=False)
)

parsed_amount = pd.to_numeric(
    clean_amount,
    errors="coerce",
)

Ne supprimez pas des caractères à l’aveugle, sauf s’il s’agit d’une mise en forme documentée.


18. Convertir des chaînes de pourcentage

Exemple :

"15.5%"
"8%"

Analysez :

pct = (
    df["discount_pct"]
    .astype("string")
    .str.rstrip("%")
)

df["discount_rate"] = (
    pd.to_numeric(
        pct,
        errors="coerce",
    )
    / 100
)

Résultat :

15.5% -> 0.155

Rendez l’unité explicite dans le nom de la colonne de sortie.


19. Convertir avec prudence des flottants à valeur entière

Supposons que :

1.0
2.0
NaN

doivent représenter des comptages entiers.

Validez d’abord :

values = pd.to_numeric(
    df["quantity"],
    errors="coerce",
)

non_integer = values.loc[
    values.notna()
    & (values % 1 != 0)
]

print(non_integer)

S’il n’y en a aucun :

df["quantity"] = (
    values.astype("Int64")
)

Ne tronquez pas silencieusement les décimales.


20. Convertir les clés des deux côtés avant un merge

Inspectez d’abord :

print(left["customer_id"].dtype)
print(right["customer_id"].dtype)

Normalisez de manière cohérente :

left["customer_id"] = (
    left["customer_id"]
    .astype("string")
)

right["customer_id"] = (
    right["customer_id"]
    .astype("string")
)

Si la mise en forme peut différer :

left["customer_id"] = (
    left["customer_id"]
    .str.strip()
)

right["customer_id"] = (
    right["customer_id"]
    .str.strip()
)

Ne normalisez la casse ou la mise en forme que lorsque la sémantique de l’identifiant le permet.


21. Convertir avec un dictionnaire de schéma

Pour les schémas connus :

schema = {
    "order_id": "string",
    "customer_id": "string",
    "quantity": "Int64",
    "amount": "Float64",
    "is_active": "boolean",
}

df = df.astype(schema)

N’utilisez cette approche que lorsque les valeurs sont déjà compatibles.

Si les données brutes peuvent contenir du texte invalide, analysez d’abord ces colonnes.


22. Valider les dtypes obtenus

expected = {
    "order_id": "string",
    "customer_id": "string",
    "quantity": "Int64",
    "amount": "Float64",
}

for column, dtype in expected.items():
    actual = str(df[column].dtype)

    if actual != dtype:
        raise TypeError(
            f"{column}: expected {dtype}, got {actual}"
        )

La validation de schéma est utile dans les pipelines d’ingestion de production.

Pour des systèmes plus importants, utilisez un framework dédié à la validation de schéma ou de données.


23. Comparer la mémoire avant et après la conversion

before = df.memory_usage(
    deep=True
).sum()

Convertissez :

df["status"] = (
    df["status"]
    .astype("category")
)

Mesurez à nouveau :

after = df.memory_usage(
    deep=True
).sum()

print("Before:", before)
print("After:", after)

Appuyez-vous sur des mesures réelles avant d’adopter des changements de dtype uniquement pour des raisons de mémoire.


24. Éviter la coercition générique risquée

Cette écriture est concise :

df["value"] = pd.to_numeric(
    df["value"],
    errors="coerce",
)

Mais chaque valeur invalide devient manquante.

Mesurez toujours l’impact :

before_nulls = df["value"].isna().sum()

parsed = pd.to_numeric(
    df["value"],
    errors="coerce",
)

after_nulls = parsed.isna().sum()

print(
    "New nulls:",
    after_nulls - before_nulls,
)

Des valeurs nulles nouvelles et inattendues sont un signal de qualité des données.


25. Convertir plusieurs colonnes de manière cohérente

numeric_cols = [
    "amount",
    "tax",
    "discount",
]

for col in numeric_cols:
    df[col] = pd.to_numeric(
        df[col],
        errors="coerce",
    )

Dans les pipelines de production, enregistrez le nombre d’échecs de conversion par colonne avant l’affectation.


26. Préserver la précision décimale lorsque l’arithmétique exacte compte

La virgule flottante binaire ne convient pas à tous les calculs financiers.

Pour une sémantique décimale exacte :

from decimal import Decimal

df["amount_decimal"] = (
    df["amount_text"]
    .map(
        lambda x: (
            Decimal(x)
            if pd.notna(x)
            else None
        )
    )
)

Cela produit des objets Python et s’avère plus lent que les dtypes numériques natifs.

Pour les charges analytiques volumineuses, envisagez un moteur de stockage ou d’exécution doté de types décimaux natifs plutôt que de vous appuyer sur des colonnes pandas de Decimal Python stockées comme objets.

Interpréter le résultat

dtype / fonction Signification
object Stockage générique d’objets Python ; souvent des chaînes ou des valeurs mixtes.
string Dtype de chaîne nullable de pandas.
Int64 Dtype d’entier 64 bits nullable de pandas.
Float64 Dtype à virgule flottante nullable de pandas.
boolean Dtype booléen nullable de pandas.
category Valeurs catégorielles encodées, utiles pour des données répétées à faible cardinalité.
datetime64[ns] Date et heure pandas/NumPy sans fuseau horaire.
datetime64[ns, UTC] Date et heure avec fuseau horaire, en UTC.
astype() Conversion explicite ; attend généralement des valeurs compatibles.
convert_dtypes() Infère les dtypes nullables de pandas adaptés.
pd.to_numeric() Analyse des valeurs numériques avec une gestion des erreurs configurable.
pd.to_datetime() Analyse des dates et des horodatages.

La distinction la plus importante est la suivante :

type de stockage != sens métier

Une valeur qui ressemble à un entier peut tout de même être un identifiant.

Une chaîne peut en réalité représenter un horodatage.

Les choix de type doivent suivre le contrat de données.

Points à vérifier

Un identifiant est devenu numérique

Vérifiez si des zéros initiaux ont été perdus.

Si c’est le cas, récupérez si possible les données depuis la source d’origine et lisez-les comme du texte la prochaine fois.

La conversion numérique crée de nouvelles valeurs nulles

L’analyse de ces valeurs a échoué.

Inspectez-les avant de continuer.

Une colonne d’entiers devient flottante

Cela se produit couramment lorsque des données entières NumPy doivent représenter des valeurs manquantes.

Utilisez le dtype nullable Int64 de pandas lorsque la sémantique entière doit être préservée.

La conversion booléenne se comporte de façon étrange

Les valeurs textuelles telles que :

"False"
"0"
"N"

doivent être mappées explicitement.

Ne vous fiez pas à la valeur de vérité Python.

Les clés de merge ont des dtypes différents

Normalisez les deux côtés avant le merge.

Inspectez aussi les différences de mise en forme.

La mémoire est anormalement élevée

Vérifiez :

  • les colonnes object
  • les chaînes répétées
  • les types numériques de précision inutilement élevée
  • les colonnes qui pourraient sans risque être catégorielles

Mesurez avant et après les changements.

convert_dtypes() produit un résultat inattendu

Il infère à partir des valeurs observées, et non de votre contrat métier.

Forcez explicitement le type des colonnes importantes.

Notes de production

Le schéma doit être explicite aux frontières du système

Définissez les types attendus lors de la lecture :

  • de CSV
  • d’API
  • d’extractions SQL
  • de charges utiles de messages
  • de fichiers externes

Ne vous fiez pas uniquement à l’inférence.

Les échecs de conversion sont des métriques de qualité des données

Suivez :

  • le nombre d’échecs d’analyse numérique
  • le nombre de dates en échec
  • les codes booléens invalides
  • les valeurs de catégorie inattendues

Ils ne doivent pas disparaître silencieusement.

Les dtypes nullables sont utiles mais ne sont pas identiques aux dtypes NumPy

Exemples :

Int64 != int64
Float64 != float64
boolean != bool

Les dtypes d’extension nullables de pandas gèrent les valeurs manquantes différemment.

Testez la compatibilité en aval lors de l’export ou de l’intégration avec d’autres bibliothèques.

astype() peut lever une erreur sur des valeurs invalides

C’est souvent souhaitable dans des pipelines maîtrisés.

Si des données brutes mal formées sont attendues, analysez d’abord, inspectez les échecs, puis convertissez.

Les catégories exigent une sémantique stable

Un dtype catégoriel est utile pour les données à faible cardinalité, mais les catégories peuvent différer d’un DataFrame à l’autre.

Soyez prudent lorsque vous :

  • concaténez des catégoriels
  • comparez des catégories ordonnées
  • écrivez vers des systèmes externes

La conversion de type peut modifier les valeurs

Exemples :

  • la conversion de flottants en entiers peut tronquer ou échouer
  • les horodatages peuvent se décaler lors d’une conversion de fuseau horaire
  • la conversion de chaînes en nombres peut perdre la mise en forme
  • les flottants binaires peuvent introduire des effets de précision

Validez avant et après.

Les conversions volumineuses allouent de la mémoire

Convertir une grande colonne peut créer un nouveau tableau.

Sur les charges de travail limitées en mémoire :

  • ne convertissez que les colonnes nécessaires
  • évitez les conversions répétées
  • libérez les objets intermédiaires inutilisés
  • envisagez de traiter en amont, en SQL ou avec Spark, lorsque c’est pertinent

Erreurs fréquentes

1. Traiter les identifiants comme des nombres

Les identifiants sont des libellés, pas des quantités.

Conservez-les sous forme de chaînes, sauf si l’arithmétique a un sens.

2. Utiliser astype(int) sur des données nullables

Cela peut échouer en présence de valeurs manquantes.

Utilisez le dtype nullable Int64 lorsque c’est approprié.

3. Utiliser errors="coerce" sans vérifier les échecs

Cela peut transformer des valeurs sources incorrectes en valeurs manquantes silencieuses.

Suivez les valeurs nulles nouvellement créées.

4. Supposer que object signifie chaîne

Une colonne object peut contenir des types Python mélangés.

Inspectez les valeurs réelles.

5. Utiliser bool() sur du texte

C’est incorrect pour des valeurs telles que :

bool("False")  # True

Mappez explicitement les valeurs sources.

6. Convertir des montants en float sans tenir compte de la précision

La virgule flottante binaire peut être inadaptée aux calculs financiers exacts.

Choisissez le modèle numérique en fonction des exigences.

7. Utiliser convert_dtypes() comme contrat de schéma complet

C’est une aide à l’inférence, pas un substitut à un schéma métier explicite.

8. Convertir les clés de merge séparément sans vérifier leur sémantique

Deux colonnes peuvent toutes deux devenir des chaînes et pourtant ne pas correspondre à cause :

  • des espaces
  • des zéros initiaux
  • de la casse
  • des règles de mise en forme

Étape suivante

Laissez le problème de type observé déterminer la suite.

  • Échecs d’analyse numérique → inspectez les valeurs brutes et définissez des règles de nettoyage.
  • Les dates restent des chaînes → analysez-les avec des règles de date et heure explicites.
  • Les identifiants ont perdu leur mise en forme → rechargez-les depuis la source avec le dtype string si possible.
  • Des entiers nullables sont devenus des flottants → passez au dtype Int64 de pandas.
  • Les booléens proviennent de codes ou de texte → mappez explicitement les valeurs sources autorisées.
  • Les clés de merge ne correspondent pas → normalisez le dtype et la mise en forme des deux côtés.
  • Les colonnes object dominent la mémoire → vérifiez si string ou category est approprié.
  • Le schéma est critique pour le métier → ajoutez une validation de schéma explicite à l’ingestion.
  • Les conversions sont coûteuses sur de très grands volumes → rapprochez le typage de la source de données ou d’un moteur d’exécution distribué.

← Tous les aide-mémoire