La gestion des exceptions en Python

Comme d'autres langages, Python fournit également la gestion d'exceptions à l'aide de try-except.
Parmi les exceptions standard les plus fréquentes : IndexError, ImportError, IOError, ZeroDivisionError, TypeError.

Il y a deux sortes d'erreurs:

• Erreur de syntaxe : Également appelée erreur d’analyse, la plus élémentaire. Apparaît lorsque l'analyseur Python est incapable de comprendre une ligne de code.
• Exception: erreurs détectées lors de l'exécution. par exemple - ZeroDivisionError.

Liste des erreurs d'exceptions:

• IOError: si le fichier ne peut pas être ouvert
• KeyboardInterrupt: lorsqu'une touche non requise est enfoncée par l'utilisateur
• ValueError: lorsque la fonction intégrée reçoit un argument incorrect
• EOFError: si End-Of-File est touché sans lire aucune donnée
• ImportError: s'il est impossible de trouver le module
• MemoryError : Cette erreur est générée lorsqu'une opération manque de mémoire.
• ...

    try:
        // Code
     except:
        // Code

Comment fonctionne try()?

• La première clause try est exécutée, c'est-à-dire le code entre try et except clause.
• S'il n'y a pas d'exception, alors seule la clause try sera exécutée, sauf que la clause est terminée.
• Si une exception survient, la clause try sera ignorée et la clause except sera exécutée.
• Si une exception se produit, mais que la clause except contenue dans le code ne la gère pas, elle est transmise aux instructions try externes.
• Si l'exception n'est pas gérée, l'exécution s'arrête.
• Une instruction try peut avoir plus d'une clause except

            def division(a, b):
                try:
                    d = a//b
                    print(d)
                except ZeroDivisionError:
                    print("Division par zero ! ")
            
            
            print("premiere instruction")
            division(4, 2)
            
            print("Deuxieme instruction")
            division(4, 0)
        

            premiere instruction
            2
            Deuxieme instruction
            Division par zero !
        

Une instruction try peut avoir plusieurs clauses except, pour spécifier des gestionnaires pour différentes exceptions. Veuillez noter qu'au plus un gestionnaire sera exécuté.

    def Test(op, a, b):
        try:
            if op == '//':
                d = a//b
            print("resultat : ", c)
        except(ZeroDivisionError, NameError):
            print("Ooops erreur")
    
    
    Test("//", 4, 2)

    Ooops erreur

En python, vous pouvez également utiliser la clause else sur le bloc try-except qui doit être présent après toutes les clauses except. Le code entre dans le bloc else uniquement si la clause try ne déclenche pas d'exception.

    def division(a, b):
        try:
            d = a//b
        except ZeroDivisionError:
            print("Division par zero ! ")
        else:
            print("Résultat : ", d)

    Résultat :  2

L'instruction raise permet au programmeur de forcer une exception spécifique à se produire. Le seul argument soulevé indique l'exception à déclencher. Il doit s'agir d'une instance d'exception ou d'une classe d'exception (une classe dérivée de Exception).

    def division(a, b):
        try:
            if b == 0:
                raise ZeroDivisionError("Division par zero ! ")
        except ZeroDivisionError:
            print("Erreur")
            raise # pour déterminer si l'exception a été levée ou non

La sortie du code ci-dessus sera simplement “Erreur”, mais une erreur d’exécution se produira également dans la dernière en raison d’une instruction raise dans la dernière ligne. Ainsi, la sortie du programme ressemblera à

    Erreur
        Traceback (most recent call last):
            File "exep.py", line 28, in < module >
                division2(4, 0)
            File "exep.py", line 22, in division2
                raise ZeroDivisionError("Division par zero ! ")
            ZeroDivisionError: Division par zero !

    try:
        // Code
    except Exception as e:
        // message d'erreur

Exemple :

    def division(a, b):
        try:
            d = a//b
        except Exception as e:
            print(e)

    integer division or modulo by zero

            def division(a, b):
                try:
                    d = a//b
                except ArithmeticError:
                    print("Erreur")
        

            T = [1, 2, 3]
            try:
                print(T[4])
            except LookupError:
                print("Indice est supérieur à la taille du tableau")
        

            Indice est supérieur à la taille du tableau
        

            assert False, 'condition est echouée'
        

            Traceback (most recent call last):
                File "< stdin >", line 1, in < module >
                AssertionError: condition est echouée
        

        class Personne:
            def __init__(self, nom):
                self.nom = nom
        
        
        try:
            p = Personne("ESSADDOUKI")
            print(p.prenom)
        except AttributeError:
            print("Erreur d'attribut")
    

        Erreur d'attribut
    

            import math
            print(math.exp(1000))
        

            Traceback (most recent call last):
                File "exep.py", line 29, in < module >
                    print(math.exp(1000))
                OverflowError: math range error
        

            def fact(n):
                n*fact(n-1)
            
            try:
                fact(10)
            except RecursionError:
                print("la profondeur de récursivité maximale est dépassée")
        

la profondeur de récursivité maximale est dépassée