Erreurs et Exceptions en Python

Introduction

Dans ce laboratoire, vous acquerrez une compréhension pratique des erreurs et des exceptions en Python. Nous explorerons comment identifier les erreurs de syntaxe courantes qui empêchent l'exécution du code, reconnaître les différents types d'exceptions qui surviennent pendant l'exécution (runtime), et différencier clairement ces deux concepts fondamentaux de la programmation Python.

Grâce à des exercices pratiques, vous apprendrez à repérer et à corriger des problèmes tels qu'une indentation incorrecte, des éléments de syntaxe manquants et d'autres pièges courants, afin de bâtir une base solide pour écrire un code Python robuste et sans erreur.

Identifier les Erreurs de Syntaxe

Dans cette étape, nous allons explorer les erreurs de syntaxe courantes en Python. Les erreurs de syntaxe se produisent lorsque le code viole les règles grammaticales du langage, empêchant l'interpréteur de comprendre et d'exécuter le code. Ces erreurs sont détectées avant même que le programme ne commence à s'exécuter.

Le fichier nécessaire syntax_errors.py a été créé pour vous dans le répertoire ~/project.

Commençons par introduire une IndentationError. Ouvrez syntax_errors.py depuis l'explorateur de fichiers situé sur le côté gauche du WebIDE. Ajoutez le code suivant, qui contient une indentation incorrecte :

for i in range(5):
    print(i)
  print("This line has incorrect indentation")

Enregistrez le fichier. Ouvrez ensuite le terminal intégré et exécutez le script :

python syntax_errors.py

Vous verrez une IndentationError. L'interpréteur Python s'attend à ce que les blocs de code (comme celui à l'intérieur d'une boucle for) aient un niveau d'indentation cohérent.

  File "/home/labex/project/syntax_errors.py", line 3
    print("This line has incorrect indentation")
                                                ^
IndentationError: unindent does not match any outer indentation level

Maintenant, corrigeons l'indentation mais introduisons une SyntaxError différente. Modifiez le code dans syntax_errors.py comme suit. Remarquez le deux-points (:) manquant à la fin de la première ligne.

for i in range(5)
    print(i)
    print("This line has correct indentation")

Enregistrez le fichier et exécutez-le à nouveau depuis le terminal :

python syntax_errors.py

Cette fois, vous obtiendrez une SyntaxError. L'instruction de boucle for en Python nécessite un deux-points à la fin pour signaler le début d'un bloc de code.

  File "/home/labex/project/syntax_errors.py", line 1
    for i in range(5)
                     ^
SyntaxError: expected ':'

Enfin, corrigeons le deux-points mais introduisons une autre SyntaxError courante : une chaîne de caractères non terminée (unterminated string). Modifiez le fichier syntax_errors.py comme suit. La chaîne "hello' commence par un guillemet double mais se termine par un guillemet simple.

for i in range(5):
    print("hello')

Enregistrez le fichier et exécutez-le :

python syntax_errors.py

Vous rencontrerez une SyntaxError car la chaîne de caractères n'a pas été correctement fermée avec un guillemet correspondant.

  File "/home/labex/project/syntax_errors.py", line 2
    print("hello')
          ^
SyntaxError: unterminated string literal (detected at line 2)

Ces exemples illustrent que les erreurs de syntaxe doivent être corrigées avant que votre programme ne puisse s'exécuter. Faites toujours très attention à l'indentation, aux symboles requis comme les deux-points, et aux guillemets correspondants.

Reconnaître les Exceptions Courantes

Dans cette étape, nous allons explorer les exceptions courantes. Contrairement aux erreurs de syntaxe, les exceptions se produisent pendant l'exécution du programme. Le code est syntaxiquement correct, mais une erreur survient pendant son exécution.

Le fichier common_exceptions.py est prêt pour vous dans le répertoire ~/project.

Tout d'abord, provoquons une ZeroDivisionError. Ouvrez common_exceptions.py dans l'éditeur et ajoutez le code suivant :

numerator = 10
denominator = 0
result = numerator / denominator
print(result)

Enregistrez le fichier et exécutez-le depuis le terminal :

python common_exceptions.py

Le programme commence à s'exécuter mais s'arrête et affiche une ZeroDivisionError. Mathématiquement, la division par zéro est indéfinie, et Python lève cette exception pour signaler le problème.

Traceback (most recent call last):
  File "/home/labex/project/common_exceptions.py", line 3, in <module>
    result = numerator / denominator
ZeroDivisionError: division by zero

Ensuite, déclenchons une NameError. Cela se produit lorsque vous essayez d'utiliser une variable qui n'a pas encore été définie. Remplacez le contenu de common_exceptions.py par ce qui suit :

print(undefined_variable)

Enregistrez le fichier et exécutez-le :

python common_exceptions.py

Vous obtiendrez une NameError car l'interpréteur ne sait pas à quoi se réfère undefined_variable.

Traceback (most recent call last):
  File "/home/labex/project/common_exceptions.py", line 1, in <module>
    print(undefined_variable)
NameError: name 'undefined_variable' is not defined

Voyons maintenant une TypeError. Cela se produit lorsque vous essayez d'effectuer une opération sur un objet d'un type inapproprié. Remplacez le contenu de common_exceptions.py par ce code :

print("Hello" + 5)

Enregistrez et exécutez le script :

python common_exceptions.py

Vous verrez une TypeError. Python ne vous permet pas d'additionner (+) directement une chaîne de caractères (string) et un entier (integer).

Traceback (most recent call last):
  File "/home/labex/project/common_exceptions.py", line 1, in <module>
    print("Hello" + 5)
TypeError: can only concatenate str (not "int") to str

Enfin, démontrons une IndexError. Cela se produit lorsque vous essayez d'accéder à un élément d'une séquence (comme une liste) en utilisant un index qui est hors limites. Remplacez le contenu de common_exceptions.py par ce qui suit :

my_list = [1, 2, 3]
print(my_list[5])

Enregistrez et exécutez le script :

python common_exceptions.py

Vous obtiendrez une IndexError. La liste my_list contient trois éléments, ses indices valides sont donc 0, 1 et 2. Accéder à l'index 5 n'est pas possible.

Traceback (most recent call last):
  File "/home/labex/project/common_exceptions.py", line 2, in <module>
    print(my_list[5])
IndexError: list index out of range

Comprendre ces exceptions courantes est une partie essentielle de l'apprentissage du débogage de code Python.

Différencier les Erreurs et les Exceptions

Dans cette dernière étape, nous allons clairement distinguer les erreurs de syntaxe et les exceptions. Cette distinction est fondamentale pour la programmation et le débogage en Python.

Erreurs de Syntaxe (ou Erreurs d'Analyse Syntaxique - Parsing Errors) :

• Ce sont des erreurs dans la structure de votre code qui violent les règles de Python.
• L'interpréteur Python trouve ces erreurs avant que votre programme ne commence à s'exécuter.
• Un programme contenant une erreur de syntaxe ne peut pas être exécuté du tout.
• Exemples : IndentationError, deux-points manquants, parenthèses ou guillemets non appariés.

Exceptions (ou Erreurs d'Exécution - Runtime Errors) :

• Ces erreurs se produisent pendant l'exécution d'un programme syntaxiquement correct.
• Elles surviennent lorsque le programme rencontre une situation inattendue, comme la division par zéro ou l'accès à un fichier inexistant.
• Si elles ne sont pas gérées, une exception provoquera le crash de votre programme et l'affichage d'une trace d'erreur (traceback).
• Exemples : ZeroDivisionError, NameError, TypeError, IndexError.

Voyons cela en action. Ouvrez le fichier error_vs_exception.py depuis l'explorateur de fichiers. Ajoutez le code suivant, qui contient à la fois une erreur de syntaxe (un deux-points manquant) et une ligne qui provoquera une exception d'exécution.

## This line has a syntax error (missing colon)
for i in range(5)
    print(i)

## This line will cause an exception (division by zero)
result = 10 / 0
print(result)

Enregistrez le fichier et essayez de l'exécuter :

python error_vs_exception.py

Remarquez que vous obtenez immédiatement une SyntaxError. L'interpréteur vérifie la syntaxe correcte de l'ensemble du fichier avant d'exécuter quoi que ce soit. Il trouve le deux-points manquant et s'arrête, sans jamais atteindre la ligne contenant 10 / 0.

  File "/home/labex/project/error_vs_exception.py", line 2
    for i in range(5)
                     ^
SyntaxError: expected ':'

Maintenant, corrigeons l'erreur de syntaxe. Ajoutez le deux-points manquant à la ligne de la boucle for dans error_vs_exception.py :

## The syntax error is now fixed
for i in range(5):
    print(i)

## This line will cause an exception (division by zero)
result = 10 / 0
print(result)

Enregistrez le fichier et exécutez-le à nouveau :

python error_vs_exception.py

Cette fois, le programme est syntaxiquement correct, il commence donc à s'exécuter. La boucle for s'exécute et affiche les nombres de 0 à 4. Ensuite, lorsque le programme tente d'exécuter result = 10 / 0, il rencontre un problème d'exécution et lève une ZeroDivisionError, provoquant le crash du programme.

0
1
2
3
4
Traceback (most recent call last):
  File "/home/labex/project/error_vs_exception.py", line 6, in <module>
    result = 10 / 0
ZeroDivisionError: division by zero

Ceci démontre clairement que les erreurs de syntaxe empêchent l'exécution, tandis que les exceptions surviennent pendant l'exécution. Dans les laboratoires futurs, vous apprendrez comment gérer les exceptions de manière élégante pour éviter qu'elles ne fassent planter votre programme.

Résumé

Dans ce laboratoire, vous avez appris la différence fondamentale entre les erreurs et les exceptions en Python. Vous avez commencé par identifier et corriger des erreurs de syntaxe courantes, telles que IndentationError et SyntaxError dues à un deux-points manquant, comprenant que celles-ci empêchent un programme de s'exécuter.

Ensuite, vous avez exploré plusieurs exceptions d'exécution courantes, notamment ZeroDivisionError, NameError, TypeError et IndexError. Vous avez vu comment ces exceptions se produisent dans un code syntaxiquement correct lorsqu'une opération échoue pendant l'exécution. Enfin, vous avez consolidé votre compréhension en observant comment l'interpréteur Python traite un fichier contenant à la fois une erreur de syntaxe et une exception potentielle, prouvant que la syntaxe est vérifiée avant le début de l'exécution. Cette connaissance fournit une base cruciale pour écrire et déboguer des applications Python.