Python Try Except : expliqué avec des exemples

Python Try Except est une construction utilisée en Python pour gérer les exceptions avec élégance sans planter.

La gestion des exceptions rend le code de votre programme plus fiable et moins susceptible d’échouer. Cet article guide la gestion des exceptions et les scénarios courants dans lesquels la gestion des exceptions est idéale. En prime, nous expliquerons également comment déclencher des exceptions.

Qu’est-ce que la gestion des exceptions ?

Les exceptions sont des anomalies critiques et des erreurs qui surviennent lors de l’exécution d’un programme. Si elles ne sont pas gérées, les exceptions feront planter le programme. Par conséquent, la gestion des exceptions est un moyen de gérer les exceptions pour garantir qu’elles ne font pas planter le programme.

Voici un exemple pour illustrer ce qu’est une exception.

user_input = input("Enter a number: ")
num = int(user_input)
print("Your number doubled is:", num * 2)

À première vue, il semble qu’il n’y ait rien de mal avec le programme ci-dessus. Il reçoit les entrées de l’utilisateur et les convertit en un entier. Ensuite, il affiche l’entier fourni par l’utilisateur doublé.

Le programme fonctionne correctement si vous l’exécutez avec une valeur d’entrée de 5. Voir ci-dessous.

Mais supposons que vous ayez à nouveau exécuté le même programme. Seulement cette fois, au lieu d’utiliser 5 comme entrée, vous entrez la chaîne « bonjour ». Le programme va planter. La chaîne « hello » ne peut pas être convertie en un entier, donc une exception est levée et le programme plante.

Pourquoi des exceptions sont-elles générées et pourquoi devriez-vous les gérer ?

Des exceptions sont levées car nous décomposons souvent les programmes en fonctions lors de leur codage. Ces fonctions sont ensuite appelées pour effectuer différentes tâches.

Dans l’exemple ci-dessus, nous avons appelé la fonction input pour recevoir l’entrée de l’utilisateur, puis nous avons appelé la fonction int pour convertir la chaîne d’entrée en un entier, et enfin, nous avons appelé la fonction print pour afficher une sortie.

Cependant, au fur et à mesure que les fonctions exécutent leurs actions, elles peuvent rencontrer des erreurs qu’elles ne savent pas gérer. Dans ce cas, lesdites fonctions doivent cesser de fonctionner et communiquer qu’une erreur a été rencontrée. Pour communiquer, ils soulèveront des exceptions.

Le code appelé fonction est chargé d’écouter ces exceptions et de réagir de manière appropriée. Si cela n’est pas fait, le programme plantera après avoir rencontré des erreurs, comme nous l’avons vu dans l’exemple précédent.

Les exceptions sont donc essentiellement un mécanisme de communication qui permet à une fonction appelée d’envoyer un signal de détresse au code qui l’a appelée. Et la réaction évoquée à juste titre plus tôt est l’essence même de la gestion des exceptions.

Différents types d’exceptions

Il est important de savoir que toutes les exceptions ne sont pas identiques. Il existe différents types d’exceptions générées pour différentes erreurs rencontrées. Par exemple, si vous tentez de diviser un nombre par zéro, une ZeroDivisionError est générée. Et une TypeError est générée lorsque vous tentez une opération avec un type de données non valide. Voici une liste complète de types d’exceptions.

Comment gérer les exceptions

Comme expliqué précédemment, les exceptions sont les signaux de détresse émis par les fonctions que nous appelons. Notre code doit donc écouter ces signaux de détresse et réagir de manière appropriée lorsqu’ils sont émis. Pour gérer les exceptions de manière appropriée, nous utilisons les constructions Python Try Except. La structure de base de la construction est la suivante :

try:
    # Code to try and run
except:
    # Code to run if an exception is raised
finally:
    # Code to run in the end, whether or not an exception is raised

Comme vous pouvez le constater, la construction est composée de trois mots-clés expliqués ci-dessous :

essayer

Le mot-clé try marque le début d’une construction Python Try Except. De plus, il marque un bloc de code qui pourrait potentiellement déclencher une exception. Il s’agit d’une instruction adressée à l’interpréteur Python pour essayer d’exécuter du code dans le bloc. Si une exception est levée, le programme s’arrête immédiatement et saute pour exécuter le code écrit dans le bloc except.

sauf

Le mot-clé except marque le bloc de code qui sera exécuté si une exception est levée lors de l’exécution du bloc try. Vous pouvez définir plusieurs blocs except pour différents types d’exceptions qui pourraient être déclenchées. Ceci sera illustré plus tard.

enfin

Le mot-clé enfin est le troisième et dernier mot-clé utilisé dans Python Try Except. Il marque un bloc de code qui sera exécuté qu’une exception soit levée ou non.

Un exemple

Voici un exemple de la façon dont les mots-clés ci-dessus peuvent gérer une exception. Nous modifierons l’exemple précédent pour cela.

try:
    user_input = input("Enter a number: ")
    num = int(user_input)
    print("Your number doubled is:", num * 2)
except:
    print("Something went wrong")
finally:
    print("This code will be executed no matter what")

Si vous exécutez le code ci-dessus avec 5, une entrée valide, comme entrée, vous obtiendrez ce qui suit :

Et si vous l’exécutez avec « bonjour » comme entrée, vous obtiendrez ce qui suit :

Ainsi, lorsqu’aucune exception n’a été levée lors de l’exécution du code dans le bloc try, l’ordinateur est passé au bloc enfin. Cependant, lorsqu’une exception était déclenchée lors de l’exécution du code dans le bloc try, l’ordinateur se déplaçait vers le bloc except, puis vers le bloc enfin.

Vous pouvez également gérer des exceptions pour des types spécifiques d’erreurs. Par exemple, si vous souhaitez gérer les exceptions ValueError et KeyboardInterrupt d’une manière spécifique, vous pouvez modifier le code ci-dessus comme suit :

try:
    user_input = input("Enter a number: ")
    num = int(user_input)
    print("Your number doubled is:", num * 2)
except ValueError:
    print("Value can't be converted to int")
except KeyboardInterrupt:
    print("Received a keyboard interrupt")
except:
    print("Catch-all exception block")
finally:
    print("This code will be executed no matter what")

Dans le code ci-dessus, nous avons 3 blocs except. Le premier bloc except intercepte uniquement les exceptions ValueError, tandis que le second intercepte uniquement les exceptions KeyboardInterrupt. Le dernier bloc except n’a pas de type d’exception associé à écouter. En conséquence, il intercepte le reste des exceptions non détectées par les deux premiers blocs.

En exécutant le code ci-dessus, vous devriez obtenir un résultat similaire à celui-ci :

Lorsqu’une exception est déclenchée, vous pouvez obtenir plus d’informations sur l’exception dans l’objet exception. Pour accéder à l’objet d’exception, vous utilisez le mot-clé as. Il est utilisé comme suit :

try:
    user_input = input("Enter a number: ")
    num = int(user_input)
    print("Your number doubled is:", num * 2)
except ValueError as e:
    print("Value Error:", e)
except KeyboardInterrupt as e:
    print("Keyboard Interrupt:", e)
except Exception as e:
    print("Some other exception", e)

Comment lever des exceptions

Jusqu’à présent, nous avons eu affaire à des exceptions soulevées par d’autres fonctions. Cependant, il vous est également possible de déclencher des exceptions dans votre code. Pour déclencher une exception, nous utilisons le mot-clé raise. Nous spécifions également une classe qui représente le type d’exception que nous souhaitons déclencher et le message lisible par l’homme associé à l’exception.

Nous utilisons la classe Exception dans l’exemple suivant pour déclencher une exception générique. Ensuite, nous transmettons le message au constructeur de la classe.

raise Exception('Something went wrong')

Si vous exécutez l’extrait ci-dessus en tant que programme, vous obtiendrez un résultat similaire à celui-ci :

Vous pouvez également spécifier différents types d’exceptions. Par exemple, vous pouvez déclencher une exception TypeError lorsqu’une valeur a le mauvais type de données :

def double(x):
    if isinstance(x, int):
        return x * 2
    else
        raise TypeError('x should be an int')

Ou si la valeur spécifiée est en dehors des limites acceptables, vous pouvez générer une ValueError :

def say_hello(name):
    if name == '':
        raise ValueError('Value outside bounds')
    else:
        print('Hello', name)

Vous pouvez également créer vos types d’exceptions en sous-classant la classe Exception. Voici un exemple:

class InvalidHTTPMethod(Exception):
    pass

Dans l’exemple ci-dessus, nous avons créé une classe InvalidHTTPMethod, qui hérite de la classe Exception. Nous pouvons l’utiliser de la même manière que précédemment pour lever des exceptions :

raise InvalidHTTPMethod('Must be GET or POST')

Cas d’utilisation courants pour la gestion des exceptions

La gestion des exceptions est utilisée dans de nombreux scénarios. L’exemple précédent a montré comment il peut gérer les exceptions dues aux entrées de l’utilisateur. Cette section couvrira deux situations supplémentaires dans lesquelles la gestion des exceptions est utile. Il s’agit de la gestion des exceptions résultant d’échecs de requêtes réseau et de la gestion des exceptions lors de la lecture des fichiers.

Faire des requêtes réseau

Dans l’exemple ci-dessous, nous faisons une requête à Google. Nous écoutons les exceptions pour les gérer. Ces exceptions sont définies dans l’objet request.exceptions.

import requests

try:
    response = requests.get("https://google.com")

    # Check if the response status code is in the 200-299 range (successful response)
    if 200 <= response.status_code < 300:
        print("Request was successful!")
    else:
        print(f"Request failed with status code: {response.status_code}")
except requests.exceptions.RequestException as e:
    print(f"RequestException occurred: {e}")
except requests.exceptions.ConnectionError as e:
    print(f"ConnectionError occurred: {e}")
except requests.exceptions.Timeout as e:
    print(f"Timeout occurred: {e}")
except requests.exceptions.TooManyRedirects as e:
    print(f"TooManyRedirects occurred: {e}")
except requests.exceptions.HTTPError as e:
    print(f"HTTPError occurred: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

Lire des données à partir d’un fichier

Dans ce dernier exemple, nous lisons les données du fichier hello.txt. Nous traitons également les exceptions courantes qui peuvent être générées, telles que l’erreur FileNotFound et IOError.

try:
    with open(file_path, 'r') as file:
        data = file.read()
        print("File contents:")
        print(data)
except FileNotFoundError as e:
    print(f"FileNotFoundError occurred: {e}")
except IOError as e:
    print(f"IOError occurred: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

Conclusion

Cet article a exploré ce qu’étaient les exceptions et pourquoi elles ont été soulevées. Nous avons également établi que nous les traitons pour rendre le code plus fiable et éviter les plantages. Enfin, nous avons expliqué comment gérer les exceptions ainsi que comment déclencher certaines exceptions.

Ensuite, découvrez les types d’erreurs Python courants et comment les résoudre.