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