10 Erreurs Fréquentes En Python Et Comment Les Éviter

Apprendre la Data Science avec Python est passionnant. Mais soyons honnêtes : tout le monde fait des erreurs, débutants comme confirmés. L’important, ce n’est pas de les éviter à tout prix, mais de les reconnaître rapidement… et de savoir en tirer des leçons.

Dans cet article, je vais passer en revue les 10 erreurs les plus fréquentes, avec des explications simples, des exemples concrets et des conseils pratiques pour les éviter.

Introduction – Pourquoi Les Erreurs Sont Normales En Apprentissage ?

Quand tu apprends un langage comme Python, tu vas forcément tomber sur des erreurs. Et c’est tant mieux : ce sont elles qui t’obligent à réfléchir, à chercher, à comprendre. Elles font partie intégrante du processus d’apprentissage. Le but n’est donc pas de les craindre, mais d’apprendre à les décoder. Je dis même souvent à mes apprenants d’apprendre à “les aimer”, car elles nous challengent… et on en ressort toujours avec de nouvelles compétences.

Les 10 Erreurs Fréquentes

1. Oublier D’importer Les Bonnes Librairies

C’est sans doute l’erreur la plus basique… mais tout le monde la fait ! Tu lances ton code et tu vois apparaître :

NameError: name 'pd' is not defined

Pourquoi ? Parce que tu essaies d’utiliser une fonction Pandas (pd.DataFrame par exemple) sans avoir importé la librairie au préalable.

Exemple Concret

Tu veux créer un DataFrame Pandas :

data = {'Nom': ['Alice', 'Bob'], 'Age': [25, 30]}
df = pd.DataFrame(data)

Résultat : erreur immédiate, car tu n’as pas fait :

import pandas as pd

Bonne Pratique : Regrouper Ses Imports

Toujours placer tes imports en haut de ton script ou de ton notebook :

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

Cela rend ton code clair et évite de perdre du temps à comprendre pourquoi une fonction “n’existe pas”.

Conseil De Pro

Crée un bloc d’imports standard que tu copies au début de tous tes projets.

2. Confondre Listes, Arrays NumPy Et DataFrames Pandas

Chaque structure a son usage :

• Listes Python : pour stocker de petites collections.
• NumPy arrays : pour les calculs numériques rapides.
• Pandas DataFrames : pour manipuler des données tabulaires.

Astuce

Choisis toujours la structure en fonction de ce que tu veux faire.

Exemple :

• Une liste Python : pratique pour stocker de petites données, comme les notes d’un élève.
  Exemple : [12, 15, 17] → moyenne = 14,6.

• Un array NumPy : idéal pour appliquer des calculs rapides et vectorisés sur des grandes séries numériques.
  Exemple : np.array([1, 2, 3]) * 10 → [10, 20, 30].

• Un DataFrame Pandas : parfait pour gérer et analyser des tableaux complets, avec colonnes et lignes.
  Exemple : un tableau {'Nom': ['Alice', 'Bob'], 'Note': [15, 18]} → moyenne des notes = 16,5.

3. Ne Pas Vérifier Les Valeurs Manquantes

C’est l’une des erreurs les plus fréquentes : ignorer les valeurs manquantes (NaN) dans un jeu de données. Elles sont pourtant très courantes en Data Science : un client qui n’a pas renseigné son âge, une transaction sans date, …

Si tu ne les traites pas, elles faussent tes calculs et peuvent même empêcher ton modèle de machine learning de fonctionner.

Exemple 1 – Moyenne Faussée

Imaginons une colonne age avec des valeurs manquantes :

df['age'].head()
# Résultat : 25, 32, NaN, 40, NaN

Si tu calcules la moyenne directement :

df['age'].mean()
# Résultat : 32.33

Ici, les NaN sont ignorés par défaut, mais si une colonne en contient trop, la moyenne perd tout son sens.

Exemple 2 – Régression Impossible

Si tu lances un modèle de régression avec Scikit-learn sur un dataset contenant des NaN :

from sklearn.linear_model import LinearRegression
model = LinearRegression()
model.fit(X, y)

Tu auras une erreur immédiate : Input contains NaN.
Les algorithmes n’acceptent pas de données manquantes.

Bonnes Pratiques Pour Gérer Les Valeurs Manquantes

1. Les détecter rapidement : df.isnull().sum(). Cela te donne le nombre de valeurs manquantes par colonne.
2. Décider quoi en faire selon le contexte :
   • Supprimer : si la colonne a très peu de valeurs manquantes, ou si elle n’est pas importante.
   • Imputer : remplacer les NaN par une valeur.
     • Moyenne ou médiane pour les numériques.
     • Mode (valeur la plus fréquente) pour les catégorielles.
   • Créer une catégorie spéciale : par exemple “Inconnu” dans une variable ville.
3. Documenter ton choix
   Ne supprime ou n’impute jamais au hasard : explique dans ton projet pourquoi tu as fait ce choix.

Exemple 3 – Remplir Intelligemment

Si tu as une colonne salaire avec des valeurs manquantes :

df['salaire'].fillna(df['salaire'].median(), inplace=True)

Tu remplaces les NaN par la médiane, ce qui évite que les valeurs extrêmes biaisent la moyenne.

Pour une colonne ville avec des valeurs manquantes :

df['ville'].fillna('Inconnue', inplace=True)

Ici les valeurs manquantes sont remplacées par un mot : « Inconnue ».

Conseil De Pro

Ne traite pas toutes les colonnes de la même manière. Une valeur manquante en âge n’a pas le même impact qu’une valeur manquante en code_postal. Analyse toujours avant d’agir.

4. Mal Gérer Les Types De Variables

En Python (et en Data Science en général), bien gérer les types de variables est crucial. Une erreur fréquente est de ne pas vérifier les types et de manipuler les données comme si tout était correct. Résultat : erreurs de calcul, modèles qui plantent ou résultats incohérents.

Exemple 1 – Les Dates Mal Interprétées

Par défaut, quand tu importes un fichier CSV, les dates sont souvent lues comme de simples chaînes de caractères (strings).

df['date'].head()
# Résultat : '2025-09-16', '2025-09-17', ...

Si tu essaies de calculer la différence entre deux dates dans ce format, ça ne marche pas : Python croit que ce sont de simples mots.

Bonne Pratique : Convertir En Vrai Format datetime

df['date'] = pd.to_datetime(df['date'])
df['duree'] = df['date'].max() - df['date'].min()

Tu peux alors calculer un intervalle de temps, extraire le mois, le jour, etc.

Exemple 2 – Confondre int Et float

Imaginons une colonne revenu importée depuis un fichier Excel :

df['revenu'].head()
# Résultat : 2500.0, 3100.0, 2800.0

Ici, chaque valeur est un float (nombre à virgule), même si ce sont des revenus entiers.

Pourquoi c’est un problème ?

• Certains calculs statistiques risquent de ne pas être cohérents (moyennes arrondies avec des décimales inutiles).
• Les regroupements (groupby) peuvent créer des doublons si les types sont incohérents entre colonnes.

Bonne Pratique : Convertir Au Bon Type

df['revenu'] = df['revenu'].astype(int)

Tes calculs sont plus cohérents et tes modèles plus propres.

Exemple 3 – Les Booléens Déguisés En Texte

Autre piège courant : avoir une colonne avec “Oui” et “Non” au lieu de vrais booléens (True/False).

df['achat'].unique()
# Résultat : ['Oui', 'Non']

Difficile de faire des calculs ou de filtrer facilement !

Bonne Pratique : Convertir En Booléen

df['achat'] = df['achat'].map({'Oui': True, 'Non': False})

Conseil De Pro

Avant toute analyse, fais un petit check rapide :

df.dtypes

Cela t’affiche le type de chaque colonne. Tu peux ainsi corriger immédiatement les incohérences.

5. Écrire Du Code Sans Fonction Ni Structure

Quand on débute, on a tendance à tout écrire “en vrac” dans un notebook : copier-coller les mêmes lignes plusieurs fois, refaire les mêmes calculs manuellement… Ça fonctionne au début, mais très vite ton code devient illisible, difficile à maintenir et source d’erreurs.

Exemple D’erreur Classique

Tu veux calculer la moyenne de plusieurs listes de notes :

notes1 = [12, 14, 15, 13]
notes2 = [10, 11, 12, 13, 14]
notes3 = [16, 17, 18]

moyenne1 = sum(notes1) / len(notes1)
moyenne2 = sum(notes2) / len(notes2)
moyenne3 = sum(notes3) / len(notes3)

Ça marche… mais tu répètes trois fois le même calcul. Si demain tu dois en calculer 20, ton code devient ingérable.

Bonne Pratique : Utiliser Des Fonctions

Crée une fonction réutilisable :

def calculer_moyenne(notes):
    return sum(notes) / len(notes)

moyenne1 = calculer_moyenne(notes1)
moyenne2 = calculer_moyenne(notes2)
moyenne3 = calculer_moyenne(notes3)

Résultat : ton code est plus court, plus clair et facile à modifier.

Exemple Plus Avancé : Nettoyage De Données

Erreur fréquente : répéter du code pour nettoyer plusieurs colonnes.

df['age'] = df['age'].fillna(df['age'].median())
df['revenu'] = df['revenu'].fillna(df['revenu'].median())
df['score'] = df['score'].fillna(df['score'].median())

Ici aussi, tu dupliques trois fois la même logique.

Avec une fonction :

def imputer_median(df, col):
    df[col] = df[col].fillna(df[col].median())
    return df

for colonne in ['age', 'revenu', 'score']:
    df = imputer_median(df, colonne)

Ton code est plus robuste et facile à réutiliser dans d’autres projets.

Astuce

Donne des noms clairs à tes fonctions (calculer_moyenne, nettoyer_donnees) plutôt que des abréviations obscures.

Ajoute un petit docstring (documentation de fonction) pour expliquer ce que fait ta fonction :

def calculer_moyenne(notes):
    \"\"\"Calcule la moyenne d’une liste de notes numériques.\"\"\"
    return sum(notes) / len(notes)

Conseil De Pro

Même si tu travailles seul·e, prends dès le début l’habitude de structurer ton code. Tu t’y retrouveras mieux, et dans quelques mois tu seras reconnaissant·e envers “le toi du passé” d’avoir laissé un code propre.

6. Copier-Coller Du Code Sans Comprendre

Quand on débute, on passe beaucoup de temps sur Google, Stack Overflow ou ChatGPT (ou autre assistant conversationnel). C’est normal, et c’est même une excellente habitude : les meilleurs développeurs savent chercher des solutions.

Mais l’erreur, c’est de copier-coller du code sans le lire ni le comprendre. Ça peut marcher sur le moment… mais dès qu’un petit détail change dans ton projet, tout casse. Et tu ne sais pas pourquoi.

Exemple D’erreur Classique

Tu veux normaliser tes données avant d’entraîner un modèle et tu trouves ce code :

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Tu le copies, ça fonctionne. Mais tu ne comprends pas la différence entre fit() et transform(). Du coup, quand tu veux appliquer le même traitement sur tes données de test, tu écris :

X_test_scaled = scaler.fit_transform(X_test)

Erreur : tu recalcules les paramètres sur le test, ce qui fausse ton modèle.

Bonne Pratique : Comprendre Avant D’Utiliser

Avant de copier, pose-toi ces questions :

• Qu’est-ce que fait chaque ligne ?
• Puis-je expliquer ce code à quelqu’un en une phrase simple ?
• Quelles sont les hypothèses derrière cette méthode ?

Dans l’exemple précédent, il fallait en réalité écrire :

X_test_scaled = scaler.transform(X_test)

Le fit doit se faire uniquement sur l’entraînement, jamais sur le test.

Astuce

• Lis toujours la documentation officielle (un simple help(nom_fonction) en Python).
• Teste le code avec un mini-exemple avant de l’appliquer sur ton vrai dataset.
• Ajoute un commentaire dans ton notebook pour te rappeler ce que ça fait.

Conseil De Pro

Tu n’as pas besoin de tout comprendre en profondeur immédiatement. Mais essaie toujours de saisir l’intention du code. Même un petit effort de compréhension te fera progresser, et tu éviteras les erreurs bêtes qui bloquent des heures.

7. Négliger La Visualisation Des Données

C’est une erreur classique : vouloir “faire tourner un modèle” le plus vite possible, sans regarder ses données. Pourtant, la visualisation est l’étape clé qui te permet de comprendre ton dataset avant toute analyse ou modélisation.

Sans elle, tu passes à côté de tendances, de corrélations ou d’anomalies… et tu risques de tirer de mauvaises conclusions.

Exemple 1 – Détecter Une Anomalie

Tu as une colonne revenu :

df['revenu'].describe()

Tout semble normal : moyenne autour de 2 500 €.

Mais si tu fais un simple boxplot :

import seaborn as sns
sns.boxplot(x=df['revenu'])

Tu découvres qu’une valeur est à 250 000 €, probablement une erreur de saisie. Sans ce graphique, tu ne l’aurais peut-être jamais remarqué.

Outils Essentiels

• Matplotlib & Seaborn : pour explorer rapidement tes données avec des histogrammes, scatterplots, boxplots…

Astuce

Commence toujours ton analyse par un EDA (Exploratory Data Analysis) simple :

• Histogramme des variables numériques.
• Compte des valeurs pour les variables catégorielles.
• Matrice de corrélation.

Tu n’as pas besoin de dizaines de graphes : trois ou quatre bien choisis peuvent déjà te donner des informations précieuses.

Conseil De Pro

Ne vois pas la visualisation comme une étape “secondaire”. C’est un peu comme prendre une carte avant de partir en randonnée : sans elle, tu avances… mais tu ne sais pas où tu vas. Prends ce temps d’exploration : tu éviteras beaucoup d’erreurs ensuite, et tu gagneras en confiance dans tes analyses.

8. Sur-Apprendre (Overfitting) Sans Validation Croisée

L’overfitting (ou sur-apprentissage) est l’un des pièges les plus courants en machine learning. C’est quand ton modèle “apprend par cœur” les données d’entraînement au lieu de comprendre les tendances générales. Résultat : il est excellent sur ton jeu d’entraînement… mais catastrophique dès qu’il voit de nouvelles données.

Exemple – Prédire Les Revenus

Imaginons que tu crées un modèle pour prédire le revenu des personnes selon leur âge et leur niveau d’études.

Tu entraînes une régression trop complexe (ou un arbre trop profond). Résultat :

• Sur l’entraînement : 98 % de précision.
• Sur le test : 55 % seulement.

Ton modèle a retenu les “détails” et les valeurs aberrantes de l’entraînement, mais il est incapable de généraliser.

Solution : La Validation Croisée

Plutôt que de te fier à un seul découpage entraînement/test, utilise la validation croisée.
Avec Scikit-learn :

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LinearRegression

model = LinearRegression()
scores = cross_val_score(model, X, y, cv=5)

print(scores)
print("Score moyen :", scores.mean())

Ici, ton dataset est découpé en 5 parties. Le modèle est entraîné et testé 5 fois, sur des portions différentes.
Résultat : tu obtiens un score plus fiable, qui reflète la vraie performance de ton modèle.

Astuce

• Commence simple : un modèle simple mais robuste vaut mieux qu’un modèle compliqué qui sur-apprend.
• Règle d’or : toujours valider ton modèle avec plusieurs échantillons différents.
• Tu peux aussi tester des techniques comme la régularisation (Ridge, Lasso) ou le dropout (en deep learning) pour limiter l’overfitting.

Conseil De Pro

Ne sois pas impressionné·e par un modèle qui affiche 99 % de précision à l’entraînement. Au contraire, sois méfiant·e : c’est souvent le signe d’un modèle qui sur-apprend. Le vrai bon modèle, c’est celui qui garde des performances solides même sur des données qu’il n’a jamais vues.

9. Utiliser Jupyter Sans Versionner Son Code

Jupyter Notebook est un outil génial pour expérimenter, tester des idées et explorer des données. Mais beaucoup de débutants tombent dans un piège : ne pas versionner leur travail. Résultat : on se retrouve avec des fichiers aux noms improbables :

analyse.ipynb  
analyse_final.ipynb  
analyse_final2.ipynb  
analyse_final_version_corrigée.ipynb  

Tu t’y reconnais peut-être ? Très vite, on ne sait plus lequel est le bon. Et si tu veux revenir en arrière, c’est presque impossible.

Exemple Concret – Le Notebook Qui Devient Ingérable

Tu analyses des données clients et tu testes plusieurs approches. Au lieu de garder un suivi clair, tu dupliques ton fichier à chaque essai.
Après quelques jours, tu as 8 notebooks différents… mais aucun commentaire, aucun suivi, et tu as perdu la trace de ce qui marchait vraiment.

Imagine maintenant que tu sois en équipe : impossible de collaborer correctement. Tes collègues ne savent pas quelle version utiliser.

Bonne Pratique : Utiliser Git Et GitHub

Versionner son code avec Git change tout :

• Chaque modification est enregistrée avec un message clair.
• Tu peux revenir en arrière facilement si une idée ne fonctionne pas.
• Tu peux collaborer avec d’autres sans écraser leur travail.

Un flux de travail simple :

git init
git add .
git commit -m "Ajout de l'analyse exploratoire"
git push origin main

En quelques commandes, tu as une version claire et sauvegardée de ton notebook.

Astuce

• Utilise GitHub ou GitLab pour héberger tes projets.
• Garde tes notebooks pour l’exploration et mets ton code “propre” dans des scripts .py bien organisés.
• Ajoute un README.md qui explique le but du projet et les étapes pour le reproduire.

Conseil De Pro

Même si tu travailles seul·e, prends l’habitude de versionner ton code. Ce n’est pas du temps perdu, au contraire : c’est une sécurité, une clarté, et une preuve de professionnalisme que tu pourras montrer sur ton portfolio GitHub

10. Ne Pas Documenter Ni Commenter

Un code sans explications, c’est comme une carte sans légende : inutilisable. Sur le moment, tu crois que tu t’en souviendras… mais quelques semaines plus tard, tu relis ton notebook et tu ne comprends plus ce que tu avais voulu faire.

C’est frustrant, et encore pire si quelqu’un d’autre doit reprendre ton travail.

Exemple Concret – Le Code Incompréhensible

Tu trouves ce bout de code dans ton ancien projet :

df2 = df1[df1['x'] > 10]
df3 = df2.groupby('cat').mean()
df3.to_csv('result.csv')

Sur le moment, tu savais très bien ce que signifiait x ou cat. Mais deux mois plus tard, tu ne sais plus à quoi ces variables correspondent. Ton futur toi est bloqué… et doit ré-analyser le dataset pour comprendre.

Bonne Pratique : Commenter Et Documenter

Avec des commentaires clairs, le même code devient compréhensible :

# Filtrer les lignes où la variable 'x' est supérieure à 10
df2 = df1[df1['x'] > 10]

# Calculer la moyenne par catégorie
df3 = df2.groupby('cat').mean()

# Sauvegarder les résultats dans un fichier CSV
df3.to_csv('result.csv')

En quelques mots, tu rends ton code lisible pour toi et pour les autres.

Astuce

• Commente l’intention, pas l’évidence.
  • Mauvais : i = i + 1 # incrémente i de 1
  • Bon : i = i + 1 # avancer d’un pas dans la boucle de recherche
• Ajoute un README.md dans chaque projet pour expliquer :
  • le but du projet,
  • les étapes pour l’exécuter,
  • les dépendances nécessaires.

Conseil De Pro

Documenter ton code, ce n’est pas une corvée : c’est un cadeau que tu fais à ton futur toi (et à ton équipe). Crois-moi, sur parole et par exéprience, dans 6 mois, tu seras reconnaissant·e d’avoir pris 5 minutes pour ajouter un commentaire ou écrire un petit README.

Ressources Pour Apprendre

• Cours en ligne : Je te propose aussi mes deux formations vidéo de 8h sur Udemy : R pour la Data Science et Python pour la Data Science. On y retrouve toutes ces erreurs fréquentes, expliquées pas à pas avec des exercices pratiques, pour t’aider à progresser et à construire de vraies compétences de Data Scientist.
• Livres : Si tu aimes apprendre avec un support écrit, découvre mon livre « Python pour la Data Science » (éditions ENI). C’est le guide que j’aurais aimé avoir à mes débuts : clair, pratique et pensé pour t’accompagner pas à pas.
• Tu veux savoir comment organiser ton apprentissage pour éviter ces erreurs et progresser efficacement en Data Science ? Je t’ai préparé une roadmap complète dans cet article : Apprendre la Data Science en 2025 : roadmap et étapes clés

Conclusion – Transformer Ses Erreurs En Apprentissage Durable

Faire des erreurs en Python, ce n’est pas un échec. C’est au contraire une étape normale, presque obligatoire, dans l’apprentissage. Chaque bug, chaque blocage est une chance d’apprendre un peu plus et de progresser.

L’essentiel, c’est de ne pas les subir mais de les transformer en opportunités d’apprentissage.

En adoptant de bonnes pratiques — vérifier tes données, commenter ton code, versionner tes projets, prendre le temps de comprendre tes erreurs — tu avanceras plus vite et tu gagneras en confiance.

Avec cette approche, tu ne seras pas seulement un·e meilleur·e codeur·se, mais aussi un·e data scientist plus solide, capable d’apprendre en continu.

FAQ – Erreurs Python En Data Science

1. Quelle est l’erreur la plus courante chez les débutants en Python ?
Oublier d’importer les librairies ou mal gérer les types de variables.

2. Comment éviter l’overfitting en machine learning ?
Utiliser la validation croisée et des techniques comme la régularisation ou le dropout.

3. Est-il obligatoire d’apprendre Git quand on fait de la Data Science ?
Oui, car la version de code est essentielle en projet collaboratif.

4. Pourquoi la visualisation est-elle si importante ?
Elle permet de mieux comprendre ses données et d’éviter des erreurs d’interprétation.

5. Peut-on se passer de R si on apprend Python pour la Data Science ?
Oui, mais R reste très utile pour la statistique et la recherche.

6. Quelle est la meilleure manière d’apprendre Python sans copier-coller du code ?
Pratiquer avec des petits projets personnels et expliquer son code à voix haute ou dans un blog.