Un guide sur la gestion des exceptions Python —

Dans cet article, nous verrons comment gérer les erreurs et les exceptions en Python – un concept connu sous le nom de « gestion des exceptions ».

Il existe généralement deux types d’erreurs que vous rencontrerez lors de la programmation en Python : les erreurs de syntaxe et les exceptions.

Toute erreur résultant d’une syntaxe, d’une indentation ou d’une structure de programmation invalide est souvent considérée comme un erreur de syntaxe. Lorsqu’une erreur de syntaxe se produit, le programme se bloque au point où l’erreur de syntaxe s’est produite.

Un exception est une anomalie qui perturbe le déroulement normal d’un programme informatique. Lorsque des exceptions se produisent, nous sommes censés gérer ces exceptions pour nous assurer que nos programmes ne se bloquent pas brusquement.

Gestion des exceptions est le processus par lequel des vérifications sont mises en œuvre dans les programmes informatiques pour gérer les erreurs – attendues ou non – qui peuvent survenir lors de l’exécution de nos programmes. (Python a tendance à avoir plus un style de programmation « faire la chose et demander pardon » que la plupart des autres langages, comme discuté ici et ici.)

Gestion des exceptions Python

Python, comme tous les autres langages de programmation, a un moyen de gérer les exceptions qui se produisent lors de l’exécution d’un programme. Cela signifie que les exceptions sont gérées avec élégance : notre programme Python ne plante pas. Lorsqu’une erreur se produit lors de l’exécution d’un programme dont la syntaxe est correcte, Python utilise la try déclaration et except clause pour intercepter et gérer les exceptions.

Étant donné que la plupart des exceptions sont attendues, il est nécessaire d’être plus ciblé ou spécifique avec la gestion des exceptions dans nos programmes Python. La gestion spécifique des exceptions facilite le débogage des programmes.

Quelques exceptions Python standard

Python a une liste d’exceptions intégrées utilisées pour gérer différentes exceptions. Ci-dessous quelques exceptions Python intégrées.

Gestion des exceptions Python avec les instructions try et except

Le try et except les blocs sont utilisés pour la gestion des exceptions en Python. La syntaxe peut ressembler à ceci :

try:
    
except: 
    

Le try bloc contient une section de code qui peut déclencher une exception, tandis que le except Le bloc contient du code qui gère l’exception.

Prenons un exemple simple ci-dessous :

print(3/0)

Le code ci-dessus générera un message d’erreur à la fin du programme :

Traceback (most recent call last):
  File "/home/ini/Dev/Tutorial/sitepoint/exception.py", line 53, in <module>
    print(3/0)
ZeroDivisionError: division by zero

La ligne de code qui lève l’exception peut être gérée comme suit :

try:
    print(3/0)
except ZeroDivisionError:
    print("Cannot divide number by Zero")

Dans l’exemple ci-dessus, nous plaçons la première instruction d’impression dans le try bloc. Le morceau de code dans ce bloc déclenchera une exception, car diviser un nombre par zéro n’a aucun sens. Le except bloquera l’exception levée dans le try bloc. Le try et except les blocs sont souvent utilisés ensemble pour gérer les exceptions en Python. Au lieu du message d’erreur précédent qui a été généré, nous avons simplement « Impossible de diviser le nombre par zéro » imprimé dans la console.

Plusieurs exceptions Python

Il y a des cas où deux ou plusieurs except les blocs sont utilisés pour intercepter différentes exceptions en Python. Plusieurs blocs d’exception nous aident à intercepter des exceptions spécifiques et à les gérer différemment dans notre programme :

try:
    number = 'one'
    print(number + 1)
    print(block)
except NameError:
    print("Name is undefined here")
except TypeError:
    print("Can't concatenate string and int")

Voici la sortie du code ci-dessus :

Can't concatenate string and int

De l’exemple ci-dessus, nous avons deux except blocs spécifiant les types d’exceptions que nous voulons gérer : NameError et TypeError. La première déclaration d’impression dans le try bloc jette un TypeError exception. L’interpréteur Python vérifie chaque except clause pour trouver la classe d’exception appropriée, qui est gérée par la seconde except bloc. « Can’t concatenate string and int » est affiché dans la console.

La deuxième déclaration d’impression dans le try bloc est ignoré car une exception s’est produite. Cependant, tout code après le dernier except clause sera exécutée :

try:
    number = 'one'
    print(number + 1)
    print(block)
except NameError:
    print("Name is undefined here")
except TypeError:
    print("Can't concatenate string and int")

for name in ['Chris', 'Kwame', 'Adwoa', 'Bolaji']:
    print(name, end=" ")

Voici la sortie du code ci-dessus :

Can't concatenate string and int
Chris Kwame Adwoa Bolaji

Le for boucle après le try et except blocks est exécuté car l’exception a été gérée.

Un Python générique sauf

On peut avoir un générique except block pour intercepter toutes les exceptions en Python. Le générique except bloc peut être utilisé avec d’autres except blocs dans notre programme pour intercepter les exceptions non gérées. Il est logique de placer le plus générique except clause après tout spécifique except blocs. Cela se déclenchera lorsqu’une exception non gérée se produira. Révisons notre exemple précédent avec un général except bloc arrivant en dernier :

names = ['Chris', 'Kwame', 'Adwoa', 'Bolaji']
try:
    print(names[6])
    number = 'one'
    print(number + 1)
    print(block)
except NameError:
    print("Name is undefined here")
except TypeError:
    print("Can't concatenate string and int")
except:
    print('Sorry an error occured somewhere!')

for name in names:
    print(name, end=" ")

Voici la sortie du code ci-dessus :

Sorry an error occured somewhere!
Chris Kwame Adwoa Bolaji

Un IndexError une exception se produit, cependant, car elle n’est gérée dans aucun des except blocs. Le générique except block gère l’exception. L’instruction du bloc générique est exécutée et la for boucle après qu’elle soit également exécutée, avec la sortie respective imprimée dans la console.

La déclaration de relance

Parfois, dans nos programmes Python, nous pouvons vouloir lever des exceptions dans certaines conditions qui ne correspondent pas à nos exigences en utilisant le raise mot-clé. Le raise L’instruction se compose du mot-clé lui-même, d’une instance d’exception et d’un argument facultatif. Prenons un extrait de code ci-dessous :

def validate_password(password):
    if len(password) < 8:
        raise ValueError("Password characters less than 8")
    return password

try:
    user_password = input('Enter a password: ')
    validate_password(user_password)
except ValueError:
    print('Password should have more characters')

Le raise ValueError vérifie si le mot de passe respecte la longueur requise et déclenche l’exception spécifiée si la condition n’est pas remplie. Débordement de pile examine pourquoi il est acceptable de déclencher des exceptions au lieu de simplement imprimer sur la console :

La génération d’une erreur arrête l’ensemble du programme à ce stade (à moins que l’exception ne soit interceptée), alors que l’impression du message écrit simplement quelque chose dans stdout – la sortie peut être redirigée vers un autre outil, ou quelqu’un peut ne pas exécuter votre application à partir de la ligne de commande, et la sortie d’impression peut ne jamais être vue.

Levez une exception, pour déléguer la gestion de cette condition à quelque chose plus haut dans la pile d’appels.

La clause else

Le else clause peut être ajoutée à la norme try et except blocs. Il est placé après le except clause. Le else clause contient du code que nous voulons exécuter si la try l’instruction ne lève pas d’exception. Considérons le code suivant :

try:
    number = int(input('Enter a number: '))
    if number % 2 != 0:
        raise ValueError
except ValueError:
    print("Number must be even")
else:
    square = number ** 2
    print(square)

Lorsqu’un utilisateur saisit un nombre pair, notre code s’exécute sans lever d’exceptions. Puis le else la clause s’exécute. Nous avons maintenant le carré de notre nombre pair imprimé dans la console. Toutefois, les exceptions qui peuvent survenir dans le else la clause précédente n’est pas gérée par la précédente except bloc(s).

La clause finale

Le finally clause peut être ajoutée à try et except blocs et doivent être utilisés si nécessaire. Coder dans le finally La clause est toujours exécutée qu’une exception se produise ou non. Voir l’extrait de code ci-dessous :

try:
    with open('robots.txt', 'r', encoding='UTF-8') as f:
        first_line = f.readline()
except IOError: 
    print('File not found!')
else:
    upper_case = first_line.upper()
    print(upper_case.index('x'))
finally:
    print('The Python program ends here!')

Voici la sortie du code ci-dessus :

The Python program ends here!
Traceback (most recent call last):
  File "/home/ini/Dev/python/python_projects/extra.py", line 89, in <module>
    print(upper_case.index('x'))
ValueError: substring not found

Dans l’exemple ci-dessus, nous essayons de lire un robots.txt dossier dans le try clause. Puisqu’il n’y a pas d’exception déclenchée, le code dans le else clause est exécutée. Une exception est levée dans le else clause parce que la sous-chaîne x n’a pas été trouvé dans la variable upper_case. Lorsqu’il n’y a pas de clause except pour gérer une exception – comme on le voit dans l’extrait de code ci-dessus – le finally La clause est exécutée en premier et l’exception est relancée après.

Le Documentation Python l’explique ainsi :

Une exception peut se produire lors de l’exécution d’un except ou else clause. Encore une fois, l’exception est relancée après la finally clause a été exécutée.

Groupes d’exceptions

ExceptionGroup est devenu disponible dans Python 3.11. Il fournit un moyen de déclencher plusieurs exceptions non liées. La syntaxe préférée pour la gestion ExceptionGroup est except*. La syntaxe des groupes d’exceptions ressemble à ceci :

ExceptionGroup(msg, excs)

Lorsqu’ils sont initialisés, les groupes d’exceptions prennent deux arguments, msg et excs:

• msg: un message descriptif
• excs: une séquence de sous-groupes d’exception

Créons une instance de ExceptionGroup:

eg = ExceptionGroup('group one', [NameError("name not defined"), TypeError("type mismatch")])

Lors de l’instanciation d’un groupe d’exceptions, la liste des sous-groupes d’exceptions ne peut pas être vide. Nous allons créer une instance du groupe d’exceptions que nous avons créé précédemment :

raise eg

Voici la sortie du code ci-dessus :

+ Exception Group Traceback (most recent call last):
|   File "<string>", line 10, in <module>
  | ExceptionGroup: group one (2 sub-exceptions)
  +-+---------------- 1 ----------------
    | NameError: name not defined
    +---------------- 2 ----------------
    | TypeError: type mismatch
    +------------------------------------

La trace affichée montre tous les sous-groupes d’exceptions contenus dans le groupe d’exceptions.

Comme indiqué précédemment, ExceptionGroup est mieux géré avec le except* clause, car elle peut sélectionner chaque exception spécifique dans le groupe d’exceptions. Le générique except La clause ne traitera que le groupe d’exceptions comme une unité sans être spécifique.

Voir l’extrait de code ci-dessous :

try:
    raise ExceptionGroup('exception group', [NameError("name not defined"), TypeError("type mismatch"), ValueError("invalid input")])
except* NameError as e:
    print("NameError handled here.")
except* TypeError as e:
    print("TypeError handled here.")
except* ValueError:
    print("ValueError handled here.")

Voici la sortie de ce code :

NameError handled here.
TypeError handled here.
ValueError handled here.

Chaque except* La clause gère un sous-groupe d’exceptions ciblé dans le groupe d’exceptions. Tout sous-groupe non géré déclenchera à nouveau une exception.

Exceptions définies par l’utilisateur en Python

Les exceptions intégrées sont excellentes, mais des exceptions personnalisées peuvent être nécessaires pour notre projet logiciel. Python nous permet de créer des exceptions définies par l’utilisateur pour répondre à nos besoins. Le Documentation Python États:

Toutes les exceptions doivent être des instances d’une classe qui dérive de BaseException.

Les exceptions personnalisées sont dérivées en héritant de Python Exception classe. La syntaxe d’une exception personnalisée ressemble à ceci :

class CustomExceptionName(Exception):
    pass
try:
    pass
except CustomExceptionName:
    pass

Créons une exception personnalisée et utilisons-la dans notre code dans l’exemple suivant :

class GreaterThanTenError(Exception):
    pass

try:
    number = int(input("Enter a number: "))
    if number > 10:
        raise GreaterThanTenError
except GreaterThanTenError:
    print("Input greater than 10")
else:
    for i in range(number):
        print(i ** 2, end=" ")
finally:
    print()
    print("The Python program ends here")

Dans l’exemple ci-dessus, nous créons notre propre classe avec un nom d’exception appelé GreaterThanTenExceptionqui hérite de la Exception superclasse. Nous y plaçons du code qui peut déclencher une exception dans le try bloc. Le except block est notre gestionnaire d’exceptions. Le else La clause contient du code à exécuter si aucune exception n’est levée. Et enfin, le finally La clause s’exécute quel que soit le résultat.

Si un utilisateur de notre programme Python saisit un nombre supérieur à 10, un GreaterThanTenError sera relevé. Le except la clause gérera les exceptions, puis l’instruction d’impression dans la finally clause est exécutée.

Conclusion

Dans ce didacticiel, nous avons appris la principale différence entre les erreurs de syntaxe et les exceptions. Nous avons également vu qu’une erreur de syntaxe ou une exception perturbe le déroulement normal de notre programme.

Nous avons également appris que le try et except Les instructions sont la syntaxe standard pour gérer les exceptions en Python.

La gestion des exceptions est importante lors de la création d’applications réelles, car vous souhaitez détecter les erreurs et les gérer de manière appropriée. Python fournit une longue liste d’exceptions intégrées qui s’avèrent utiles lors de la gestion des exceptions.