Le Tutoriel de gestion des exceptions Python

View more Tutorials:

1- Qu'est- ce que Exception?

Tout d'abord, voyons l'exemple d'illustration suivant:
Dans cet exemple, il existe une partie du code d'erreur qui résulte de la division par 0. La division par 0 provoque l'exception: ZeroDivisionError
helloExceptionExample.py
print ("Three")

# Cette division a aucun problème.
value = 10 / 2

print ("Two")

# Cette division a aucun problème.
value = 10 / 1
 
print ("One")

d = 0

# Cette division a un problème, divisé par 0.
# Une erreur s'est produite ici.
# ​​​​​​​
value = 10 / d

# Et le code suivant ne sera pas exécuté.
print ("Let's go!")
Le résultat de l'exécution de l'exemple:
Vous pouvez voir la notification sur l'écran de la console. La notification d'erreur est très claire, y compris les informations de la ligne de code.
Voyons le flux du programme à travers l'illustration suivante.
  • Le programme s'exécute normalement de l'étape (1),(2) à (6)
  • À l'étape (7), le programme est divisé par 0. Le programme se termine.
  • Et l'étape (8), le code n'a pas été exécuté.

Nous modifierons le code de l'exemple ci-dessus.

helloCatchException.py
print ("Three")

value = 10 / 2

print ("Two")

value = 10 / 1
 
print ("One")

d = 0


try :
    # Cette division a un problème, divisé par 0.
    # Une erreur s'est produite ici (ZeroDivisionError).
    value = 10 / d
    
    print ("value = ", value)
    
except ZeroDivisionError as e :
    
    print ("Error: ", str(e) )
    print ("Ignore to continue ...")


print ("Let's go!")
Et les résultats de l'exécution de l'exemple :
Nous allons expliquer le flux du programme par les images d'illustration suivantes.
  • Des étapes (1)-(6) sont complètement normales.
  • L'exception se produit à l'étape (7), le problème a divisé par 0.
  • Tout de suite, il effectue l'exécution de la commande dans le bloc except, l'étape (8) est omise.
  • L'étape (9), (10) sont exécutées.
  • L'étape (11) est exécutée.

2- La hiérarchie des exceptions

Voici est le modèle d'hiérarchie des exceptions en Python.

  • La classe la plus élevée est BaseException
  • Les sous-classes directes sont ExceptionKeyboardInterrupt, ...

Les Exception disponibles en Python qui sont normalement dérivées (derived) de BaseException (Étendues de BaseException). Alors que les exceptions de l’utilisateur (du programmeur) devrient hériter ses Exception ou de ses sous-classes.

3- Gestion de l'exception avec try-except

Nous écrivons une classe qui hérite de la classe  Exception.
See more:
La fonction  checkAge sert à vérifier l'âge, si l'âge est moins de 18 ou plus de 40, une exception se produira.
ageexception.py
# Python 3.x
class AgeException(Exception):
    
    def __init__(self, msg, age ):
        super().__init__(msg) 
        self.age = age
        
        
class TooYoungException(AgeException):
    
    def __init__(self, msg, age):
        super().__init__(msg, age)     
        

class TooOldException(AgeException):
    
    def __init__(self, msg, age):
        super().__init__(msg, age)    
         
# La fonction de vérifier l'âge, il peut lever l'exception..
def checkAge(age):
  
    if (age < 18) :
        # Si l'âge est inférieur à 18 ans, une exception sera levée.
        # Cette fonction se termine ici.
        raise TooYoungException("Age " + str(age) + " too young", age)
    
    elif (age > 40) :
        # Si l'âge est supérieur à 40, une exception sera levée.
        # Cette fonction se termine ici.        
        raise TooOldException("Age " +  str(age) + " too old", age);

    # Si l'âge est entre 18-40.
    # Ce code sera exécuté.
    print ("Age " +  str(age) + " OK!");
Exemple:
tryExceptDemo1.py
import ageexception
from ageexception import AgeException
from ageexception import TooYoungException
from ageexception import TooOldException


print ("Start Recruiting ...")

age = 11

        
print ("Check your Age ", age)

try :


    ageexception.checkAge(age)

    print ("You pass!")

 
except TooYoungException as e  :


    print("You are too young, not pass!")    
    print("Cause message: ", str(e) )
    print("Invalid age: ", e.age)


except  TooOldException as e :

 
    print ("You are too old, not pass!")
    print ("Cause message: ", str(e) )
    print("Invalid age: ", e.age)
   
 
Exécutez l'exemple:
Dans l'exemple ci-dessous, nous allons intercepter les exceptions par les exceptions parentales. Au niveau plus supérieur, elle attrapera des exceptions et tous les sous-exceptions.
tryExceptDemo2.py
import ageexception
from ageexception import AgeException
from ageexception import TooYoungException
from ageexception import TooOldException


print ("Start Recruiting ...")

age = 51

      
print ("Check your Age ", age)

try :


    ageexception.checkAge(age)

    print ("You pass!")


except AgeException as e  :


    print("You are not pass!")  
    print("type(e): ", type(e) )
    print("Cause message: ", str(e) )
    print("Invalid age: ", e.age)
 
Exécution de l'exemple:

4- Le bloc try-except-finally

Nous nous sommes habitués à attraper l'erreur via le bloc try-except. La gestion des exception complète est  try-except-finally. Le bloc  finally est toujours exécuté, que l'exception se produise ou non dans le bloc try.
try - except - finally
try :

    # Faites quelque chose ici.
except Exception1 as e :

    # Faites quelque chose ici.
except Exception2 as e :

    # Faites quelque chose ici.
finally :

    # Le bloc finally est toujours exécuté.
    # Faites quelque chose ici.
Exemple:
tryExceptFinallyDemo.py
def toInteger(text) :
       
    try :
    

        print ("-- Begin parse text: ", text)

        # Une exception peut lancer ici (ValueError).
        value = int(text)

        return value

    except ValueError as e :
     
        # Dans le cas de 'texte' n'est pas un nombre.
        # Ce bloc 'except' sera exécuté.
        print ("ValueError message: ", str(e))
        print ("type(e): ", type(e))

        # Renvoie 0 si ValueError se produit.
        return 0

     
    finally :
   

        print ("-- End parse text: " + text)

    
 
text = "001234A2"

value = toInteger(text)

print ("Value= ", value)
Exécution de l'exemple:
Voici est le flux du programme. Le bloc  finally est toujours exécuté.

La commande pass

Si vous ne voulez rien traiter dans le bloc ' except' ou ' finally', vous pouvez utiliser l'instruction ' pass' (pass statement). La commande passe ne fait rien, c'est comme une déclaration nulle.
passStatementExample.py
print ("Three")

try :
   
    value = 10 / 0;
   
except Exception as e:
   
    pass

print ("Two")   

print ("One")

print ("Let's go")

5- Relancer l'exception

Lors de la gestion de l'exception, vous pouvez attraper cette exception et la gérer ou vous pouvez la relancer (rethrow).
reRaiseExceptionDemo1.py

def checkScore(score) :
    
    if score < 0 or score > 100:
        raise Exception("Invalid Score " + str(score) )
    


def checkPlayer(name, score):
    
    try :
        
        checkScore(score)
     
    except Exception as e :
        
        print ("Something invalid with player: ",name, ' >> ', str(e) )
        
        # re throw exception.
        raise    
 
 
# ------------------------------------------


checkPlayer("Tran", 101)          
Par exemple, attrapez une exception et jettez (rethrow) une autre exception.
reRaiseExceptionDemo2.py

def checkScore(score) :
  
    if score < 0 or score > 100:
        raise Exception("Invalid Score " + str(score) )
  


def checkPlayer(name, score):
  
    try :
      
        checkScore(score)
    
    except Exception as e :
      
        print ("Something invalid with player: ",name, ' >> ', str(e) )
      
        # throw new exception.
        raise Exception("Something invalid with player: "+ name + " >> "+ str(e))  


# ------------------------------------------


checkPlayer("Tran", 101)          

6- Emballage une Exception dans une autre Exception

Python permet d'attraper et de jeter une nouvelle exception. Des nouvelles exceptions peuvent stocker des informations de l'exception originale que vous avez accédé via l'attribut  __cause__.
try :

    # Faites quelque chose ici ...
except Exception as e :

    raise OtherException("Message...") from e
Voyons l'exemple complet:
wrapExceptionDemo.py
# Python 3.x:
# L'exception de genre
class GenderException(Exception):
    
    def __init__(self, msg):
        super().__init__(msg)     

# L'exception linguistique.
class LanguageException(Exception):
    
    def __init__(self, msg):
        super().__init__(msg)     


class PersonException(Exception):
    
    def __init__(self, msg):
        super().__init__(msg)

# Cette fonction peut lancer GenderException.
def checkGender(gender):
    
    if gender != 'Female' :
        raise GenderException("Accept female only")

# Cette fonction peut lancer LanguageException.
def checkLanguage(language):  
      
    if language != 'English' :
        raise LanguageException("Accept english language only")
    

def checkPerson(name, gender, language):
    
    try : 
        # Peut lancer GenderException.
        checkGender(gender)
        # Peut lancer LanguageException.
        checkLanguage(language)
    except Exception as e:
        # Attraper l'exception et lever une autre exception.
        # La nouvelle exception a __cause__ = e.
        raise PersonException(name + " does not pass") from e
    
# --------------------------------------------------------
try  :
    
    checkPerson("Nguyen", "Female", "Vietnamese")
    
except PersonException as e:
    
    print ("Error message: ", str(e) )   
    
    # GenderException ou LanguageException
    cause = e.__cause__  
    
    print ('e.__cause__: ', repr(cause))
    
    print ("type(cause): " , type(cause) )
    
    print (" ------------------ ")
    
    if type(cause) is GenderException :
        
        print ("Gender exception: ", cause)
        
    elif type(cause) is LanguageException:
        
        print ("Language exception: ", cause)

View more Tutorials: