Python 3 - Gestion des exceptions

Python fournit deux fonctionnalités très importantes pour gérer toute erreur inattendue dans vos programmes Python et pour y ajouter des capacités de débogage -

  • Exception Handling- Cela serait couvert dans ce tutoriel. Voici une liste d'exceptions standard disponibles en Python - Exceptions standard .

  • Assertions- Cela serait couvert dans le didacticiel Assertions in Python 3 .

Exceptions standard

Voici une liste des exceptions standard disponibles en Python. -

N ° Sr. Nom et description de l'exception
1

Exception

Classe de base pour toutes les exceptions

2

StopIteration

Déclenché lorsque la méthode next () d'un itérateur ne pointe vers aucun objet.

3

SystemExit

Déclenché par la fonction sys.exit ().

4

StandardError

Classe de base pour toutes les exceptions intégrées à l'exception de StopIteration et SystemExit.

5

ArithmeticError

Classe de base pour toutes les erreurs qui se produisent pour le calcul numérique.

6

OverflowError

Déclenché lorsqu'un calcul dépasse la limite maximale pour un type numérique.

sept

FloatingPointError

Déclenché lorsqu'un calcul en virgule flottante échoue.

8

ZeroDivisonError

Augmenté lorsque la division ou le modulo par zéro a lieu pour tous les types numériques.

9

AssertionError

Levé en cas d'échec de la déclaration Assert.

dix

AttributeError

Levé en cas d'échec de la référence d'attribut ou de l'affectation.

11

EOFError

Déclenché lorsqu'il n'y a aucune entrée de la fonction raw_input () ou input () et que la fin du fichier est atteinte.

12

ImportError

Déclenché lorsqu'une instruction d'importation échoue.

13

KeyboardInterrupt

Déclenché lorsque l'utilisateur interrompt l'exécution du programme, généralement en appuyant sur Ctrl + c.

14

LookupError

Classe de base pour toutes les erreurs de recherche.

15

IndexError

Déclenché lorsqu'un index n'est pas trouvé dans une séquence.

16

KeyError

Déclenché lorsque la clé spécifiée est introuvable dans le dictionnaire.

17

NameError

Déclenché lorsqu'un identificateur n'est pas trouvé dans l'espace de noms local ou global.

18

UnboundLocalError

Déclenché lors d'une tentative d'accès à une variable locale dans une fonction ou une méthode mais aucune valeur ne lui a été affectée.

19

EnvironmentError

Classe de base pour toutes les exceptions qui se produisent en dehors de l'environnement Python.

20

IOError

Déclenché lorsqu'une opération d'entrée / sortie échoue, comme l'instruction d'impression ou la fonction open () lors de la tentative d'ouverture d'un fichier qui n'existe pas.

21

OSError

Levé pour des erreurs liées au système d'exploitation.

22

SyntaxError

Déclenché en cas d'erreur dans la syntaxe Python.

23

IndentationError

Levé lorsque l'indentation n'est pas spécifiée correctement.

24

SystemError

Déclenché lorsque l'interpréteur trouve un problème interne, mais lorsque cette erreur est rencontrée, l'interpréteur Python ne se ferme pas.

25

SystemExit

Déclenché lorsque l'interpréteur Python est fermé à l'aide de la fonction sys.exit (). S'il n'est pas traité dans le code, provoque la fermeture de l'interpréteur.

26

TypeError

Déclenché lorsqu'une opération ou une fonction est tentée qui n'est pas valide pour le type de données spécifié.

27

ValueError

Déclenché lorsque la fonction intégrée pour un type de données a le type d'arguments valide, mais que les arguments ont des valeurs non valides spécifiées.

28

RuntimeError

Déclenché lorsqu'une erreur générée n'appartient à aucune catégorie.

29

NotImplementedError

Déclenché lorsqu'une méthode abstraite qui doit être implémentée dans une classe héritée n'est pas réellement implémentée.

Assertions en Python

Une assertion est un contrôle de cohérence que vous pouvez activer ou désactiver lorsque vous avez terminé votre test du programme.

  • La façon la plus simple de penser à une assertion est de la comparer à un raise-ifinstruction (ou pour être plus précis, une instruction rise-if-not). Une expression est testée et si le résultat est faux, une exception est déclenchée.

  • Les assertions sont effectuées par l'instruction assert, le mot-clé le plus récent de Python, introduit dans la version 1.5.

  • Les programmeurs placent souvent des assertions au début d'une fonction pour vérifier l'entrée valide, et après un appel de fonction pour vérifier la sortie valide.

La déclaration d'assert

Lorsqu'il rencontre une instruction assert, Python évalue l'expression d'accompagnement, ce qui est, espérons-le, vrai. Si l'expression est fausse, Python déclenche une exception AssertionError .

La syntaxe pour assert est -

assert Expression[, Arguments]

Si l'assertion échoue, Python utilise ArgumentExpression comme argument pour AssertionError. Les exceptions AssertionError peuvent être interceptées et gérées comme toute autre exception, à l'aide de l'instruction try-except. S'ils ne sont pas traités, ils mettront fin au programme et produiront une trace.

Exemple

Voici une fonction qui convertit une température donnée de degrés Kelvin en degrés Fahrenheit. Comme 0 ° K est aussi froid que possible, la fonction se retire si elle voit une température négative -

#!/usr/bin/python3

def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Colder than absolute zero!"
   return ((Temperature-273)*1.8)+32

print (KelvinToFahrenheit(273))
print (int(KelvinToFahrenheit(505.78)))
print (KelvinToFahrenheit(-5))

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

32.0
451
Traceback (most recent call last):
File "test.py", line 9, in <module>
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

Qu'est-ce qu'une exception?

Une exception est un événement, qui se produit pendant l'exécution d'un programme qui perturbe le flux normal des instructions du programme. En général, lorsqu'un script Python rencontre une situation qu'il ne peut pas gérer, il lève une exception. Une exception est un objet Python qui représente une erreur.

Lorsqu'un script Python lève une exception, il doit soit gérer l'exception immédiatement, sinon il se termine et se ferme.

Gérer une exception

Si vous avez un code suspect qui peut soulever une exception, vous pouvez défendre votre programme en plaçant le code suspect dans untry:bloquer. Après l'essai: bloquer, inclure unexcept: , suivi d'un bloc de code qui gère le problème le plus élégamment possible.

Syntaxe

Voici la syntaxe simple de try .... sauf ... else blocs -

try:
   You do your operations here
   ......................
except ExceptionI:
   If there is ExceptionI, then execute this block.
except ExceptionII:
   If there is ExceptionII, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Voici quelques points importants sur la syntaxe mentionnée ci-dessus -

  • Une seule instruction try peut avoir plusieurs instructions except. Ceci est utile lorsque le bloc try contient des instructions qui peuvent lever différents types d'exceptions.

  • Vous pouvez également fournir une clause d'exception générique, qui gère toute exception.

  • Après la ou les clause (s) except, vous pouvez inclure une clause else. Le code du bloc else s'exécute si le code du bloc try: ne déclenche pas d'exception.

  • Le bloc else est un bon endroit pour le code qui n'a pas besoin de la protection try: block.

Exemple

Cet exemple ouvre un fichier, écrit le contenu dans le fichier, et sort gracieusement car il n'y a aucun problème -

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print ("Error: can\'t find file or read data")
else:
   print ("Written content in the file successfully")
   fh.close()

Cela produit le résultat suivant -

Written content in the file successfully

Exemple

Cet exemple tente d'ouvrir un fichier dans lequel vous n'avez pas l'autorisation d'écriture, il déclenche donc une exception -

#!/usr/bin/python3

try:
   fh = open("testfile", "r")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print ("Error: can\'t find file or read data")
else:
   print ("Written content in the file successfully")

Cela produit le résultat suivant -

Error: can't find file or read data

La clause except sans exception

Vous pouvez également utiliser l'instruction except sans aucune exception définie comme suit -

try:
   You do your operations here
   ......................
except:
   If there is any exception, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Ce genre de try-exceptL'instruction intercepte toutes les exceptions qui se produisent. L'utilisation de ce type d'instruction try-except n'est cependant pas considérée comme une bonne pratique de programmation, car elle intercepte toutes les exceptions mais ne permet pas au programmeur d'identifier la cause première du problème pouvant survenir.

La clause except avec plusieurs exceptions

Vous pouvez également utiliser la même instruction except pour gérer plusieurs exceptions comme suit -

try:
   You do your operations here
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   ......................
else:
   If there is no exception then execute this block.

La clause try-finally

Vous pouvez utiliser un finally: bloquer avec un try:bloquer. lefinally:block est un endroit pour mettre tout code qui doit s'exécuter, que le bloc try ait déclenché une exception ou non. La syntaxe de l'instruction try-finally est la suivante -

try:
   You do your operations here;
   ......................
   Due to any exception, this may be skipped.
finally:
   This would always be executed.
   ......................

Note- Vous pouvez fournir des clauses except ou une clause finally, mais pas les deux. Vous ne pouvez pas utiliser une clause else avec une clause finally.

Exemple

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
finally:
   print ("Error: can\'t find file or read data")
   fh.close()

Si vous n'avez pas la permission d'ouvrir le fichier en mode écriture, cela produira le résultat suivant -

Error: can't find file or read data

Le même exemple peut être écrit plus proprement comme suit -

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   try:
      fh.write("This is my test file for exception handling!!")
   finally:
      print ("Going to close the file")
      fh.close()
except IOError:
   print ("Error: can\'t find file or read data")

Cela produit le résultat suivant -

Going to close the file

Lorsqu'une exception est levée dans le bloc try , l'exécution passe immédiatement au bloc finally . Une fois toutes les instructions du bloc finally exécutées, l'exception est à nouveau déclenchée et est gérée dans les instructions except si elle est présente dans la couche supérieure suivante de l' instruction try-except .

Argument d'une exception

Une exception peut avoir un argument , qui est une valeur qui donne des informations supplémentaires sur le problème. Le contenu de l'argument varie par exception. Vous capturez l'argument d'une exception en fournissant une variable dans la clause except comme suit -

try:
   You do your operations here
   ......................
except ExceptionType as Argument:
   You can print value of Argument here...

Si vous écrivez le code pour gérer une seule exception, vous pouvez faire en sorte qu'une variable suive le nom de l'exception dans l'instruction except. Si vous interceptez plusieurs exceptions, vous pouvez faire en sorte qu'une variable suive le tuple de l'exception.

Cette variable reçoit la valeur de l'exception contenant principalement la cause de l'exception. La variable peut recevoir une ou plusieurs valeurs sous la forme d'un tuple. Ce tuple contient généralement la chaîne d'erreur, le numéro d'erreur et un emplacement d'erreur.

Exemple

Voici un exemple pour une seule exception -

#!/usr/bin/python3

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError as Argument:
      print ("The argument does not contain numbers\n", Argument)

# Call above function here.
temp_convert("xyz")

Cela produit le résultat suivant -

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

Lever une exception

Vous pouvez lever des exceptions de plusieurs manières à l'aide de l'instruction rise. La syntaxe générale duraise la déclaration est la suivante -

Syntaxe

raise [Exception [, args [, traceback]]]

Ici, Exception est le type d'exception (par exemple, NameError) et argument est une valeur pour l'argument d'exception. L'argument est facultatif; s'il n'est pas fourni, l'argument d'exception est None.

L'argument final, traceback, est également facultatif (et rarement utilisé en pratique), et s'il est présent, il s'agit de l'objet de traceback utilisé pour l'exception.

Exemple

Une exception peut être une chaîne, une classe ou un objet. La plupart des exceptions soulevées par le noyau Python sont des classes, avec un argument qui est une instance de la classe. La définition de nouvelles exceptions est assez simple et peut être effectuée comme suit -

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

Note- Pour intercepter une exception, une clause "except" doit faire référence à la même exception lancée soit comme un objet de classe, soit comme une simple chaîne. Par exemple, pour capturer l'exception ci-dessus, nous devons écrire la clause except comme suit -

try:
   Business Logic here...
except Exception as e:
   Exception handling here using e.args...
else:
   Rest of the code here...

L'exemple suivant illustre l'utilisation de la levée d'une exception -

#!/usr/bin/python3

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

try:
   l = functionName(-10)
   print ("level = ",l)
except Exception as e:
   print ("error in level argument",e.args[0])

Cela produira le résultat suivant

error in level argument -10

Exceptions définies par l'utilisateur

Python vous permet également de créer vos propres exceptions en dérivant des classes à partir des exceptions intégrées standard.

Voici un exemple lié à RuntimeError . Ici, une classe est créée qui est sous- classée à partir de RuntimeError . Ceci est utile lorsque vous devez afficher des informations plus spécifiques lorsqu'une exception est interceptée.

Dans le bloc try, l'exception définie par l'utilisateur est déclenchée et interceptée dans le bloc except. La variable e est utilisée pour créer une instance de la classe Networkerror .

class Networkerror(RuntimeError):
   def __init__(self, arg):
      self.args = arg

Donc, une fois que vous avez défini la classe ci-dessus, vous pouvez lever l'exception comme suit -

try:
   raise Networkerror("Bad hostname")
except Networkerror,e:
   print e.args