Gestion des exceptions et des erreurs en Python

Les erreurs et les exceptions peuvent entraîner un comportement inattendu, voire empêcher l'exécution d'un programme. Python propose diverses fonctions et mécanismes pour gérer ces problèmes et améliorer la robustesse du code. Dans ce tutoriel, nous apprendrons à connaître les différents types d'erreurs et les fonctions intégrées à l'aide d'exemples. 

Une erreur est un problème dans un programme qui l'empêche d'accomplir sa tâche. Par comparaison, une exception est une condition qui interrompt le déroulement normal du programme. Les erreurs et les exceptions sont un type d'erreur d'exécution, ce qui signifie qu'elles se produisent pendant l'exécution d'un programme. 

En d'autres termes, l'erreur est un problème critique qu'une application normale ne doit pas détecter, tandis que l'exception est une condition qu'un programme doit détecter. 

Nous allons en apprendre davantage sur les erreurs et les exceptions en examinant divers exemples. Pour les exécuter facilement, vous pouvez créer gratuitement un classeur DataLab dans lequel Python est préinstallé et qui contient tous les échantillons de code.

Erreurs dans Python

Voici un exemple d'erreur de syntaxe où un retour en dehors de la fonction ne signifie rien. Nous ne devons pas traiter les erreurs dans un programme. Au lieu de cela, nous devons créer une fonction qui renvoie la chaîne de caractères. 

return "DataCamp"

Input In [1]
    return "DataCamp"
    ^
SyntaxError: 'return' outside function

Nous avons créé la fonction, mais avec une indentation incorrecte. Nous ne devrions pas gérer les erreurs d'indentation au moment de l'exécution. Nous pouvons le faire manuellement ou utiliser des outils de formatage de code.

def fun():
return "DataCamp"    

Input In [2]
    return "DataCamp"
    ^
IndentationError: expected an indented block

Exceptions en Python

Nous avons rencontré une ZeroDivisionError (Exception). Nous pouvons le gérer au moment de l'exécution en utilisant les blocs try et except.

test = 1/0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Input In [4], in <cell line: 1>()
----> 1 test = 1/0

ZeroDivisionError: division by zero

NameError Les exceptions sont assez fréquentes lorsqu'une variable n'est pas trouvée. Nous pouvons également gérer l'exception en remplaçant la variable ou en imprimant l'avertissement. 

y = test

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Input In [5], in <cell line: 1>()
----> 1 y = test

NameError

Exceptions intégrées à Python

Voici la liste des exceptions par défaut de Python avec leur description :

1. AssertionError: levée lorsque l'instruction assert échoue.
2. EOFError: levée lorsque la fonction input() rencontre la condition de fin de fichier.
3. AttributeError: levée en cas d'échec de l'attribution ou de la référence d'un attribut.
4. TabError: elle se manifeste lorsque les retraits sont constitués de tabulations ou d'espaces incohérents. 
5. ImportError: levée en cas d'échec de l'importation du module. 
6. IndexError: se produit lorsque l'index d'une séquence est en dehors de la plage.
7. KeyboardInterruptLe message d'alerte est le suivant : il est levé lorsque l'utilisateur introduit des touches d'interruption (Ctrl + C ou Suppr).
8. RuntimeErrorL'erreur d'interprétation : il s'agit d'une erreur qui n'entre dans aucune catégorie. 
9. NameError: levée lorsqu'une variable n'est pas trouvée dans le champ d'application local ou global. 
10. MemoryError: elle est déclenchée lorsque les programmes manquent de mémoire. 
11. ValueErrorL'opération ou la fonction reçoit un argument du bon type mais de la mauvaise valeur. 
12. ZeroDivisionError: soulevée lorsque vous divisez une valeur ou une variable par zéro. 
13. SyntaxError: soulevée par l'analyseur syntaxique lorsque la syntaxe Python n'est pas correcte. 
14. IndentationError: se produit lorsqu'il y a une indentation incorrecte.
15. SystemError: levée lorsque l'interprète détecte une erreur interne.

Vous trouverez une liste complète des erreurs et exceptions en Python en lisant la documentation. 

Apprenez à connaître les exceptions Python en suivant notre cours Programmation orientée objet en Python. Il vous apprendra à créer des classes et à tirer parti de l'héritage et du polymorphisme pour réutiliser et optimiser le code.

Traitement des exceptions avec try, except, else et finally

Après avoir découvert les erreurs et les exceptions, nous apprendrons à les gérer en utilisant les blocs try, except, else et finally. 

Qu'entendons-nous donc par les traiter ? Dans des circonstances normales, ces erreurs interrompent l'exécution du code et affichent le message d'erreur. Pour créer des systèmes stables, nous devons anticiper ces erreurs et proposer des solutions alternatives ou des messages d'avertissement. 

Dans cette section, nous verrons ce que fait chaque bloc et comment nous pouvons les utiliser pour écrire un code robuste. 

L'instruction try et except 

La manière la plus simple de gérer les exceptions en Python consiste à utiliser les blocs try et except.  

1. Exécutez le code sous la déclaration try.
2. Lorsqu'une exception est levée, exécutez le code sous l'instruction except. 

Au lieu de s'arrêter à une erreur ou à une exception, notre code s'orientera vers des solutions alternatives. 

Exemple simple

Dans le premier exemple, nous allons essayer d'imprimer la variable indéfinie x. Dans des circonstances normales, l'erreur devrait être levée et l'exécution arrêtée, mais avec les blocs try et except, nous pouvons modifier le comportement du flux. 

• Le programme exécutera le code sous l'instruction try. 
• Comme nous le savons, x n'est pas défini, donc l'instruction except sera exécutée et l'avertissement sera imprimé.

try:
   print(x)
except:
   print("An exception has occurred!")

An exception has occurred!

Exemple de déclaration d'exceptions multiples

Dans le deuxième exemple, nous utiliserons plusieurs instructions except pour gérer plusieurs types d'exceptions.

•  Si une exception ZeroDivisionError est levée, le programme imprimera "Vous ne pouvez pas diviser une valeur par zéro".
• Les autres exceptions afficheront "Quelque chose d'autre n'a pas fonctionné".

Il nous permet d'écrire un code flexible qui peut gérer plusieurs exceptions à la fois sans se casser la figure. 

try:
   print(1/0)
except ZeroDivisionError:
   print("You cannot divide a value with zero")
except:
   print("Something else went wrong")

You cannot divide a value with zero

Chargement du fichier exemple

Prenons maintenant un exemple plus concret. 

Dans le code ci-dessous, nous lisons le fichier CSV et, lorsqu'il soulève l'exception FileNotFoundError, le code affiche l'erreur et un message supplémentaire concernant le fichier data.csv. 

Oui, nous pouvons imprimer des messages d'erreur par défaut sans interrompre l'exécution. 

try:
   with open('data.csv') as file:
       read_data = file.read()
except FileNotFoundError as fnf_error:
   print(fnf_error)
   print("Explanation: We cannot load the 'data.csv' file")

[Errno 2] No such file or directory: 'data.csv'
Explanation: We cannot load the 'data.csv' file

L'essai avec la clause else

Nous avons appris ce qu'étaient try et except, et nous allons maintenant apprendre ce qu'est la déclaration else.

Lorsque l'instruction try ne soulève pas d'exception, le code entre dans le bloc else. Il s'agit d'une solution ou d'une option de repli lorsque vous vous attendez à ce qu'une partie de votre script produise une exception. Elle est généralement utilisée dans une brève section d'installation ou de vérification où vous ne voulez pas que certaines erreurs se cachent. 

Note : Dans le bloc try-except, vous pouvez utiliser else après toutes les déclarations except. 

Exemple simple

Nous ajoutons la déclaration else à l'exemple ZeroDivisionError. Comme nous pouvons le voir, lorsqu'il n'y a pas d'exception, la fonction print sous l'instruction else est exécutée, affichant le résultat. 

try:
   result = 1/3
except ZeroDivisionError as err:
   print(err)
else:
   print(f"Your answer is {result}")

Your answer is 0.3333333333333333

IndexError avec l'exemple else

Pour en savoir plus, créons une fonction simple et testons-la dans différents scénarios. 

La fonction find_nth_value() a pour arguments x (liste) et n (numéro d'index). Nous avons créé les blocs try, except et else pour gérer l'exception IndexError. 

x = [5,8,9,13]

def find_nth_value(x,n):
    try:
        result = x[n]
    except IndexError as err:
        print(err)
    else:
        print("Your answer is ", result)

La liste x a quatre valeurs, et nous les testerons pour les index 6 et 2. 

# Testing
find_nth_value(x,6)
find_nth_value(x,2)

• À n=6, l'exception IndexError a été levée et nous avons pu voir le message d'erreur par défaut "list index out of range". 
• À n=2, aucune exception n'a été soulevée et la fonction a imprimé le résultat qui se trouve sous l'instruction else. 

list index out of range
Your answer is  9

Le mot-clé finally en Python

Le mot-clé finally dans le bloc try-except est toujours exécuté, qu'il y ait ou non une exception. En d'autres termes, le bloc de code finally est exécuté après que les blocs try, except et else sont terminés. Il est très utile pour nettoyer les ressources et fermer l'objet, en particulier pour fermer les fichiers.

La fonction divide est créée pour gérer les exceptions ZeroDivisionError et afficher le résultat lorsqu'il n'y a pas d'exception. Quel que soit le résultat, l'application finally imprimera toujours "Code by DataCamp" en vert.

def divide(x,y):
    try:
        result = x/y
    except ZeroDivisionError:
        print("Please change 'y' argument to non-zero value")
    except:
        print("Something went wrong")
    else:
        print(f"Your answer is {result}")
    finally:
        print("\033[92m Code by DataCamp\033[00m")

Dans le premier test, nous divisons 1 par 0, ce qui devrait soulever l'exception ZeroDivisionError et imprimer le message. Comme nous pouvons le voir, nous avons une ligne supplémentaire après le message d'erreur. 

divide(1,0)

Please change 'y' argument to non-zero value
 Code by DataCamp

Lorsque nous ajoutons une entrée valide, il affiche le résultat en exécutant les blocages else et finally.

divide(3,4)

Your answer is 0.75
 Code by DataCamp

Au lieu d'un entier, nous avons ajouté une chaîne de caractères comme deuxième argument, ce qui a soulevé une exception, différente de ZeroDivisionError, avec un message différent. 

divide(1,'g')

Something went wrong
 Code by DataCamp

Dans ces trois scénarios, il y a un point commun. Le code exécute toujours la fonction print sous l'instruction finally.

Si vous êtes novice en Python et que vous souhaitez coder comme un vrai programmeur, essayez notre cursus de compétences en programmation Python. Vous apprendrez à écrire du code efficace, les fonctions Python, le génie logiciel, les tests unitaires et la programmation orientée objet. 

Gestion des exceptions imbriquées en Python

Nous avons besoin d'une gestion imbriquée des exceptions lorsque nous préparons le programme à gérer plusieurs exceptions dans une séquence. Par exemple, nous pouvons ajouter un autre bloc try-except sous l'instruction else. Ainsi, si la première instruction ne soulève pas d'exception, vérifiez la seconde instruction avec l'autre moitié du code. 

Modifier la fonction de division

Nous avons modifié la fonction divide de l'exemple précédent et ajouté un bloc try-except imbriqué sous l'instruction else. Ainsi, s'il n'y a pas de AttributeError, il exécutera le else et vérifiera le nouveau code pour l'exception ZeroDivisionError.

def divide(x,y):
    
    try:
        value = 50
        x.append(value)
    
    except AttributeError as atr_err:
        print(atr_err)
        
    else:
        try:
            result = [i / y for i in x]
            print( result )
 except ZeroDivisionError:
            print("Please change 'y' argument to non-zero value")

    finally:
        print("\033[92m Code by DataCamp\033[00m")

Dans le premier scénario, nous fournissons la liste des quatre valeurs x et le dénominateur 3. Le script ajoutera 50 à la liste, divisera la valeur individuelle de la liste par 3 et affichera le résultat. 

x = [40,65,70,87]
divide(x,3)

La fonction a été exécutée avec succès sans soulever d'exception.

[13.333333333333334, 21.666666666666668, 23.333333333333332, 29.0, 16.666666666666668]
 Code by DataCamp

Au lieu d'une liste, nous avons fourni un entier en premier argument, ce qui a soulevé AttributeError.

divide(4,3)

'int' object has no attribute 'append'
 Code by DataCamp

Dans le dernier scénario, nous avons fourni la liste, mais 0 est le deuxième argument qui a soulevé l'exception ZeroDivisionError sous la déclaration else. 

divide(x,0)

Please change 'y' argument to non-zero value
 Code by DataCamp

Exemple d'édition de fichier

Examinons des exemples plus pratiques de chargement du fichier, d'écriture d'un texte et de fermeture du fichier. 

La fonction file_editor() vous permettra

• Vérifiez l'exception FileNotFoundError pour la fonction open().
• Si l'exception extérieure n'est pas levée, il vérifiera l'exception de la fonction write().
• Quoi qu'il en soit, après avoir ouvert le fichier, il le fermera en exécutant l'instruction finally. 
• Si l'instruction try externe lève l'exception, elle renvoie le message d'erreur avec un chemin d'accès au fichier non valide. 

def file_editor(path,text):
    try:
      data = open(path)

      try:
        data.write(text)

      except:
        print("Unable to write the data. Please add an append: 'a' or write: 'w' parameter to the open() function.")

      finally:
        data.close()

    except:
      print(f"{path} file is not found!!")

Dans le premier scénario, nous fournissons le chemin d'accès au fichier et le texte.

path = "data.txt"
text = "DataLab: Share your data analysis in a cloud-based environment--no installation required."

file_editor(path,text)

L'exception extérieure est levée. 

data.txt file is not found!!

Pour résoudre l'exception du fichier introuvable, nous devons créer un fichier data.txt à l'aide de la commande Linux echo. 

!echo "File by DataCamp" > "data.txt"

Ensuite, réexécutez la fonction file_editor().

file_editor(path,text)

L'exception interne est levée, car la fonction write() n'est pas en mesure d'ajouter le texte.

Unable to write the data. Please add an append: 'a' or write: 'w' parameter to the open() function.

Pour résoudre ce problème, nous devons remplacer la troisième ligne data = open(path) par data = open(path, 'a'). Il nous permettra d'ajouter le nouveau texte au fichier. 

Après avoir réexécuté la fonction, nous avons ajouté avec succès le texte au fichier. 

file_editor(path,text)

La gestion des exceptions imbriquées n'est pas recommandée car elle rend la gestion des exceptions plus complexe ; les développeurs utilisent plusieurs blocs try-except pour créer une gestion des exceptions séquentielle simple. 

Remarque : vous pouvez également ajouter un bloc imbriqué try-except sous la déclaration try ou except. Tout dépend de vos besoins. 

Lever des exceptions en Python

En tant que développeur Python, vous pouvez lancer une exception si certaines conditions sont remplies. Il vous permet d'interrompre le programme en fonction de vos besoins. 

Pour lancer une exception, nous devons utiliser le mot-clé raise suivi d'un nom d'exception. 

Exemple de levée d'erreur de valeur

Nous pouvons simplement lever des exceptions en ajoutant un mot-clé raise dans la déclaration if/else. 

Dans l'exemple, nous affichons ValueError si la valeur est supérieure à 1 000. Nous avons changé la valeur à 2 000, ce qui a rendu la déclaration if TRUE et a augmenté ValueError avec le message personnalisé. Le message d'erreur personnalisé vous aide à résoudre rapidement le problème. 

value = 2_000
if value > 1_000:   
    # raise the ValueError
    raise ValueError("Please add a value lower than 1,000")
else:
    print("Congratulations! You are the winner!!")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)

----> 4     raise ValueError("Please add a value lower than 1,000")
      5 else:
      6     print("Congratulations! You are the winner!!")

ValueError: Please add a value lower than 1,000

Exemple de levée d'une exception

Nous pouvons également lever n'importe quelle exception Python intégrée au hasard si la condition est remplie. Dans notre cas, nous avons levé une Exception générique avec le message d'erreur.

if value > 1_000:   
    # raise the Exception
    raise Exception("Please add a value lower than 1,000")
else:
    print("Congratulations! You are the winner!!")

---------------------------------------------------------------------------
Exception                                 Traceback (most recent call last)
----> 3     raise Exception("Please add a value lower than 1,000")
      4 else:
      5     print("Congratulations! You are the winner!!")

Exception: Please add a value lower than 1,000

Exemple de gestion d'une exception levée

Nous pouvons également créer notre propre exception et la gérer en utilisant le bloc try-except. 

Dans l'exemple, nous avons ajouté un exemple d'erreur de valeur sous la déclaration try.  

Comment cela fonctionnera-t-il ? Au lieu de lever l'exception et de terminer le programme, il affichera le message d'erreur que nous avons fourni.

value = 2_000
try:
    if value > 1_000:
          
        # raise the ValueError
        raise ValueError("Please add a value lower than 1,000")
    else:
        print("Congratulations! You are the winner!!")
              
# if false then raise the value error
except ValueError as e:
        print(e)

Ce type de gestion des exceptions nous aide à nous préparer à des erreurs non couvertes par Python et qui sont spécifiques aux exigences de votre application. 

Please add a value lower than 1,000

Quoi de neuf dans Python 3.10 et 3.11 pour la gestion des exceptions ?

Certaines nouveautés importantes ont été ajoutées aux versions plus récentes de Python, telles que 3.10 et 3.11, depuis la rédaction initiale du billet de blog :

1. Recherche de motifs structurels dans Python 3.10 : Python 3.10 a introduit la correspondance des motifs structurels, qui peut être utilisée pour gérer les exceptions de manière plus élégante en faisant correspondre les types d'erreur dans une déclaration match. Ceci est particulièrement utile pour traiter plusieurs types d'exceptions de manière plus lisible. Exemple :

try:
    result = 1 / 0
except Exception as e:
    match e:
        case ZeroDivisionError():
            print("You cannot divide by zero.")
        case NameError():
            print("Variable not defined.")
        case _:
            print("An unexpected error occurred.")

2. Localisation fine des erreurs dans les tracebacks (Python 3.11) : Dans Python 3.11, les traces d'erreurs indiquent désormais l'emplacement précis des erreurs, ce qui facilite le débogage des exceptions.

• Avant Python 3.11 :

value = (1 + 2) * (3 / 0)

• Traceback :

ZeroDivisionError: division by zero

• Python 3.11 : Les traces permettent d'identifier la sous-expression exacte à l'origine de l'exception :

ZeroDivisionError: division by zero
       (1 + 2) * (3 / 0)
                      ^

3. Groupes d'exceptions et except* (Python 3.11) : Python 3.11 a introduit les groupes d'exceptions pour gérer plusieurs exceptions dans un seul bloc en utilisant except*. Cette fonction est utile pour gérer du code asynchrone ou des scénarios dans lesquels plusieurs exceptions peuvent être levées. Exemple :

try:
    raise ExceptionGroup("Multiple errors", [ValueError("Bad value"), TypeError("Bad type")])
except* ValueError as ve:
    print(f"Handling ValueError: {ve}")
except* TypeError as te:
    print(f"Handling TypeError: {te}")

4. Méthode add_note pour les exceptions (Python 3.11) : Les exceptions disposent désormais d'une méthode add_note(), qui permet aux développeurs d'ajouter des notes personnalisées aux exceptions afin d'améliorer le débogage. Exemple :

try:
    raise ValueError("Invalid input")
except ValueError as e:
    e.add_note("This happened while processing user input.")
    e.add_note("Consider validating input before processing.")
    raise

• Traceback :

ValueError: Invalid input
Notes:
- This happened while processing user input.
- Consider validating input before processing.

5. PEP 654 : Meilleure gestion des exceptions imbriquées : Avec les groupes d'exceptions, les exceptions imbriquées sont désormais plus faciles à déboguer et à gérer, en particulier dans les flux de travail complexes tels que le multiprocessus ou les tâches asynchrones.

Conclusion

Les deux tests unitaires et la gestion des exceptions sont des éléments essentiels de la programmation Python qui permettent à votre code d'être prêt pour la production et à l'abri des erreurs. Dans ce tutoriel, nous avons appris à connaître les exceptions et les erreurs en Python et à les gérer. En outre, nous avons appris à connaître les blocs try-except imbriqués complexes et avons créé des blocs d'exception personnalisés en fonction des besoins.  

Ces outils et mécanismes sont essentiels, mais la majeure partie du travail est effectuée par le biais de simples blocs try et except. try recherche les exceptions soulevées par le code et except gère ces exceptions. 

Si cela vous semble confus et que vous ne savez pas par où commencer, suivez notre cours Introduction aux fonctions en Python pour comprendre le cadrage, les fonctions lambda et la gestion des erreurs. Vous pouvez également vous inscrire au cursus de carrière Python Programmer pour acquérir des compétences professionnelles et devenir un développeur Python professionnel.