Parcourir les aide-mémoire · Python

Technologie: PythonCatégorie: Analyse de donnéesNiveau: DébutantMis à jour

Inspecter un DataFrame pandas

Inspectez un DataFrame pandas rapidement et en toute sécurité pour comprendre sa forme, ses colonnes, ses types de données, ses valeurs nulles, ses doublons, ses distributions et ses valeurs suspectes avant de transformer les données.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Vérifier la forme et les noms de colonnes
  5. 2. Inspecter le schéma et l’utilisation mémoire
  6. 3. Afficher les premières et les dernières lignes
  7. 4. Échantillonner des lignes au hasard
  8. 5. Inspecter les types de données
  9. 6. Compter les valeurs nulles par colonne
  10. 7. Vérifier les lignes en double
  11. 8. Vérifier les doublons par clé métier
  12. 9. Résumer les colonnes numériques
  13. 10. Résumer tous les types de colonnes
  14. 11. Compter les valeurs uniques
  15. 12. Inspecter les valeurs catégorielles
  16. 13. Inspecter plusieurs colonnes catégorielles en toute sécurité
  17. 14. Inspecter les plages numériques
  18. 15. Vérifier les plages de dates
  19. 16. Repérer les espaces suspects dans les colonnes de texte
  20. 17. Distinguer les chaînes vides des valeurs nulles
  21. 18. Repérer les chaînes courantes assimilables à des nulls
  22. 19. Inspecter un enregistrement par clé métier
  23. 20. Créer une fonction d’inspection compacte et réutilisable
  24. Interpréter le résultat
  25. Points à vérifier
  26. Colonne numérique chargée comme object ou string
  27. Colonne de dates chargée comme texte
  28. Pourcentage de valeurs nulles très élevé
  29. Cardinalité étonnamment élevée dans une colonne catégorielle
  30. Cardinalité étonnamment faible
  31. Écart très important entre min et max
  32. Clés métier en double
  33. Notes de production
  34. Les opérations d’inspection peuvent être coûteuses
  35. df.info(memory_usage="deep") peut être lent
  36. Les types de données pandas doivent être interprétés
  37. Ne modifiez rien pendant l’inspection
  38. Les échantillons peuvent masquer des problèmes rares
  39. Les pipelines de production ont besoin d’assertions ou de règles de qualité
  40. Erreurs fréquentes
  41. 1. Considérer head() comme représentatif
  42. 2. Appeler drop_duplicates() immédiatement
  43. 3. Remplacer toutes les valeurs nulles par zéro
  44. 4. Supposer que pandas a inféré le bon dtype
  45. 5. Afficher toutes les valeurs uniques
  46. 6. Convertir des données incorrectes avant de les inspecter
  47. 7. Profiler toutes les colonnes d’un énorme DataFrame
  48. Étape suivante
  49. Pour aller plus loin

Problème

Vous avez chargé dans pandas un CSV, un fichier Parquet, une réponse d’API ou le résultat d’une requête, et vous devez comprendre ce que contiennent réellement les données avant de les transformer.

L’objectif est de répondre rapidement aux questions suivantes :

  • Combien y a-t-il de lignes et de colonnes ?
  • Quels sont les noms et les types de données des colonnes ?
  • Quelles colonnes contiennent des valeurs nulles ?
  • Y a-t-il des lignes en double ?
  • Quelles valeurs dominent les colonnes catégorielles ?
  • Les plages numériques sont-elles plausibles ?
  • Les colonnes de dates sont-elles réellement interprétées comme des dates ?
  • Y a-t-il des chaînes suspectes, des types mélangés ou des valeurs inattendues ?

Faites-le avant les jointures, les agrégations, le filtrage ou la réécriture des données.

Réponse rapide

Commencez par une passe d’inspection compacte :

import pandas as pd

df = pd.read_parquet("data.parquet")

print(df.shape)
print(df.columns.tolist())
df.info()

print(df.head())
print(df.isna().sum().sort_values(ascending=False).head(20))
print(df.duplicated().sum())

print(df.describe(include="all").T)

Vous obtenez ainsi :

  • les dimensions
  • les noms de colonnes
  • les types de données inférés
  • le nombre de valeurs nulles
  • le nombre de doublons
  • des lignes d’exemple
  • des résumés numériques et non numériques

Ne commencez pas à transformer les données tant que le schéma et la qualité des données ne semblent pas plausibles.

Code / commandes

1. Vérifier la forme et les noms de colonnes

print(df.shape)
print(df.columns.tolist())

Faites-le immédiatement après le chargement des données.

Exemple :

(125000, 18)

signifie :

  • 125 000 lignes
  • 18 colonnes

Si la forme est étonnamment petite ou grande, vérifiez la source avant toute autre chose.


2. Inspecter le schéma et l’utilisation mémoire

df.info()

Pour une vision plus détaillée de la mémoire :

df.info(memory_usage="deep")

Utilisez-le pour inspecter :

  • les noms de colonnes
  • le nombre de valeurs non nulles
  • les dtypes
  • l’utilisation mémoire approximative

memory_usage="deep" est plus précis pour les DataFrames riches en colonnes object ou string, mais peut prendre plus de temps sur de gros volumes.


3. Afficher les premières et les dernières lignes

print(df.head())
print(df.tail())

Choisissez un nombre précis lorsque c’est utile :

print(df.head(10))

Utilisez-le pour vérifier :

  • le comportement du délimiteur et de l’analyse
  • l’alignement des colonnes
  • les valeurs nulles évidentes
  • les en-têtes inattendus
  • le format des dates
  • les valeurs suspectes

Ne vous fiez pas à head() seul pour tirer des conclusions sur la qualité des données.


4. Échantillonner des lignes au hasard

print(df.sample(10, random_state=42))

Un échantillon aléatoire est souvent plus représentatif que les premières lignes.

Utilisez un random_state fixe lorsque vous voulez une inspection reproductible.


5. Inspecter les types de données

print(df.dtypes)

Filtrer par type :

numeric_cols = df.select_dtypes(include="number").columns
text_cols = df.select_dtypes(include=["object", "string"]).columns
date_cols = df.select_dtypes(include=["datetime", "datetimetz"]).columns

Utilisez-le pour détecter des problèmes tels que :

  • des colonnes numériques chargées comme chaînes
  • des dates chargées comme chaînes
  • des identifiants inférés par erreur comme des nombres

6. Compter les valeurs nulles par colonne

null_counts = df.isna().sum().sort_values(ascending=False)
print(null_counts)

Ajouter le pourcentage :

null_summary = (
    pd.DataFrame(
        {
            "null_count": df.isna().sum(),
            "null_pct": df.isna().mean().mul(100),
        }
    )
    .sort_values("null_pct", ascending=False)
)

print(null_summary)

Utilisez des pourcentages, car un nombre brut de valeurs nulles est difficile à interpréter sans le nombre de lignes.


7. Vérifier les lignes en double

duplicate_count = df.duplicated().sum()
print(duplicate_count)

Inspecter les doublons :

duplicates = df[df.duplicated(keep=False)]
print(duplicates.head(20))

Ne supprimez pas automatiquement les doublons tant que vous ne savez pas s’ils sont invalides.

Des lignes répétées peuvent correspondre à des événements légitimes.


8. Vérifier les doublons par clé métier

Les contrôles de doublons sur la ligne entière peuvent passer à côté des doublons qui comptent vraiment.

Exemple :

key_cols = ["customer_id", "order_id"]

duplicate_keys = df[
    df.duplicated(subset=key_cols, keep=False)
].sort_values(key_cols)

print(duplicate_keys.head(50))

Utilisez les colonnes qui doivent identifier de manière unique une entité ou un événement métier.


9. Résumer les colonnes numériques

print(df.describe().T)

Champs utiles :

  • le nombre de valeurs (count)
  • la moyenne
  • l’écart type
  • le minimum
  • les quartiles
  • le maximum

C’est un moyen rapide de repérer :

  • des valeurs négatives impossibles
  • des maximums extrêmes
  • des zéros suspects
  • une échelle inattendue

10. Résumer tous les types de colonnes

summary = df.describe(include="all").T
print(summary)

Cela peut montrer :

  • le nombre de valeurs uniques
  • les valeurs les plus fréquentes
  • la distribution numérique
  • les plages de dates lorsque c’est pris en charge

Sur des données très larges ou à forte cardinalité, préférez des résumés ciblés plutôt qu’un profilage aveugle de toutes les colonnes.


11. Compter les valeurs uniques

unique_counts = df.nunique(dropna=False).sort_values()
print(unique_counts)

Utile pour détecter :

  • les colonnes constantes
  • les identifiants presque uniques
  • les catégories à cardinalité étonnamment élevée
  • les booléens encodés en chaînes ou en entiers

Exemple :

constant_cols = df.columns[df.nunique(dropna=False) <= 1]
print(constant_cols.tolist())

12. Inspecter les valeurs catégorielles

print(df["status"].value_counts(dropna=False))

Afficher les pourcentages :

print(
    df["status"]
    .value_counts(dropna=False, normalize=True)
    .mul(100)
    .round(2)
)

Utilisez-le pour détecter :

  • les variantes orthographiques
  • les catégories inattendues
  • les chaînes assimilables à des nulls, comme "NULL" ou "N/A"
  • les valeurs dominantes

13. Inspecter plusieurs colonnes catégorielles en toute sécurité

for col in ["status", "country", "channel"]:
    print(f"\n--- {col} ---")
    print(df[col].value_counts(dropna=False).head(20))

Évitez d’afficher toutes les valeurs uniques des colonnes à forte cardinalité.

Limitez la sortie.


14. Inspecter les plages numériques

numeric_summary = df.select_dtypes(include="number").agg(
    ["min", "max", "mean", "median"]
).T

print(numeric_summary)

Utilisez-le pour valider les attentes du domaine.

Exemples de questions :

  • La quantité peut-elle être négative ?
  • Un pourcentage doit-il dépasser 100 ?
  • Un âge peut-il valoir 250 ?
  • Le chiffre d’affaires doit-il un jour être nul ?

15. Vérifier les plages de dates

Si une colonne de dates est déjà interprétée :

print(df["event_time"].min())
print(df["event_time"].max())

Si elle est encore au format texte :

parsed = pd.to_datetime(df["event_time"], errors="coerce")
print(parsed.min())
print(parsed.max())
print(parsed.isna().sum())

errors="coerce" est utile pendant l’inspection, car les valeurs invalides deviennent NaT.

N’écrasez pas la colonne d’origine tant que vous n’avez pas compris ce qui n’a pas pu être interprété.


16. Repérer les espaces suspects dans les colonnes de texte

col = "customer_name"

leading_or_trailing_space = df[
    df[col].notna()
    & (df[col] != df[col].str.strip())
]

print(leading_or_trailing_space.head(20))

Les problèmes d’espaces peuvent casser :

  • les jointures
  • la déduplication
  • le regroupement
  • les comparaisons d’égalité

17. Distinguer les chaînes vides des valeurs nulles

empty_string_counts = (
    df.select_dtypes(include=["object", "string"])
    .apply(lambda s: s.eq("").sum())
    .sort_values(ascending=False)
)

print(empty_string_counts)

Une chaîne vide n’est pas la même chose que NaN ou None.

Traitez-les selon la sémantique du système source.


18. Repérer les chaînes courantes assimilables à des nulls

null_like_values = {"", "null", "none", "n/a", "na", "unknown"}

for col in df.select_dtypes(include=["object", "string"]).columns:
    s = df[col].astype("string").str.strip().str.lower()
    count = s.isin(null_like_values).sum()

    if count:
        print(col, count)

Utilisez-le uniquement à des fins de diagnostic.

Ne convertissez pas globalement ces chaînes en null sans confirmer leur signification métier.


19. Inspecter un enregistrement par clé métier

row = df.loc[df["customer_id"].eq(12345)]
print(row)

Pour plusieurs conditions :

row = df.loc[
    df["customer_id"].eq(12345)
    & df["order_id"].eq("A1007")
]

print(row)

C’est souvent le moyen le plus rapide de valider un enregistrement problématique connu.


20. Créer une fonction d’inspection compacte et réutilisable

def inspect_dataframe(df: pd.DataFrame) -> None:
    print("Shape:", df.shape)

    print("\nDtypes:")
    print(df.dtypes)

    print("\nNulls:")
    print(df.isna().sum().sort_values(ascending=False).head(20))

    print("\nUnique values:")
    print(df.nunique(dropna=False).sort_values().head(20))

    print("\nDuplicate rows:", df.duplicated().sum())

    print("\nSample:")
    print(df.sample(min(5, len(df)), random_state=42))

Utilisez-la pour une analyse locale rapide.

Pour les pipelines de production, préférez une validation et une journalisation structurées plutôt qu’une inspection fondée sur des print.

Interpréter le résultat

Signal Pourquoi c’est important
df.shape Confirme que le volume ingéré correspond à peu près à ce que vous attendiez.
df.dtypes Montre comment pandas a interprété chaque colonne. Une mauvaise inférence peut casser les calculs et les jointures.
nombre de valeurs non nulles Révèle les colonnes partiellement renseignées.
pourcentage de valeurs nulles Aide à distinguer des valeurs manquantes occasionnelles de champs systématiquement absents.
nunique() Aide à identifier les identifiants, les constantes, les catégories et les cardinalités suspectes.
doublons Signalent des enregistrements répétés, mais seulement après avoir défini ce que signifie « doublon ».
min/max Révèlent rapidement des valeurs numériques ou de dates impossibles ou suspectes.
value_counts() Montre la distribution des catégories et les valeurs inattendues.
utilisation mémoire Aide à prévoir si des opérations ultérieures, comme des jointures ou des copies, risquent de devenir coûteuses.

Points à vérifier

Colonne numérique chargée comme object ou string

Causes possibles :

  • des symboles monétaires
  • des virgules
  • des valeurs mélangées
  • des jetons invalides
  • des incohérences de format à la source

N’appelez pas immédiatement astype(float).

Inspectez d’abord les valeurs incorrectes.

Colonne de dates chargée comme texte

Vérifiez :

  • la présence de plusieurs formats de date
  • les indicateurs de fuseau horaire
  • les valeurs invalides
  • l’ambiguïté entre jour et mois

Interprétez les dates de manière explicite.

Pourcentage de valeurs nulles très élevé

Demandez-vous si la colonne est :

  • facultative
  • propre à une source
  • introduite récemment
  • cassée en amont

Ne remplacez pas automatiquement les valeurs nulles par zéro ou par une chaîne vide.

Cardinalité étonnamment élevée dans une colonne catégorielle

Causes possibles :

  • des espaces
  • des différences de casse
  • des identifiants stockés dans le mauvais champ
  • des données sources sales

Cardinalité étonnamment faible

Un identifiant censé être unique qui ne compte que quelques valeurs est un signal majeur.

Vérifiez la source et la logique de transformation.

Écart très important entre min et max

Examinez :

  • les incohérences d’unités
  • les erreurs de signe
  • la conversion de devises
  • une analyse mal formée
  • les valeurs aberrantes

Clés métier en double

Cela peut indiquer :

  • une duplication à la source
  • des relations un-à-plusieurs
  • des événements retraités
  • une définition de clé incomplète

Ne supprimez rien tant que la granularité métier n’est pas claire.

Notes de production

Les opérations d’inspection peuvent être coûteuses

Certaines opérations parcourent toutes les lignes :

  • isna().sum()
  • nunique()
  • duplicated()
  • describe()
  • value_counts()

Sur de très grands DataFrames, évitez de lancer aveuglément toutes les opérations de profilage.

Privilégiez d’abord des colonnes ciblées ou une exploration sur échantillon.

df.info(memory_usage="deep") peut être lent

L’inspection mémoire approfondie mesure plus précisément la mémoire des objets et chaînes Python.

Utilisez-la lorsque le diagnostic mémoire compte, pas systématiquement dans chaque pipeline.

Les types de données pandas doivent être interprétés

Exemples :

  • object peut contenir des chaînes, des objets Python mélangés ou des valeurs incohérentes
  • les dtypes pandas nullables comme Int64, boolean et string se comportent différemment des types primitifs NumPy
  • les datetimes avec fuseau horaire diffèrent des datetimes naïfs

Ne déduisez pas la sémantique métier du seul dtype.

Ne modifiez rien pendant l’inspection

Préférez des contrôles non destructifs.

Mauvaise pratique :

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

pendant l’inspection initiale.

Plus sûr :

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

Comparez ensuite les échecs avant de remplacer la colonne d’origine.

Les échantillons peuvent masquer des problèmes rares

head() et sample() sont utiles, mais incomplets.

Utilisez des contrôles sur la colonne entière pour :

  • les valeurs nulles
  • les doublons
  • l’intégrité des clés
  • la validation des plages

lorsque la précision compte.

Les pipelines de production ont besoin d’assertions ou de règles de qualité

L’inspection manuelle sert à l’exploration et au dépannage.

Les pipelines de production doivent à terme encoder des attentes telles que :

assert df["order_id"].notna().all()
assert not df["order_id"].duplicated().any()

Pour des systèmes plus importants, utilisez un véritable framework de validation ou des contrôles de qualité au niveau du pipeline.

Erreurs fréquentes

1. Considérer head() comme représentatif

Les premières lignes peuvent toutes provenir de la même partition, de la même date, du même client ou du même ordre de tri.

Utilisez des échantillons aléatoires et des contrôles agrégés.

2. Appeler drop_duplicates() immédiatement

Les doublons peuvent être légitimes.

Définissez d’abord la clé métier et la granularité des événements.

3. Remplacer toutes les valeurs nulles par zéro

Zéro et valeur manquante ne sont pas la même chose.

Cela peut altérer le sens des données sans que rien ne le signale.

4. Supposer que pandas a inféré le bon dtype

Inspectez toujours les dtypes après l’ingestion.

Les données CSV sont particulièrement exposées aux problèmes d’inférence.

5. Afficher toutes les valeurs uniques

Cela peut inonder les journaux ou les notebooks pour les colonnes à forte cardinalité.

Utilisez :

value_counts().head()

ou nunique() en premier.

6. Convertir des données incorrectes avant de les inspecter

Utiliser errors="coerce" directement sur la colonne source peut masquer les valeurs invalides d’origine.

Comparez d’abord, puis nettoyez de manière délibérée.

7. Profiler toutes les colonnes d’un énorme DataFrame

Certaines opérations d’inspection parcourent toutes les données.

Commencez par :

  • la forme
  • les dtypes
  • des comptages ciblés de valeurs nulles
  • un échantillon
  • les colonnes métier critiques connues

Puis élargissez uniquement là où c’est nécessaire.

Étape suivante

Utilisez les résultats de l’inspection pour décider de la suite.

  • Dtypes incorrects → normalisez les types avec soin et inspectez les échecs de conversion.
  • Valeurs manquantes → déterminez si elles sont attendues avant de les remplacer ou de les supprimer.
  • Clés métier en double → définissez la bonne granularité et remontez à l’origine de la duplication en amont.
  • Catégories inattendues → normalisez les espaces et la casse uniquement après avoir validé la sémantique.
  • Valeurs numériques extrêmes → validez les unités, la logique de la source et les plages métier.
  • Empreinte mémoire importante → inspectez les dtypes, la représentation des chaînes et la sélection des colonnes.
  • Le schéma semble propre → passez au filtrage, aux jointures, aux agrégations ou à la validation.
  • Données trop volumineuses pour des parcours complets répétés → réduisez les colonnes ou les lignes, ou déplacez le traitement vers un moteur distribué.

← Tous les aide-mémoire