Comment faire pour ne plus avoir d'IndentationError ?

Configure ton éditeur de code pour qu'il utilise 4 espaces à chaque fois que tu appuies sur la touche Tab. Cela garantit une indentation cohérente. Évite absolument de mélanger espaces et tabulations dans un même fichier.

Mon code ne plante pas mais donne un mauvais résultat. Comment trouver l'erreur ?

C'est une erreur de logique (ou "bug"). Utilise la méthode des `print()` pour afficher les valeurs de tes variables clés à différentes étapes. Compare ce que tu obtiens avec ce que tu attends. Le débogueur de ton éditeur est aussi parfait pour suivre l'exécution ligne par ligne.

Quelle est la différence entre `=` et `==` en Python ?

C'est fondamental ! Le signe `=` est l'opérateur d'**affectation** : il stocke une valeur dans une variable (ex: `x = 5`). Le double signe `==` est l'opérateur de **comparaison** : il teste si deux valeurs sont égales et renvoie `True` ou `False` (ex: `if x == 5:`). Les confondre est une source très fréquente d'erreurs.

Les erreurs Python les plus frequentes et comment les corriger

Introduction : L'erreur, ton meilleur professeur en programmation

Si tu es en train d'apprendre Python en spécialité NSI, tu as déjà dû rencontrer ces messages rouges énigmatiques qui s'affichent dans ton terminal. Ne t'inquiète pas, c'est le lot de tous les programmeurs, des débutants aux experts ! Une erreur n'est pas un échec, mais un signal que ton code a besoin d'attention. Dans cet article, nous allons décortiquer ensemble les 10 erreurs les plus fréquentes en Python, comprendre ce qu'elles signifient et, surtout, apprendre à les corriger. Maîtriser le débogage (debugging) est une compétence essentielle pour réussir en NSI et au-delà.

1. Les erreurs de syntaxe : quand Python ne comprend pas la structure

Les erreurs de syntaxe sont les premières que tu rencontres. Python lit ton code comme une langue et, si la grammaire est incorrecte, il ne peut pas l'exécuter.

SyntaxError : la faute de frappe classique

Cette erreur survient lorsque tu oublies un caractère essentiel. L'exemple le plus courant ? Oublier le deux-points (:) après une instruction comme if, for, def ou while.

Code erroné : if x > 5 print("Grand")
Message d'erreur : SyntaxError: expected ':'
Correction : if x > 5: print("Grand")

Autres coupables fréquents : les parenthèses, crochets ou guillemets non fermés. Pour les éviter, utilise un éditeur de code coloré (comme VS Code ou Thonny) qui te signalera souvent ces problèmes.

IndentationError : le piège de l'indentation

En Python, l'indentation (les espaces ou tabulations en début de ligne) n'est pas juste pour la lisibilité, elle fait partie de la syntaxe. Elle définit les blocs de code.

Code erroné :
def ma_fonction(): print("Bonjour") # Pas d'indentation après la définition return True # Indentation incohérente
Correction : Utilise soit 4 espaces (recommandé), soit une tabulation, mais sois constant dans tout ton script.

2. Les erreurs d'exécution : quand le code a une logique mais plante à l'utilisation

Contrairement aux erreurs de syntaxe, ces erreurs apparaissent quand ton code est exécuté. La structure est correcte, mais une opération spécifique échoue.

NameError : "Cette variable, je ne la connais pas !"

Python te dit qu'il ne reconnaît pas le nom que tu utilises. Cela arrive généralement pour trois raisons :

Variable non définie : Tu utilises un nom avant de lui donner une valeur.
print(ma_variable) # Erreur si ma_variable n'a pas été définie avant.
Faute de frappe : nonbre au lieu de nombre.
Variable hors de portée : Tu essaies d'accéder, depuis l'extérieur d'une fonction, à une variable définie à l'intérieur de celle-ci.

Solution : Vérifie l'orthographe et assure-toi que la variable est bien définie dans la portée (scope) où tu l'utilises.

TypeError : "Je ne peux pas mélanger ces types !"

Python est un langage à typage fort : tu ne peux pas effectuer certaines opérations entre des types de données incompatibles.

Exemple classique : resultat = "Votre note est : " + 15
Message : TypeError: can only concatenate str (not "int") to str
Correction : Convertis le nombre en chaîne avec str() : resultat = "Votre note est : " + str(15)

Autre cas fréquent : appeler une fonction avec un mauvais nombre d'arguments ou utiliser un objet non appelable (comme un entier) comme une fonction.

IndexError et KeyError : les pièges des collections

IndexError : Tu essaies d'accéder à un index qui n'existe pas dans une liste ou un tuple.
ma_liste = [1, 2, 3] print(ma_liste[5]) # IndexError : l'index 5 est hors de la liste (qui va de 0 à 2).
KeyError : Tu essaies d'accéder à une clé qui n'existe pas dans un dictionnaire.
mon_dict = {"nom": "Alice"} print(mon_dict["prenom"]) # KeyError : la clé "prenom" n'existe pas.

Solution : Pour les listes, vérifie la longueur avec len() avant d'accéder à un index. Pour les dictionnaires, utilise la méthode .get() qui renvoie None (ou une valeur par défaut) si la clé est absente : mon_dict.get("prenom", "Clé inconnue").

ZeroDivisionError : la division interdite

Assez explicite : tu as essayé de diviser un nombre par zéro. resultat = 10 / 0. Solution : Ajoute une condition pour vérifier que le dénominateur n'est pas zéro avant de diviser.

3. Les erreurs de sémantique : le code tourne... mais fait n'importe quoi

Ce sont les erreurs les plus subtiles. Aucun message rouge n'apparaît, mais le résultat n'est pas celui attendu. Le programme fait quelque chose de différent de ce que tu avais prévu.

Problèmes de logique et de conditions

Un classique : utiliser l'opérateur d'affectation (=) au lieu de l'opérateur de comparaison (==) dans une condition.

Code erroné : if note = 20: print("Parfait!") (Cela affecte 20 à `note`, et la condition est toujours vraie !)
Correction : if note == 20: print("Parfait!")

Autre piège : les conditions composées mal formulées. Pour vérifier qu'un nombre x est entre 5 et 10, il faut écrire if 5 < x < 10 ou if x > 5 and x < 10. if 5 < x or x < 10 est toujours vrai !

Modification d'une liste pendant son parcours

Cette erreur peut provoquer des comportements imprévisibles ou une RuntimeError.

Code risqué :
liste = [1, 2, 3, 4, 5] for element in liste: if element % 2 == 0: liste.remove(element) # Modifie la liste pendant l'itération !
Solution sûre : Crée une nouvelle liste ou itère sur une copie :
for element in liste[:]: # [:] crée une copie if element % 2 == 0: liste.remove(element)
Ou mieux, utilise une compréhension de liste : liste = [x for x in liste if x % 2 != 0]

4. Ta boîte à outils pour déboguer comme un pro

Maintenant que tu connais les erreurs, voici comment les traiter efficacement.

Lire le message d'erreur (vraiment !)

Le message d'erreur n'est pas là pour faire joli. Il te donne :
1. Le type d'erreur (ex: TypeError).
2. Un message descriptif (ex: "can only concatenate str...").
3. La trace d'exécution (Traceback) : la liste des appels de fonctions qui ont mené à l'erreur, avec le numéro de ligne du fichier concerné. C'est ta piste principale !

Techniques de débogage manuel

La méthode des print() stratégiques : Ajoute print() pour afficher la valeur des variables à différents endroits et voir où elle change ou devient incorrecte.
Utiliser le débogueur intégré : Les bons éditeurs (VS Code, PyCharm) ont un débogueur visuel. Tu peux poser des points d'arrêt (breakpoints) pour suspendre l'exécution et inspecter l'état du programme.
Isoler le problème : Si ton code est long, essaie de reproduire l'erreur avec un extrait minimal. Cela t'aide à identifier la cause racine.

Écrire un code plus robuste

Anticipe les erreurs avec :
- Des vérifications (if) avant des opérations risquées (division, accès à un index).
- La gestion d'exceptions avec try...except pour les erreurs que tu ne peux pas éviter (ex: lire un fichier qui n'existe pas).
- Des noms de variables clairs et explicites pour éviter les confusions.

Conclusion : De la frustration à la maîtrise

Rencontrer des erreurs est inévitable et c'est même le signe que tu es en train d'apprendre et de pousser tes limites. Chaque message d'erreur résolu est une compétence acquise. Au lieu de les redouter, apprends à les décrypter. Elles sont les gardiennes de la logique et de la robustesse de ton code. En NSI, et dans tous tes projets futurs, ta capacité à déboguer efficacement sera aussi importante que ta capacité à écrire du nouveau code. Alors, la prochaine fois que Python te lance un message rouge, souris et dis-toi : "Ah, un nouvel indice pour m'améliorer !".