class: center, middle # Gestion des erreurs --- # Exceptions En Python les **exceptions** sont un ensemble de mots-clés dédié à la **gestion des erreurs**. Un exception est un objet qui représente une erreur. On dit qu'une exception est **levée** lorsqu'une erreur survient. ```python >>> 10/0 Traceback (most recent call last): File "
", line 1, in
ZeroDivisionError: division by zero ``` => Python a retourné une exception de type **`ZeroDivisionError`**. D'autres types d'exceptions existent : `NameError`, `TypeError`, `ValueError`, ... ```python >>> x = a Traceback (most recent call last): File "
", line 1, in
NameError: name 'a' is not defined ``` Pour la liste des exceptions en Python, voir https://docs.python.org/3/library/exceptions.html --- # Exceptions #### Try ... Except Les mots-clés **`try`** et **`except`** permettent « **d'attraper** » les exceptions. On peut ainsi programmer des comportements adaptés en cas d'erreur. ```python >>> x = 10 >>> y = 0 >>> try: ... print (x/y) ... except ZeroDivisionError: ... print ("ERREUR, division par zéro impossible") >>> print ("Le programme continue ...") ERREUR, division par zéro impossible Le programme continue ... ``` --- # Exceptions #### Try ... Except Plusieurs blocs **`except`** peuvent se suivre pour gérer plusieurs types d'exceptions. ```python >>> x = 10 >>> y = 0 >>> z = "a" >>> try: ... print (x/y) ... print (x+z) ... except ZeroDivisionError: ... print (f"ERREUR, division par zéro impossible : ({x}/{y})") ... except TypeError: ... print (f"ERREUR, opération impossible : ({x}+{z})") ... except Exception: ... print ("Une erreur est survenue") >>> print ("Le programme continue ...") ERREUR, division par zéro impossible : (10 / 0) Le programme continue ... ``` => Lorsqu'un type d'exception est attrapé, les autres blocs « **`except`** » ne sont pas évalués. --- # Exceptions #### Try ... Except ```python >>> x = 10 >>> y = 2 >>> z = "a" >>> try: ... print (f"Résultat de la division : {x/y}") ... print (f"Résultat de l'addition : {x+z}") ... except ZeroDivisionError: ... print (f"ERREUR, division par zéro impossible : ({x}/{y})") ... except TypeError: ... print (f"ERREUR, opération impossible : ({x}+{z})") ... except Exception: ... print ("Une erreur est survenue") >>> print ("Le programme continue ...") Résultat de la division : 5.0 ERREUR, opération impossible : (10+a) Le programme continue... ``` => La ligne « `except Exception` » attrape toutes les exceptions non attrapées par les autres blocs. Cela permet de gérer des exceptions non prévues. --- # Exceptions #### Try ... Except ... Else ... Finally * Le bloc **`else`** est éxécuté si aucune exception est déclenchée. * Le bloc **`finally`** est executé quoiqu'il arrive. ```python >>> x = 10 >>> y = 0 >>> try: ... div = x/y ... ... except ZeroDivisionError: ... print ("ERREUR, division par zéro impossible") ... ... except Exception: ... print ("Une erreur est survenue") ... ... else: # Ici la suite du programme si aucune erreur n'est rencontrée ... print (f"Le résulat de la division est {div}") ... ... finally: # Ici les opérations "obligatoires" ... print ("Fin du programme") ERREUR, division par zéro impossible Fin du programme ``` --- # Exceptions #### Mots-clés `as` et `raise` Le mot clé **`as`** permet de **stocker** une exception dans une variable. ```python >>> x = 10 >>> y = 0 >>> try: ... div = x/y ... ... except ZeroDivisionError as erreur: ... print (f"ERREUR : {erreur}") ERREUR : division by zero ``` --- # Exceptions #### Mots-clés `as` et `raise` Le mot clé **`raise`** permet de **déclencher** une exception. ```python >>> x = 10 >>> y = 0 >>> if y == 0: ... raise ZeroDivisionError("La division par zéro n'est pas possible.") --------------------------------------------------------------------------- ZeroDivisionError Traceback (most recent call last) Cell In[26], line 2 1 if y == 0: ----> 2 raise ZeroDivisionError("La division par zéro n'est pas possible.") ZeroDivisionError: La division par zéro n'est pas possible. ``` --- # Exceptions #### Mots-clé `assert` Le mot clé **`assert`** permet de **vérifier** une condition. ```python >>> x = 10 >>> y = 0 >>> try: >>> assert y != 0 # Déclence une exception "AssertionError" si faux >>> except AssertionError: >>> print ("La division par zéro n'est pas possible.") La division par zéro n'est pas possible. ``` Ci-dessous, un bloc d'instructions équivalent qui utilise le mot-clé **`if`** : ```python >>> x = 10 >>> y = 0 >>> if y == 0: ... raise ZeroDivisionError("La division par zéro n'est pas possible.") La division par zéro n'est pas possible. ``` => L'un et l'autre sont valables et ils produisent le même résultat, mais l'utilisation de `assert` aide à clarifier le code. --- # Travaux Pratiques (1/2)
Écrivez un script Python **`capteur.py`** ou un notebook **`capteur.ipynb`** qui calcule la moyenne d'une série de températures. Le programme doit demander à l'utilisateur d'entrer les températures un par une, et afficher la moyenne des températures à chaque fois (_25 minutes d'autonomie_). Instructions : * Utilisez la fonction **`input()`** pour demander à l'utilisateur d'entrer les nombres. * Utiliser une boucle **`while`** pour demander à l'utilisateur d'entrer des températures jusqu'à ce qu'il entre le mot clé « **STOP** ». * Assurez-vous de gérer avec **`try / except`** les cas où l'utilisateur entre une valeur non numérique. Conseils : * Utilisez la méthode **`float()`** pour convertir les entrées de l'utilisateur en nombres décimaux afin de permettre les opérations avec des nombres à virgule. * Utilisez la méthode **`round()`** pour arrondir le résultat de la moyenne à deux décimales. * Vous pouvez stocker les températures dans une liste pour faciliter le calcul de la moyenne. Bonus : * Utilisez une fonction pour calculer la moyenne des températures. * Utilisez une fonction pour vérifier si l'entrée de l'utilisateur est un nombre. * Ne calculer la calculer la moyenne que sur les 5 dernières températures.
--- # Travaux Pratiques (1/2) Exemple d'affichage lors de l'exécution : ```python Capteur de température Entrez une température : 10 Moynenne : 10.0 Entrez une température : 13 Moynenne : 11.5 Entrez une température : 11 Moynenne : 11.34 Entrez une température : STOP Fin du programme ``` --- # Travaux Pratiques (2/2) Écrivez un script Python « `codon.py` » ou un notebook « `codon.ipynb` » qui prends en entrée une séquence d'ADN et retourne son dernier codon, ou déclenche une exception si la séquence n'est pas complète (_25 minutes d'autonomie_). Instructions : * Utilisez la méthode **`input()`** pour demander à l'utilisateur d'entrer la séquence d'ADN. * Utiliser la méthode **`dernier_codon()`** du module **`sequence.py`**. Ne modifiez pas cette méthode, mais utilisez-la dans votre programme. * La programme doit déclencher une exception lorsque la séquence n'est pas complète. Conseils : * Exécuter la méthode **`dernier_codon()`** dans un bloc `try / except` pour gérer les exceptions. --- # Travaux Pratiques (2/2) Exemple d'affichage lors de l'exécution : ```python Dernier codon Entrez une séquence d'ADN : ATGCGTACG Le dernier codon est : ACG ``` ```python Dernier codon Entrez une séquence d'ADN : ATGCGTAC ERREUR : La séquence n'est pas complète. ```