Parcourir les aide-mémoire · Python

Technologie: PythonCatégorie: DépannageNiveau: IntermédiaireMis à jour

Déboguer les problèmes courants de pandas

Diagnostiquez les défaillances courantes de pandas liées aux dtypes, aux valeurs manquantes, aux jointures, à l’affectation en chaîne, aux données en double, aux erreurs de dates, à la pression mémoire et aux variations inattendues du nombre de lignes.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Déboguer un KeyError dû à une colonne manquante
  5. 2. Déboguer une casse incorrecte ou des colonnes renommées
  6. 3. Déboguer les échecs de conversion numérique
  7. 4. Déboguer des valeurs nulles inattendues après une conversion
  8. 5. Déboguer les échecs d’analyse des dates
  9. 6. Déboguer les erreurs de comparaison entre dates avec et sans fuseau horaire (aware vs naive)
  10. 7. Déboguer les filtres qui ne renvoient aucune ligne
  11. 8. Déboguer les erreurs de filtre booléen
  12. 9. Déboguer les problèmes d’affectation en chaîne
  13. 10. Déboguer une augmentation inattendue du nombre de lignes après un merge
  14. 11. Déboguer les correspondances manquantes après un merge
  15. 12. Déboguer les lignes en double
  16. 13. Déboguer des totaux gonflés après une jointure
  17. 14. Déboguer des changements de dtype inattendus après l’ingestion d’un CSV
  18. 15. Déboguer des colonnes entières qui deviennent des flottants
  19. 16. Déboguer des colonnes object qui devraient être numériques
  20. 17. Déboguer ValueError: cannot convert float NaN to integer
  21. 18. Déboguer SettingWithCopyWarning / la confusion autour du copy-on-write
  22. 19. Déboguer des totaux de groupby() qui semblent faux
  23. 20. Déboguer des groupes manquants dans groupby()
  24. 21. Déboguer une logique de « dernière ligne » incorrecte
  25. 22. Déboguer un .apply() lent
  26. 23. Déboguer l’utilisation de la mémoire
  27. 24. Réduire la mémoire avant un merge volumineux
  28. 25. Déboguer un tri anormalement lent
  29. 26. Déboguer des lignes CSV décalées dans les mauvaises colonnes
  30. 27. Déboguer des lignes CSV mal formées
  31. 28. Déboguer une structure JSON inattendue
  32. 29. Déboguer les résultats en comparant des invariants
  33. 30. Créer une fonction de diagnostic de DataFrame réutilisable
  34. Interpréter le résultat
  35. Points à vérifier
  36. Le nombre de lignes change de façon inattendue
  37. Le nombre de valeurs nulles augmente de façon inattendue
  38. Le dtype change de façon inattendue
  39. Les totaux changent après un enrichissement
  40. Les données semblent correctes dans head() mais les métriques sont fausses
  41. Un contournement « corrige » l’erreur mais en masque la cause
  42. Notes de production
  43. Déboguer avec de petits échantillons représentatifs
  44. Suivre les changements de schéma et de nombre de lignes
  45. Éviter de modifier beaucoup de choses à la fois
  46. Conserver les enregistrements invalides pour analyse
  47. Les exceptions peuvent être plus sûres qu’une coercition silencieuse
  48. pandas est un outil en mémoire
  49. Erreurs fréquentes
  50. 1. Corriger les symptômes plutôt que les causes
  51. 2. Déboguer uniquement le DataFrame final
  52. 3. Faire confiance à head()
  53. 4. Ignorer la granularité métier
  54. 5. Ignorer les dtypes
  55. 6. Supprimer les avertissements aveuglément
  56. 7. Utiliser errors="coerce" sans mesurer l’impact
  57. 8. Supprimer automatiquement les lignes d’entrée mal formées
  58. 9. Déboguer les performances avant l’exactitude
  59. Étape suivante
  60. Pour aller plus loin

Problème

Un traitement pandas échoue, produit un nombre de lignes incorrect, change les dtypes de façon inattendue, crée des valeurs manquantes ou renvoie des résultats qui ne correspondent pas à la logique métier.

Les symptômes courants sont notamment :

  • KeyError
  • ValueError lors d’une conversion
  • échecs de merge/join
  • lignes en double inattendues
  • valeurs nulles inattendues
  • avertissements d’affectation en chaîne (chained assignment)
  • erreurs de comparaison de dates
  • erreurs de mémoire
  • dtype object là où des données numériques ou de date étaient attendues
  • totaux qui changent après un merge
  • filtrage qui ne renvoie aucune ligne

L’objectif est d’isoler rapidement la défaillance sans masquer le problème de données sous-jacent.

Réponse rapide

Commencez par une passe de diagnostic compacte :

print("Shape:", df.shape)
print("\nColumns:")
print(df.columns.tolist())

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

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

print("\nDuplicates:")
print(df.duplicated().sum())

print("\nSample:")
print(df.head())

Posez-vous ensuite ces questions :

Le nombre de lignes a-t-il changé ?
Le dtype a-t-il changé ?
Le nombre de valeurs nulles a-t-il changé ?
L’unicité des clés a-t-elle changé ?
L’opération a-t-elle préservé la granularité voulue ?

La plupart des bogues pandas deviennent plus faciles à résoudre dès que vous comparez le DataFrame juste avant et juste après la transformation défaillante.

Code / commandes

1. Déboguer un KeyError dû à une colonne manquante

Vérifiez les noms exacts des colonnes :

print(df.columns.tolist())

Recherchez les espaces superflus :

for col in df.columns:
    print(repr(col))

Si la source contient des espaces accidentels :

df.columns = (
    df.columns
    .str.strip()
)

Ne normalisez pas les noms de colonnes aveuglément si des contrats externes dépendent des noms exacts.


2. Déboguer une casse incorrecte ou des colonnes renommées

Vérifiez :

print(df.columns)

Les différences de casse comptent :

CustomerID
customerid
customer_id

sont des noms de colonnes différents.

Si vous avez besoin de noms normalisés, faites-le une seule fois à l’ingestion et rendez ce schéma explicite.


3. Déboguer les échecs de conversion numérique

Au lieu de :

df["amount"] = df["amount"].astype(float)

utilisez :

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

Trouvez les valeurs en échec :

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

print(
    failed
    .value_counts()
    .head(20)
)

Causes typiques :

  • virgules
  • symboles monétaires
  • libellés textuels
  • chaînes vides
  • valeurs sentinelles
  • enregistrements source mal formés

4. Déboguer des valeurs nulles inattendues après une conversion

Mesurez avant et après :

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

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

after_nulls = parsed.isna().sum()

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

De nouvelles valeurs nulles inattendues signifient que des valeurs source n’ont pas pu être converties.

Ne continuez pas en silence.


5. Déboguer les échecs d’analyse des dates

Analysez les valeurs dans une Series temporaire :

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

Trouvez les échecs :

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

print(
    failed
    .value_counts()
    .head(20)
)

Vérifiez la présence de :

  • formats mélangés
  • dates invalides
  • texte de fuseau horaire
  • ambiguïté jour/mois
  • changements inattendus dans la source

6. Déboguer les erreurs de comparaison entre dates avec et sans fuseau horaire (aware vs naive)

Inspectez les deux côtés :

print(df["event_time"].dtype)
print(start_time)
print(start_time.tzinfo)

Si la Series est en UTC avec fuseau horaire :

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

Utilisez ensuite une borne de comparaison avec fuseau horaire :

start_time = pd.Timestamp(
    "2026-10-01",
    tz="UTC",
)

Ne comparez pas des horodatages avec et sans fuseau horaire sans avoir décidé quel fuseau horaire représente la valeur sans fuseau.


7. Déboguer les filtres qui ne renvoient aucune ligne

Commencez par vérifier les valeurs réelles :

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

Inspectez les valeurs normalisées :

normalized = (
    df["status"]
    .astype("string")
    .str.strip()
    .str.casefold()
)

print(
    normalized
    .value_counts(dropna=False)
    .head(20)
)

Causes fréquentes :

  • espaces superflus
  • casse
  • valeurs nulles
  • incompatibilité de dtype
  • codes inattendus
  • bornes de dates incorrectes

8. Déboguer les erreurs de filtre booléen

Incorrect :

df[
    df["amount"] > 100
    and df["status"] == "active"
]

Correct :

df.loc[
    (df["amount"] > 100)
    & (df["status"] == "active")
]

Pour les Series pandas, utilisez :

  • &
  • |
  • ~

et placez chaque condition entre parenthèses.


9. Déboguer les problèmes d’affectation en chaîne

Risqué :

df[df["amount"] > 100]["flag"] = True

Utilisez :

df.loc[
    df["amount"] > 100,
    "flag",
] = True

Si vous voulez intentionnellement un DataFrame filtré distinct :

subset = df.loc[
    df["amount"] > 100
].copy()

subset["flag"] = True

Rendez la propriété des données explicite au lieu de compter sur des vues/copies ambiguës.


10. Déboguer une augmentation inattendue du nombre de lignes après un merge

Mesurez avant et après :

before = len(left)

result = left.merge(
    right,
    on="customer_id",
    how="left",
)

after = len(result)

print("Before:", before)
print("After:", after)
print("Added rows:", after - before)

Si une jointure d’enrichissement à gauche fait croître le nombre de lignes de façon inattendue, inspectez les doublons à droite :

duplicate_right_keys = right.loc[
    right["customer_id"]
    .duplicated(keep=False)
].sort_values("customer_id")

print(duplicate_right_keys)

Utilisez la validation de cardinalité :

result = left.merge(
    right,
    on="customer_id",
    how="left",
    validate="many_to_one",
)

11. Déboguer les correspondances manquantes après un merge

Utilisez indicator=True :

result = left.merge(
    right,
    on="customer_id",
    how="left",
    indicator=True,
)

Inspectez les lignes sans correspondance :

unmatched = result.loc[
    result["_merge"] == "left_only"
]

print(unmatched.head(50))

Comparez ensuite les dtypes des clés :

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

Vérifiez le formatage :

print(
    left["customer_id"]
    .astype("string")
    .str.strip()
    .head()
)

12. Déboguer les lignes en double

Vérifiez les doublons sur la ligne entière :

print(df.duplicated().sum())

Vérifiez les doublons sur la clé métier :

key_cols = [
    "customer_id",
    "order_id",
]

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

print(duplicates)

N’appelez pas drop_duplicates() avant d’avoir défini ce que doit être la clé métier.


13. Déboguer des totaux gonflés après une jointure

Avant la jointure :

source_total = left["amount"].sum()

Après :

result_total = result["amount"].sum()

print("Before:", source_total)
print("After:", result_total)

Si le total a augmenté, inspectez :

  • les clés en double côté droit
  • une clé composite incorrecte
  • une expansion many-to-many
  • des lignes en double côté gauche

Ne réagrégez pas le total tant que la multiplication des lignes n’est pas comprise.


14. Déboguer des changements de dtype inattendus après l’ingestion d’un CSV

Inspectez :

print(df.dtypes)

Si un identifiant est devenu numérique, rechargez avec un dtype explicite :

df = pd.read_csv(
    "orders.csv",
    dtype={
        "customer_id": "string",
    },
)

Un CSV n’embarque aucun schéma.

L’inférence n’est pas un contrat de données.


15. Déboguer des colonnes entières qui deviennent des flottants

Cela arrive souvent parce que les valeurs manquantes ne peuvent pas être représentées par le dtype entier de NumPy.

Utilisez les entiers nullables de pandas :

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

Les valeurs manquantes peuvent désormais coexister avec une sémantique d’entier.


16. Déboguer des colonnes object qui devraient être numériques

Inspectez les types Python des valeurs :

print(
    df["amount"]
    .dropna()
    .map(type)
    .value_counts()
)

Inspectez ensuite les valeurs invalides uniques au moyen de la conversion :

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

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

print(
    bad
    .value_counts()
    .head(20)
)

17. Déboguer ValueError: cannot convert float NaN to integer

N’utilisez pas :

df["quantity"].astype(int)

s’il existe des valeurs nulles.

Utilisez :

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

ou décidez d’abord si les valeurs manquantes doivent être remplies ou rejetées.


18. Déboguer SettingWithCopyWarning / la confusion autour du copy-on-write

Préférez une sélection et une affectation explicites :

mask = df["status"].eq("active")

df.loc[
    mask,
    "flag",
] = True

Pour des sous-ensembles indépendants :

active = df.loc[
    mask
].copy()

Les versions récentes de pandas utilisent de plus en plus la sémantique copy-on-write, mais .loc[] et .copy() explicites rendent toujours l’intention plus claire et évitent un code fragile.


19. Déboguer des totaux de groupby() qui semblent faux

Vérifiez d’abord la granularité des données d’entrée.

print(
    df.duplicated(
        subset=["order_id"]
    ).sum()
)

Comparez ensuite le nombre de lignes et le nombre de valeurs distinctes :

print("Rows:", len(df))
print(
    "Unique orders:",
    df["order_id"].nunique(),
)

Si une commande apparaît plusieurs fois à cause d’une jointure antérieure, une simple somme peut compter le chiffre d’affaires en double.


20. Déboguer des groupes manquants dans groupby()

Les clés de regroupement nulles en sont souvent la cause.

Comparez :

summary_default = (
    df.groupby("country")
    .size()
)

avec :

summary_with_nulls = (
    df.groupby(
        "country",
        dropna=False,
    )
    .size()
)

Si les totaux concordent désormais, des clés de regroupement manquantes étaient auparavant exclues.


21. Déboguer une logique de « dernière ligne » incorrecte

Mauvais modèle :

latest = (
    df.groupby("customer_id")
    .max()
)

Cela peut combiner des maximums issus de lignes différentes.

Correct :

latest = (
    df.sort_values(
        [
            "customer_id",
            "event_time",
            "event_id",
        ],
        ascending=[
            True,
            False,
            False,
        ],
    )
    .drop_duplicates(
        subset=["customer_id"],
        keep="first",
    )
)

Définissez un critère de départage déterministe.


22. Déboguer un .apply() lent

Recherchez du code ligne par ligne comme :

df["result"] = df.apply(
    expensive_function,
    axis=1,
)

Essayez d’abord des alternatives vectorisées.

Exemple :

df["result"] = (
    df["amount"]
    * df["quantity"]
)

Pour les conditions :

df["is_large"] = (
    df["amount"] > 1000
)

Utilisez .apply() lorsque la logique ne peut réellement pas être exprimée de façon vectorisée.


23. Déboguer l’utilisation de la mémoire

Commencez par :

df.info(
    memory_usage="deep",
)

Par colonne :

memory = (
    df.memory_usage(
        deep=True,
    )
    .sort_values(
        ascending=False,
    )
)

print(memory)

Recherchez :

  • de grandes colonnes object/chaînes
  • des colonnes inutilisées
  • du texte à forte cardinalité
  • des DataFrames intermédiaires dupliqués

24. Réduire la mémoire avant un merge volumineux

Sélectionnez uniquement les colonnes nécessaires :

left_small = left[
    [
        "customer_id",
        "order_id",
        "amount",
    ]
]

right_small = right[
    [
        "customer_id",
        "segment",
    ]
]

Puis faites le merge :

result = left_small.merge(
    right_small,
    on="customer_id",
    how="left",
    validate="many_to_one",
)

Évitez de transporter des dizaines de colonnes inutilisées à travers des opérations coûteuses.


25. Déboguer un tri anormalement lent

Si vous n’avez besoin que des premières lignes :

top_10 = df.nlargest(
    10,
    "revenue",
)

au lieu de :

top_10 = (
    df.sort_values(
        "revenue",
        ascending=False,
    )
    .head(10)
)

Pour un top N par groupe, ne triez qu’après avoir filtré et sélectionné les colonnes nécessaires.


26. Déboguer des lignes CSV décalées dans les mauvaises colonnes

Inspectez le fichier brut et vos hypothèses sur le délimiteur.

Essayez :

df = pd.read_csv(
    "data.csv",
    sep=",",
)

Si la source utilise un autre délimiteur :

df = pd.read_csv(
    "data.csv",
    sep=";",
)

Examinez aussi :

  • les délimiteurs intégrés aux valeurs
  • les guillemets
  • les lignes mal formées
  • l’encodage

N’utilisez pas une analyse permissive pour masquer des enregistrements source corrompus sans mesurer ce qui a été ignoré ou modifié.


27. Déboguer des lignes CSV mal formées

Si vous devez temporairement identifier des problèmes d’analyse, isolez le fichier défectueux au lieu d’accepter en silence une perte de données.

Une lecture de diagnostic peut utiliser :

df = pd.read_csv(
    "data.csv",
    on_bad_lines="warn",
)

C’est utile pendant l’investigation.

En production, décidez délibérément si les enregistrements mal formés doivent :

  • faire échouer le chargement
  • être mis en quarantaine
  • être corrigés en amont

Ne faites pas de skip le comportement par défaut simplement pour garder un pipeline au vert.


28. Déboguer une structure JSON inattendue

Inspectez la structure brute avant la normalisation.

print(type(payload))

Si elle est imbriquée :

df = pd.json_normalize(
    payload["results"]
)

Si des tableaux se développent en plusieurs lignes, vérifiez la granularité voulue.

Par exemple :

une ligne par commande

est différent de :

une ligne par article de commande

29. Déboguer les résultats en comparant des invariants

Avant une transformation :

before = {
    "rows": len(df),
    "orders": df["order_id"].nunique(),
    "revenue": df["amount"].sum(),
}

Après :

after = {
    "rows": len(result),
    "orders": result["order_id"].nunique(),
    "revenue": result["amount"].sum(),
}

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

Choisissez les invariants en fonction de l’opération.

Exemples :

  • jointure d’enrichissement à gauche → le nombre de lignes et les totaux doivent peut-être rester identiques
  • dédoublonnage → le nombre de lignes change intentionnellement
  • filtrage → les totaux doivent diminuer de façon prévisible
  • agrégation → le nombre de lignes change, mais les totaux peuvent concorder

30. Créer une fonction de diagnostic de DataFrame réutilisable

def diagnose_df(
    df: pd.DataFrame,
    key_cols: list[str] | None = None,
) -> None:
    print("Shape:", df.shape)

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

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

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

    if key_cols:
        print(
            "\nDuplicate keys:",
            df.duplicated(
                subset=key_cols
            ).sum(),
        )

    print("\nSample:")
    print(df.head())

Utilisez des fonctions utilitaires de ce type pour le dépannage local.

Pour les pipelines de production, préférez des journaux structurés et des métriques de qualité des données.

Interpréter le résultat

Un bogue pandas relève généralement de l’une de ces catégories :

Symptôme Zone probable
KeyError schéma / nommage des colonnes
exception de conversion valeurs brutes incompatibles
nouvelles valeurs nulles échec d’analyse ou de jointure
lignes en trop après un merge cardinalité incorrecte / clés en double
lignes manquantes après un merge clés sans correspondance / comportement de jointure interne
totaux incorrects granularité dupliquée / agrégation / expansion de jointure
« dernière » ligne incorrecte logique de tri/départage
dtype object données source mélangées ou faiblement typées
avertissement d’affectation en chaîne chemin de modification ambigu
erreur de comparaison de dates incompatibilité de fuseau horaire ou de dtype
pression mémoire DataFrame/intermédiaires/colonnes object surdimensionnés
.apply() lent exécution Python ligne par ligne

La démarche de débogage essentielle est :

inspecter
→ isoler
→ comparer avant/après
→ valider les hypothèses
→ changer une seule chose
→ revérifier

Points à vérifier

Le nombre de lignes change de façon inattendue

C’est l’un des signaux les plus forts d’un problème de logique.

Vérifiez :

  • la cardinalité du merge
  • les filtres
  • les clés en double
  • l’explosion/la normalisation
  • le dédoublonnage

Le nombre de valeurs nulles augmente de façon inattendue

Vérifiez :

  • les conversions en échec
  • les jointures sans correspondance
  • les colonnes source manquantes
  • les règles d’analyse

Le dtype change de façon inattendue

Vérifiez :

  • l’inférence CSV
  • les valeurs manquantes
  • la concaténation
  • les merges
  • la logique de conversion

Les totaux changent après un enrichissement

Une expansion many-to-many ou one-to-many est probable.

Validez les clés de jointure avant de continuer.

Les données semblent correctes dans head() mais les métriques sont fausses

head() n’est pas représentatif.

Utilisez :

  • des comptages
  • des comptages de valeurs distinctes
  • des synthèses des valeurs nulles
  • des distributions
  • des totaux de rapprochement

Un contournement « corrige » l’erreur mais en masque la cause

Exemples :

errors="coerce"
drop_duplicates()
fillna(0)
on_bad_lines="skip"

Ces outils peuvent être utiles, mais ils ne doivent pas devenir un moyen automatique de supprimer les erreurs.

Notes de production

Déboguer avec de petits échantillons représentatifs

Pour les traitements coûteux :

sample = df.sample(
    min(10_000, len(df)),
    random_state=42,
)

Utilisez des échantillons pour itérer, puis validez la logique finale sur l’ensemble des données.

N’utilisez pas un échantillon pour prouver l’unicité ou la qualité complète des données.

Suivre les changements de schéma et de nombre de lignes

Les pipelines de production doivent enregistrer au minimum :

  • le nombre de lignes en entrée
  • le nombre de lignes en sortie
  • le nombre de valeurs distinctes des clés
  • le nombre de valeurs nulles des colonnes importantes
  • les totaux métier importants
  • le schéma/les dtypes

Cela transforme une dérive silencieuse des données en comportement observable.

Éviter de modifier beaucoup de choses à la fois

Mauvaise démarche de débogage :

nettoyer les chaînes
convertir les types
supprimer les valeurs nulles
faire le merge
dédoublonner
agréger

le tout dans une seule chaîne.

Pendant l’investigation, séparez les transformations et validez après chaque étape.

Conserver les enregistrements invalides pour analyse

Lorsque c’est possible, mettez les lignes invalides en quarantaine au lieu de les supprimer.

Exemple :

valid = parsed.notna()

good_rows = df.loc[valid].copy()
bad_rows = df.loc[~valid].copy()

Cela préserve les éléments de preuve.

Les exceptions peuvent être plus sûres qu’une coercition silencieuse

Pour des contrats de production stricts, laisser un pipeline échouer peut être préférable à une modification silencieuse des données invalides.

Choisissez la gestion des erreurs en fonction de l’exigence de fiabilité.

pandas est un outil en mémoire

Si le problème relève surtout de la mémoire ou de la volumétrie, la solution n’est peut-être pas une nouvelle astuce pandas.

Envisagez :

  • SQL
  • DuckDB
  • PyArrow
  • Spark
  • PySpark
  • une base de données/un entrepôt de données

selon la charge de travail et l’architecture.

Erreurs fréquentes

1. Corriger les symptômes plutôt que les causes

Des exemples comme :

drop_duplicates()
fillna(0)
astype(str)

peuvent masquer des problèmes de données plus profonds.

Comprenez d’abord pourquoi les données sont incorrectes.

2. Déboguer uniquement le DataFrame final

Inspectez les étapes intermédiaires.

La transformation qui modifie en premier le nombre de lignes, le dtype, les valeurs nulles ou la granularité est généralement celle où commence le bogue.

3. Faire confiance à head()

Quelques lignes ne suffisent pas à valider un jeu de données.

Utilisez des diagnostics agrégés.

4. Ignorer la granularité métier

Beaucoup de bogues pandas sont en réalité des problèmes de granularité.

Définissez :

Que doit représenter une ligne ?

avant les merges, les agrégations ou le dédoublonnage.

5. Ignorer les dtypes

Une incompatibilité chaîne/entier peut casser les jointures et les filtres sans différence visuelle évidente.

6. Supprimer les avertissements aveuglément

Les avertissements révèlent souvent un comportement fragile.

Comprenez-les avant de les désactiver.

7. Utiliser errors="coerce" sans mesurer l’impact

Cette option peut transformer silencieusement des valeurs invalides en valeurs manquantes.

Suivez les nouvelles valeurs nulles créées.

8. Supprimer automatiquement les lignes d’entrée mal formées

Ignorer les lignes invalides peut fausser le nombre de lignes et les totaux alors que le pipeline semble réussir.

9. Déboguer les performances avant l’exactitude

Assurez-vous d’abord que le résultat est correct.

Optimisez ensuite.

Étape suivante

Laissez le symptôme guider la suite.

  • Colonne manquante / KeyError → inspectez le schéma exact et le nommage des colonnes.
  • Échec de conversion → isolez les valeurs brutes invalides avant le cast.
  • Nouvelles valeurs nulles après l’analyse → inspectez les conversions en échec.
  • Les lignes se multiplient après un merge → validez la cardinalité de la jointure et les clés en double.
  • Des lignes disparaissent après un merge → inspectez les clés sans correspondance avec indicator=True.
  • Les totaux gonflent → vérifiez la granularité et l’expansion one-to-many/many-to-many.
  • Mauvaise dernière ligne / mauvais top → définissez un tri complet et déterministe ainsi qu’une logique de départage.
  • La comparaison de dates échoue → normalisez le dtype et la sémantique de fuseau horaire.
  • Pression mémoire → projetez moins de colonnes, filtrez plus tôt et réduisez les intermédiaires.
  • L’exactitude est prouvée mais les performances sont médiocres → profilez l’opération coûteuse et envisagez un moteur d’exécution plus puissant.

← Tous les aide-mémoire