Parcourir les aide-mémoire · Python
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
- Problème
- Réponse rapide
- Code / commandes
- 1. Vérifier la forme et les noms de colonnes
- 2. Inspecter le schéma et l’utilisation mémoire
- 3. Afficher les premières et les dernières lignes
- 4. Échantillonner des lignes au hasard
- 5. Inspecter les types de données
- 6. Compter les valeurs nulles par colonne
- 7. Vérifier les lignes en double
- 8. Vérifier les doublons par clé métier
- 9. Résumer les colonnes numériques
- 10. Résumer tous les types de colonnes
- 11. Compter les valeurs uniques
- 12. Inspecter les valeurs catégorielles
- 13. Inspecter plusieurs colonnes catégorielles en toute sécurité
- 14. Inspecter les plages numériques
- 15. Vérifier les plages de dates
- 16. Repérer les espaces suspects dans les colonnes de texte
- 17. Distinguer les chaînes vides des valeurs nulles
- 18. Repérer les chaînes courantes assimilables à des nulls
- 19. Inspecter un enregistrement par clé métier
- 20. Créer une fonction d’inspection compacte et réutilisable
- Interpréter le résultat
- Points à vérifier
- Colonne numérique chargée comme object ou string
- Colonne de dates chargée comme texte
- Pourcentage de valeurs nulles très élevé
- Cardinalité étonnamment élevée dans une colonne catégorielle
- Cardinalité étonnamment faible
- Écart très important entre min et max
- Clés métier en double
- Notes de production
- Les opérations d’inspection peuvent être coûteuses
- df.info(memory_usage="deep") peut être lent
- Les types de données pandas doivent être interprétés
- Ne modifiez rien pendant l’inspection
- Les échantillons peuvent masquer des problèmes rares
- Les pipelines de production ont besoin d’assertions ou de règles de qualité
- Erreurs fréquentes
- 1. Considérer head() comme représentatif
- 2. Appeler drop_duplicates() immédiatement
- 3. Remplacer toutes les valeurs nulles par zéro
- 4. Supposer que pandas a inféré le bon dtype
- 5. Afficher toutes les valeurs uniques
- 6. Convertir des données incorrectes avant de les inspecter
- 7. Profiler toutes les colonnes d’un énorme DataFrame
- Étape suivante
- 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 :
objectpeut contenir des chaînes, des objets Python mélangés ou des valeurs incohérentes- les dtypes pandas nullables comme
Int64,booleanetstringse 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.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.