Actrez des exceptions avec Try Sauf in Python

Les programmes Python échouent à l'exécution lorsque des opérations telles que l'accès au fichier, l'entrée d'analyse ou les appels réseau soulèvent des exceptions. Les manipuler avectry/ /exceptGardez votre application réactive, préserve un contexte utile et garantit le nettoyage.

Avant de commencer - Règles de base

• Assistez aux types d'exceptions les plus spécifiques que vous attendez (par exemple,ValueError,FileNotFoundError), pas une couverture.
• Utiliserelsepour le chemin de réussite etfinallyPour le code qui doit s'exécuter quoi qu'il arrive.
• Préférer les gestionnaires de contexte (with) pour les fichiers et autres ressources pour simplifier le nettoyage.
• Laissez les bogues inattendus se propager; Enregistrez-les et ré-essai au lieu de les avaler silencieusement.
• Réserver tous les gestionnaires (except Exceptionouexcept BaseException) Pour les limites de niveau supérieur où vous pouvez échouer rapidement ou signaler clairement.

Méthode 1 - Cattrez des exceptions spécifiques (recommandées)

Étape 1:Identifiez une opération risquée pour protéger.

raw = input("Select a fruit number (0-2): ")

Étape 2:Enveloppez l'opération danstry/ /exceptet gérer les types d'exceptions explicites.

try:
    selection = ["apple", "pear", "banana"][int(raw)]
    print("You chose:", selection)
except ValueError:
    print("Not a number.")
except IndexError:
    print("Choice out of range.")

Étape 3:Exceptions liées au groupe lorsque la récupération est identique.

try:
    selection = ["apple", "pear", "banana"][int(raw)]
except (ValueError, IndexError) as e:
    print("Invalid selection:", type(e).__name__)

Les exceptions spécifiques communes incluentOSErrorfamille (fichiers),ValueErroretTypeError(données),ZeroDivisionError(math), etKeyError/ /IndexError(Collections).

Méthode 2 - Utiliser d'autre et enfin pour séparer le succès et le nettoyage

Étape 1:AjouterelsePour le code qui ne devrait fonctionner que si rien échouait.

try:
    f = open("config.json", "r", encoding="utf-8")
except FileNotFoundError:
    print("No config file found.")
else:
    data = f.read()
    print("Loaded", len(data), "bytes.")
    f.close()

Étape 2:AjouterfinallyPour le nettoyage, cela doit se produire, que l'essai ait réussi ou non.

f = None
try:
    f = open("config.json", "r", encoding="utf-8")
    data = f.read()
except OSError as err:
    print("OS error:", err)
finally:
    if f:
        f.close()

Méthode 3 - Gardez votre point d'entrée pour échouer rapidement et enregistrer

Étape 1:Déplacer votre flux de travail dans unmain()fonction.

def main():
    # core workflow
    # ...
    return 0

Étape 2:Enveloppez l'appel dans un niveau de hauttry/ /exceptPour enregistrer les erreurs inattendues et arrêter le programme.

import logging, sys

logging.basicConfig(level=logging.INFO)

if __name__ == "__main__":
    try:
        code = main()
    except Exception:
        logging.exception("Unhandled error")
        sys.exit(1)
    sys.exit(code)

Étape 3:Renvoyez un code de sortie non zéro sur le non-signal des outils d'automatisation que l'exécution a échoué.

# in main(), return 1 or raise an exception when a critical step fails

Méthode 4 - Gérer les ressources avecwith(préféré au manuel enfin)

Étape 1:Remplacez le manuel Open / Fermer par un gestionnaire de contexte pour appliquer la libération opportune.

from pathlib import Path

try:
    with Path("data.txt").open("r", encoding="utf-8") as f:
        print(f.readline().strip())
except FileNotFoundError:
    print("Create data.txt first.")

Étape 2:Gardez uniquement les opérations risquées à l'intérieur du bloc protégé pour éviter d'attraper des erreurs non liées.

try:
    with open("image.png", "rb") as fh:
        blob = fh.read()
except OSError as e:
    print("File access failed:", e)
# decode/process blob in a separate block

Méthode 5 - Élévation, ré-essai et exceptions de chaîne pour des chemins d'erreur clairs

Étape 1:Soulevez une exception spécifique lorsqu'une condition préalable échoue.

def parse_age(s: str) -> int:
    if not s.isdigit():
        raise ValueError("age must contain only digits")
    age = int(s)
    if age < 0:
        raise ValueError("age cannot be negative")
    return age

Étape 2:Re-raise les erreurs inattendues après la connexion afin que les appelants puissent également les gérer.

import logging

try:
    do_risky_thing()
except OSError as err:
    logging.error("OS error: %s", err)
    raise

Étape 3:Exceptions de chaîne avecraise ... from epour préserver la cause profonde tout en ajoutant du contexte.

from pathlib import Path
import json

def load_json(path: str):
    try:
        text = Path(path).read_text(encoding="utf-8")
    except OSError as e:
        raise RuntimeError(f"Failed to read {path}") from e
    return json.loads(text)

Méthode 6 - Manipulation des fourre-tout aux limites (utilisez avec parcimonie)

Étape 1:Utiliserexcept Exception as ePour capturer toute erreur de non-système, les détails du journal et décider de s'arrêter ou de réessayer.

Plus de lecture:

import traceback

try:
    risky()
except Exception as e:
    print(f"Unexpected {type(e).__name__}: {e}")
    traceback.print_exc()  # full stack trace
    # decide: raise, return error, or abort

Étape 2:Seulement attraperBaseExceptionSi vous interceptez intentionnellementKeyboardInterruptouSystemExit, puis re-raise immédiatement.

try:
    service_loop()
except BaseException as e:
    print(f"Caught {type(e).__name__}; shutting down cleanly.")
    raise  # never swallow interrupts or SystemExit

Méthode 7 - Gérer plusieurs échecs avec un groupe d'exception et sauf * (Python 3.11+)

Étape 1:Élever unExceptionGroupLors de l'agrégation des erreurs à partir de travaux parallèles ou par lots.

def run_tests(tests):
    errors = []
    for t in tests:
        try:
            t.run()
        except Exception as e:
            e.add_note(f"Test {t.name} failed")
            errors.append(e)
    if errors:
        raise ExceptionGroup("Batch failures", errors)

Étape 2:Utiliserexcept*Pour gérer uniquement les types d'exceptions correspondants au sein du groupe.

try:
    run_tests(tests)
except* (ValueError, TypeError):
    print("Some data errors occurred.")
except* OSError:
    print("Some OS errors occurred.")

Modèles de dépannage rapide

• Analyse d'entrée: enveloppeint()oufloat()avecexcept ValueErroret reprocher l'utilisateur.
• Fichier E / S: CatchFileNotFoundError,PermissionError, ou génériqueOSError, et passez à un chemin de secours.
• Réseaux / appels API: Catch des délais d'expiration spécifiques à la bibliothèque / connexion et implémentez une réessayer délimitée avec Backoff.
• Enregistrez toujours le type d'exception et le message; Pour des traces complètes, utilisezlogging.exception()outraceback.print_exc().

Quelques modèles ciblés comme spécifiquesexceptclauses,else/ /finallyet les gardes de niveau supérieur rendront vos programmes Python plus résilients sans cacher de vrais bugs.