Tutoriel Python Try-Except : Meilleures pratiques et exemples concrets

Lorsque le code Python rencontre des problèmes lors de son exécution, il génère souvent une exception. Si elles ne sont pas gérées, les exceptions entraîneront le blocage de votre programme. Cependant, avec les blocs d' try-except, vous pouvez les détecter, les récupérer de manière élégante et maintenir votre application en fonctionnement.

Ce tutoriel ne traite pas des bases des exceptions, car nous les avons déjà abordées dans notre guide guide sur la gestion des exceptions et des erreurs en Python. Au lieu de cela, nous allons ici nous intéresser de près à l' try-except e dans la pratique : comment structurer vos blocs, éviter les erreurs courantes et appliquer les meilleures pratiques qui rendent votre code plus fiable dans des scénarios réels.

À la fin, vous comprendrez non seulement comment fonctionne l' try-except, mais également comment l'utiliser à la manière Python, en écrivant un code de gestion des erreurs clair, facile à maintenir et prêt pour la production.

Si vous êtes encore en train d'apprendre Python, je vous recommande de consulter le parcours de compétences cursus de compétences « Python Programming Fundamentals », qui vous aidera à acquérir toutes les compétences essentielles.

Pourquoi se concentrer sur try-except ?

La gestion des erreurs en Python consiste essentiellement à concevoir des programmes capables de faire face à des situations imprévues. Bien qu'il existe de nombreux outils pour gérer les erreurs, l' try-except e constitue la base de l'approche Python.

Pourquoi est-ce si important ?

• Cela reflète la philosophie de Python. En Python, le style courant est «EAFP »( , « Il estplus facile de demander pardon que la permission ») . Au lieu de vérifier tout à l'avance (ce fichier existe-t-il ? cette entrée est-elle valide ? le serveur est-il disponible ?), il suffit d'essayer l'opération. Si cela échoue, vous détectez l'exception et la traitez. Cela permet d'obtenir un code plus court et plus clair.
• Il garantit le bon fonctionnement du code dans des environnements réels. Les données saisies par les utilisateurs risquent d'être incohérentes, des fichiers peuvent être perdus, les API peuvent rencontrer des défaillances et les réseaux peuvent subir des interruptions. Avec l' try-except, vous pouvez écrire du code qui ne s'effondre pas au premier problème, mais qui réagit de manière intelligente.
• Il est suffisamment flexible pour convenir aussi bien aux débutants qu'aux professionnels. Un débutant pourrait utiliser try-except pour détecter une exception ValueError lors de la conversion d'une entrée en nombre entier. Un système de production peut l'utiliser pour consigner les erreurs, réessayer les opérations ayant échoué ou générer des exceptions personnalisées qui facilitent le débogage.

C'est pourquoi cet article se concentre sur try-except. Maîtriser cette technique permet de distinguer l'écriture de scripts qui ne fonctionnent que dans des conditions idéales de l'écriture de logiciels robustes, faciles à maintenir et prêts à être mis en production.

Anatomie d'un bloc Try-Except

Dans sa forme la plus simple :

try:
    risky_thing()
except SomeError:
    handle_it()

Lorsque Python rencontre une erreur à l'intérieur du bloc ` try `, il passe au bloc ` except ` correspondant au lieu de provoquer le plantage du programme.

Vous pouvez également étendre ce modèle avec les clauses « else » et « finally » :

try:
    do_something()
except ValueError:
    print("Bad value!")
else:
    print("All good.")
finally:
    clean_up()

Voici un exemple de fonctionnement de base :

try:
    x = int(input("Enter a number: "))
except ValueError:
    print("That wasn’t a number.")
else:
    print("You entered", x)
finally:
    print("Done.")

La méthode ` except ` gère l'erreur, `else` s'exécute uniquement si tout a fonctionné, et `finally` s'exécute toujours, même si vous appuyez sur Ctrl-C ou quittez.

Vous pouvez maîtriser les principes fondamentaux du traitement des entrées utilisateur en Python, des invites de base aux techniques avancées de validation et de gestion des erreurs, grâce à notre guide Python User Input: Tutoriel sur la gestion, la validation et les meilleures pratiquesd' .

Gestion de plusieurs exceptions

Parfois, un seul except ne suffit pas. Différents chemins de code peuvent échouer de différentes manières, et tout intercepter avec un simple « except » n'est pas vraiment utile ; cela peut masquer des bogues et rendre le débogage difficile.

Supposons que vous souhaitiez convertir une valeur en nombre entier, puis la diviser. Voici ce qu'il est préférable dene pas faire :

try:
    result = int(user_input) / 2
except:
    print("Something went wrong.")

Cela couvre tout, y compris les éléments que vous n'aviez probablement pas l'intention de masquer, comme les fautes de frappe dans les noms de variables ou les exceptions inattendues qui indiquent de réels problèmes.

Soyez plutôt précis :

try:
    result = int(user_input) / 2
except ValueError:
    print("That wasn't a number.")
except ZeroDivisionError:
    print("Division by zero?")

Si vous avez plusieurs types d'exceptions qui doivent être traités de la même manière, vous pouvez les regrouper comme suit :

try:
    result = some_function()
except (TypeError, ValueError):
    print("Something was wrong with the data.")

De cette manière, vous avez toujours une vision claire des éventuels problèmes, sans avoir à répéter le même bloc à plusieurs reprises.

Il y a également except Exception, qui est plus efficace que except, mais qui reste néanmoins un peu trop large. Il est préférable de cibler les erreurs spécifiques auxquelles vous vous attendez.

Utilisation des blocs else et finally

Lorsque le code à l'intérieur du bloc ` try ` réussit et qu'aucune exception n'est levée, Python exécute le bloc ` else `. 

try:
    user_id = get_user_id()
except LookupError:
    print("User not found.")
else:
    print("Welcome, user", user_id)

Cela vous permet de séparer votre logique de gestion des exceptions du cheminement normal, ce qui facilite la lecture.

Ensuite, il y a finally. Peu importe ce qui s'est produit ; il fonctionne quoi qu'il arrive. Exception ? Fonctionne toujours. Aucune exception ? Fonctionne toujours. Le programme rencontre-t-il des difficultés avec la combinaison de touches Ctrl-C ? Fonctionne toujours. Idéal pour le nettoyage :

try:
    f = open("data.txt")
    process(f)
except IOError:
    print("Couldn’t open file.")
finally:
    f.close()

Veuillez noter que si le fichier ne s'ouvre pas, il est possible que f n'existe pas, par conséquent, soyez vigilant. Vous pouvez utiliser le gestionnaire de contexte de Python (with open(...) as f:) lorsque vous travaillez avec des fichiers. C'est plus sécurisé.

Si vous souhaitez acquérir des techniques clés, telles que la gestion des exceptions et la prévention des erreurs, afin de gérer efficacement l'exception KeyError dans Python, je vous recommande notre tutoriel sur les exceptions KeyError en Python et la manière de les résoudre .

Meilleures pratiques et pièges courants de Python try-except

Soyons honnêtes : rédiger des blocs d'try‑except s relève quelque peu de l'art. Lorsqu'ils sont correctement exécutés, ils empêchent votre programme de se bloquer. Si cela est mal effectué, les bogues peuvent être dissimulés si profondément que vous ne les remarquerez pas avant que votre application ne plante et que les utilisateurs ne se plaignent.

Voici quelques habitudes qu'il est utile de prendre :

Veuillez maintenir les blocs d'try s bien serrés. Veuillez éviter d'inclure une centaine de lignes de code dans une seule instruction try. Cela complique la tâche pour déterminer la cause du problème. Il est préférable de n'encapsuler que le code susceptible d'échouer :

# Good
try:
    value = int(data)
except ValueError:
    print("Couldn’t convert.")

# Bad
try:
    # Tons of unrelated logic
    value = int(data)
    do_more()
    something_else()
except ValueError:
    print("Huh?")

Évitez de vérifier les conditions avant d'effectuer l'action s'il est plus simple d'essayer de détecter l'erreur. Python a un terme pour cela : EAFP, Il est plus facile de demander pardon que la permission. Si vous vérifiez si un fichier existe et que vous l'ouvrez ensuite, vous créez une condition de concurrence. Au lieu de cela :

try:
    with open("file.txt") as f:
        content = f.read()
except FileNotFoundError:
    print("No file.")

Ce modèle permet d'éviter un problème courant où le fichier pourrait disparaître entre la vérification et l'appel d'ouverture. Veuillez essayer le produit. Si cela échoue, veuillez détecter l'échec.

De plus, évitez de masquer les erreurs en capturant tout et en ne prenant aucune mesure. Veuillez éviter de procéder de la manière suivante :

try:
    something()
except:
    pass

À moins que vous ne soyezvraiment sûr de ce que vous faites, c'est là que les insectes se cachent et se multiplient. Si vous devez demander le silence, soyez précis :

try:
    something()
except TimeoutError:
    # okay to ignore in this case
    pass

Veuillez consigner les erreurs quelque part. Les ignorer complètement signifie qu'à l'avenir, vous ne saurez pas ce qui a mal tourné.

Exceptions intégrées et exceptions personnalisées

Python intègre de nombreuses exceptions qui couvrent un nombre impressionnant de cas. Vous en avez probablement déjà rencontré quelques-uns :

• ValueError: lorsque quelque chose a le bon type mais une valeur non valide, comme int("hello").
• TypeError: lorsque vous tentez d'utiliser une opération sur un type incorrect, par exemple en additionnant une chaîne de caractères et un nombre.
• ZeroDivisionError: vous l'avez deviné, la division par zéro.
• FileNotFoundError: tentative d'ouverture d'un fichier qui n'existe pas.
• KeyError: lorsqu'une clé est absente dans un dictionnaire.

Ces fonctionnalités sont utiles et, dans la plupart des scripts ou applications, elles sont largement suffisantes. Cependant, il peut être nécessaire de générer une erreur plus descriptive, qui soit pertinente dans le contexte de votre projet, et pas seulement dans celui de Python.

Supposons que vous développiez une application qui traite les commandes en ligne et que vous souhaitiez générer une erreur lorsqu'un utilisateur tente d'acheter un article en rupture de stock. Vous pourriez simplement utiliser ValueError, mais cela est un peu générique. Cela n'indique pas à la personne qui lira votre code ce qui s'est produit.

C'est là que les exceptions personnalisées démontrent leur efficacité.

class OutOfStockError(Exception):
    pass

def check_inventory(product_id):
    if not in_stock(product_id):
        raise OutOfStockError(f"Product {product_id} is out of stock.")

En créant l'exception personnalisée, vous ajoutez une couche de sens. Vous vous accordez également davantage de contrôle ; vous pouvez vous concentrer uniquement sur cette situation spécifique :

try:
    check_inventory("shirt-001")
except OutOfStockError:
    print("Sorry, that item is sold out.")

C'est un détail, mais cela rend votre code plus facile à comprendre et à maintenir, en particulier dans les projets de grande envergure. De plus, cela fonctionne bien avec la journalisation et la surveillance, les noms d'exceptions personnalisés sont beaucoup plus faciles à rechercher qu'une vague « ValueError ».

Enregistrement, relance et chaînage des exceptions

Il y a un moment particulier qui survient lors du débogage : vous observez une trace, vous la fixez, et vous réalisez que vous ne comprenez pas pourquoi l' t échoué. C'est là que l'exploitation forestière entre en jeu. Il ne s'agit pas seulement d'enregistrer les erreurs, mais également de fournir à votre futur vous (ou à votre équipe) les indices nécessaires pour comprendre ce qui n'a pas fonctionné.

Supposons que vous détectiez une exception et que vous souhaitiez l'enregistrer avant de poursuivre :

import logging
logging.basicConfig(level=logging.ERROR)

try:
    do_something()
except ValueError as e:
    logging.error("Failed to do something: %s", e)
    raise

L'instruction « raise » à la fin est importante, car elle relance la même exception après l'avoir enregistrée. Sans cela, vous avez simplement ignoré l'erreur. Parfois, cela convient, mais généralement, ce n'est pas le cas.

Ensuite, il y a l'astuce de l'raise from. Cette option est utile lorsque vous traitez une erreur mais devez en générer une autre, sans perdre l'erreur d'origine. Python vous permet de les enchaîner :

try:
    connect_to_database()
except TimeoutError as e:
    raise ConnectionError("Database unavailable.") from e

De cette manière, le traceback fournit toutes les informations nécessaires. Vous obtenez le nouveau ConnectionError, mais vous voyez également l'TimeoutError qui l'a provoqué. 

Vous pouvez également masquer l'erreur d'origine (ce qui n'est généralement pas recommandé) de la manière suivante :

raise ConnectionError("Just this error, nothing else.") from None

Cependant, à moins d'avoir une raison valable, conserver l'intégralité de la chaîne permet à chacun de comprendre ce qui s'est mal passé et comment la situation s'est aggravée.

Vous pouvez découvrir les principes fondamentaux de la journalisation en Python grâce à notre tutoriel sur la journalisation en Python.

Exemples concrets et cas d'utilisation

C'est une chose de discuter de la gestion des exceptions de manière abstraite, mais cela devient plus clair lorsque vous la voyez dans du code réel.

Prenons l'exemple des données saisies par l'utilisateur. Demandez à toute personne ayant déjà développé un outil en ligne de commande ou un validateur de formulaire : les utilisateurs saisissent parfois les éléments les plus inhabituels. Souhaitez-vous obtenir un numéro ? Quelqu'un saisira « douze ». Ou veuillez coller un numéro de téléphone. Ou appuyez simplement sur Entrée. Cela arrive.

Au lieu de rédiger une longue liste de vérifications hypothétiques, vous pouvez procéder comme suit :

while True:
    user_input = input("Enter a number: ")
    try:
        number = int(user_input)
        break
    except ValueError:
        print("Try again with a whole number.")

Ce code ne panique pas lorsqu'il reçoit des données erronées. Il invite l'utilisateur à réessayer et répète l'opération jusqu'à ce que tout soit en ordre. Beaucoup plus propre que d'empiler des instructions if pour chaque cas particulier.

Voici un autre cas : lecture d'un fichier qui pourrait ne pas exister.

try:
    with open("config.json") as f:
        settings = f.read()
except FileNotFoundError:
    print("Missing config file. Using defaults.")
    settings = "{}"

Il n'est pas nécessaire de vérifier si le fichier est présent. Veuillez tenter de l'ouvrir, et si cela ne fonctionne pas, passez à autre chose. Si vous aviez vérifié au préalable (os.path.exists()), il est possible que quelqu'un d'autre ait supprimé le fichier entre le moment de la vérification et celui de l'ouverture. Il s'agit d'une condition de concurrence, ce n'est pas quelque chose que vous souhaitez déboguer.

Les requêtes réseau constituent une autre source importante d'exceptions. Il n'est pas toujours possible de se fier à Internet pour se comporter correctement. Les serveurs sont indisponibles. Les connexions sont interrompues. Le DNS rencontre des difficultés. Donc, si vous procédez de la manière suivante :

import requests

try:
    response = requests.get("https://example.com/data")
    response.raise_for_status()
except requests.exceptions.RequestException as e:
    print("Network problem:", e)

La classe de base RequestException permet de détecter de manière pratique presque tout ce que requests peut générer, des délais d'attente aux réponses incorrectes. Il n'est pas nécessaire de rédiger dix blocs d'except s distincts, sauf si vous souhaitez les traiter différemment.

Si vous développez des scripts d'automatisation ou des services backend, encapsuler la logique clé dans des blocs try-except peut faire la différence entre l'échec d'une tâche et la défaillance de l'ensemble du système. Vous souhaitez que les erreurs soient consignées, que les tâches récupérables soient réessayées et que celles qui ne le sont pas soient arrêtées proprement, sans traces de pile cryptiques défilant sans fin dans vos journaux.

Découvrez l'automatisation Python, notamment les concepts fondamentaux, les bibliothèques clés, le travail avec les données, l'utilisation des améliorations apportées par l'IA et les meilleures pratiques grâce à notre cours Python Automation : Guide complet du tutoriel .

Utilisations avancées de try-except en Python

À présent, vous avez probablement constaté à quel point try‑except peut être flexible. Cependant, la flexibilité présente des avantages et des inconvénients. Il est facile de passer de serviable à négligent sans le vouloir. Voici comment maintenir le contrôle.

Veuillez intercepter les exceptions spécifiques. Si vous avez connaissance de problèmes potentiels, veuillez les indiquer :

try:
    result = int(data)
except ValueError:
    # Only catches invalid numbers, not everything else under the sun

Veuillez éviter l'except. Veuillez ne pas procéder ainsi, sauf si vous manipulez un objet très particulier. Il détectera des éléments tels que KeyboardInterrupt, SystemExit et d'autres éléments que vous ne souhaitez probablement pas ignorer.

Veuillez utiliser les balises ` else ` et ` finally ` lorsque cela rend le code plus clair. Veuillez ne pas les inclure simplement parce qu'ils existent. Si le chemin normal de votre code est masqué dans un try, il serait peut-être préférable de le déplacer vers un else.

Veuillez veiller à ce que vos blocs d'try s restent concis. Plus vous incluez d'éléments, plus il est difficile de déterminer quelle ligne a causé l'erreur. Veuillez envelopper uniquement la partie susceptible de présenter un problème. 

Veuillez consigner les erreurs lorsque cela est nécessaire, en particulier en production. Même si vous ne rencontrez pas de problème, connaître la cause de l'échec (et le moment où il s'est produit) facilite considérablement le débogage ultérieur.

Les exceptions personnalisées ne sont pas obligatoires, mais elles peuvent être utiles. Si vous rencontrez des problèmes spécifiques à une application, veuillez définir vos propres erreurs. Ils peuvent rendre les journaux plus lisibles et votre code plus explicite.

Une dernière remarque : veuillez éviter d'utiliser les exceptions pour le contrôle de flux, sauf s'il n'existe pas de meilleure solution. Il est tentant d'écrire une logique telle que « essayez ceci ; si cela échoue, faites cela », mais si c'est quelque chose que vous vous attendez à ce qui se produise tout le temps, il existe probablement une méthode plus claire.

Conclusion

Comme je l'ai expliqué tout au long de cet article, la gestion des exceptions ne consiste pas seulement à éviter les plantages. Il s'agit d'écrire du code qui anticipe les problèmes, les gère sans difficulté et continue de fonctionner, ou s'arrête de manière appropriée. Il s'agit de la différence entre un utilisateur recevant un message utile et un utilisateur renvoyé vers le terminal avec une longue trace de débogage illisible.

Je vous recommande vivement d'approfondir vos connaissances sur les exceptions, à l'aide d'exercices pratiques, dans notre Chapitre « Catching Exceptions in Python » de notre cours OOP in Python.