Ce chapitre vous initiera à la gestion d'erreurs en Python, compétence cruciale pour créer des programmes fiables. Vous apprendrez à utiliser les blocs try-except, à identifier les différents types d'exceptions et à implémenter des stratégies de récupération. Cette approche préventive garantira la robustesse de vos applications.
La gestion d'erreurs est une compétence fondamentale en programmation qui permet d'anticiper, détecter et traiter les situations exceptionnelles pouvant survenir lors de l'exécution d'un programme.
En programmation, une erreur est un problème qui survient lors de l'exécution d'un programme et qui empêche son déroulement normal. Contrairement aux idées reçues, les erreurs ne sont pas nécessairement négatives - elles fournissent des informations précieuses pour comprendre ce qui ne fonctionne pas comme prévu.
# Exemple simple d'erreur courante nombre = input("Entrez un nombre: ") resultat = 10 / nombre # Erreur si l'utilisateur entre 0 ou du texte print(f"Le résultat est {resultat}")
Dans cet exemple, deux types d'erreurs peuvent survenir : une division par zéro si l'utilisateur entre 0, ou une erreur de type si l'utilisateur entre autre chose qu'un nombre.
On distingue généralement trois catégories d'erreurs en programmation :
# 1. Erreur de syntaxe (détectée à la compilation) # Cette ligne provoque une SyntaxError x = 5 y = 10 # print(x + y # Manque une parenthèse fermante # 2. Erreur logique (le programme fonctionne mais donne un mauvais résultat) # Calcul de la moyenne de deux nombres a = 10 b = 20 moyenne = a + b / 2 # Erreur: manque des parenthèses pour (a + b)/2 print(f"Mauvaise moyenne: {moyenne}") # Affiche 20.0 au lieu de 15.0 # 3. Erreur d'exécution (runtime error) liste = [1, 2, 3] # print(liste[5]) # IndexError: index hors limites
Les erreurs de syntaxe sont les plus faciles à corriger, tandis que les erreurs logiques peuvent être les plus difficiles à détecter car le programme s'exécute sans message d'erreur.
Une bonne gestion des erreurs est essentielle pour plusieurs raisons :
# Sans gestion d'erreurs def diviser(a, b): return a / b # Avec gestion d'erreurs def diviser_securise(a, b): try: resultat = a / b return resultat except ZeroDivisionError: print("Erreur: Division par zéro impossible") return None except TypeError: print("Erreur: Types de données incorrects") return None # Test des deux fonctions print("Sans gestion d'erreurs:") # print(diviser(10, 0)) # Provoque une erreur et arrête le programme print("Avec gestion d'erreurs:") print(diviser_securise(10, 0)) # Gère l'erreur et continue l'exécution print(diviser_securise(10, 2)) # Fonctionne normalement
La gestion d'erreurs permet de créer des applications plus robustes, prévisibles et professionnelles.
Ne pas gérer correctement les erreurs peut avoir plusieurs conséquences négatives :
# Exemple d'application critique sans gestion d'erreurs def sauvegarder_donnees(donnees, nom_fichier): # Ouvre un fichier pour sauvegarder des données importantes fichier = open(nom_fichier, 'w') fichier.write(donnees) fichier.close() print("Données sauvegardées avec succès") # Si le fichier ne peut pas être ouvert (disque plein, permissions, etc.) # le programme plantera sans terminer proprement # sauvegarder_donnees("données importantes", "/disque_plein/important.txt") # Version avec gestion d'erreurs def sauvegarder_donnees_securise(donnees, nom_fichier): try: fichier = open(nom_fichier, 'w') fichier.write(donnees) fichier.close() print("Données sauvegardées avec succès") return True except IOError as e: print(f"Erreur lors de la sauvegarde: {e}") print("Veuillez vérifier l'espace disque et les permissions") return False except Exception as e: print(f"Erreur inattendue: {e}") return False # Maintenant le programme peut gérer les erreurs et informer l'utilisateur succes = sauvegarder_donnees_securise("données importantes", "/disque_plein/important.txt") if not succes: print("L'application continue de fonctionner malgré l'erreur")
Les conséquences des erreurs non gérées incluent l'arrêt brutal de l'application, la perte de données, une expérience utilisateur médiocre, et des difficultés à diagnostiquer les problèmes.
En Python, les exceptions sont le mécanisme principal pour gérer les erreurs qui se produisent lors de l'exécution d'un programme. Elles permettent de séparer le flux normal d'exécution du traitement des situations exceptionnelles.
Une exception est un événement qui se produit pendant l'exécution d'un programme et qui interrompt le flux normal des instructions. Quand une erreur se produit, Python génère une exception qui peut être interceptée et traitée.
# Sans gestion d'exception nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") # Si l'utilisateur entre 0, une exception ZeroDivisionError est levée # Si l'utilisateur entre du texte, une exception ValueError est levée # Avec gestion d'exception try: nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") except ZeroDivisionError: print("Erreur: Division par zéro impossible!") except ValueError: print("Erreur: Vous devez entrer un nombre valide!") # Le programme continue son exécution même si une erreur se produit print("Fin du programme")
Le mécanisme try-except permet d'intercepter les exceptions et de fournir un traitement approprié sans interrompre l'exécution du programme.
Les exceptions en Python sont organisées dans une hiérarchie de classes. Toutes les exceptions héritent de la classe de base BaseException.
# Hiérarchie principale des exceptions en Python # BaseException # ├── SystemExit # ├── KeyboardInterrupt # ├── GeneratorExit # └── Exception # ├── ArithmeticError # │ ├── ZeroDivisionError # │ └── FloatingPointError # ├── AssertionError # ├── AttributeError # ├── EOFError # ├── ImportError # ├── LookupError # │ ├── IndexError # │ └── KeyError # ├── NameError # ├── OSError # │ ├── FileNotFoundError # │ └── PermissionError # ├── RuntimeError # ├── SyntaxError # ├── TypeError # ├── ValueError # └── ... (beaucoup d'autres) # Exemple d'héritage dans la capture d'exceptions try: # Code qui peut générer différentes exceptions liste = [1, 2, 3] print(liste[10]) # IndexError (hérite de LookupError) except LookupError as e: print(f"Erreur d'accès: {e}") # Cette clause except capturera aussi bien IndexError que KeyError # On peut capturer plusieurs types d'exceptions try: # Code susceptible de générer différentes exceptions pass except (ValueError, TypeError) as e: print(f"Erreur de valeur ou de type: {e}") except OSError as e: print(f"Erreur système: {e}")
Comprendre la hiérarchie des exceptions permet de capturer des groupes d'exceptions connexes avec une seule clause except, rendant le code plus concis et maintenable.
Python dispose de nombreuses exceptions intégrées. Voici les plus courantes :
# 1. ValueError : levée quand une fonction reçoit un argument du bon type mais valeur inappropriée try: nombre = int("abc") # Impossible de convertir "abc" en entier except ValueError as e: print(f"ValueError: {e}") # 2. TypeError : levée quand une opération est appliquée à un objet de type inapproprié try: resultat = "5" + 3 # Impossible d'additionner string et integer except TypeError as e: print(f"TypeError: {e}") # 3. IndexError : levée quand on tente d'accéder à un index qui n'existe pas dans une séquence try: liste = [1, 2, 3] element = liste[5] # Index 5 n'existe pas except IndexError as e: print(f"IndexError: {e}") # 4. KeyError : levée quand on tente d'accéder à une clé qui n'existe pas dans un dictionnaire try: dico = {"a": 1, "b": 2} valeur = dico["c"] # Clé "c" n'existe pas except KeyError as e: print(f"KeyError: {e}") # 5. ZeroDivisionError : levée quand on tente de diviser par zéro try: resultat = 10 / 0 # Division par zéro except ZeroDivisionError as e: print(f"ZeroDivisionError: {e}") # 6. FileNotFoundError : levée quand un fichier ou dossier est introuvable try: fichier = open("fichier_inexistant.txt", "r") except FileNotFoundError as e: print(f"FileNotFoundError: {e}") # 7. ImportError : levée quand un import échoue try: import module_inexistant except ImportError as e: print(f"ImportError: {e}")
Chaque type d'exception correspond à une situation d'erreur spécifique, ce qui permet un traitement ciblé et approprié.
Les messages d'erreur Python contiennent des informations précieuses pour identifier et corriger les problèmes. Apprendre à les lire est essentiel pour déboguer efficacement.
# Exemple de message d'erreur détaillé def calculer_moyenne(nombres): return sum(nombres) / len(nombres) def main(): donnees = [10, 20, 30, 40] moyenne = calculer_moyenne(donnees) print(f"Moyenne: {moyenne}") # Provoquons une erreur pour analyser le message donnees_vides = [] moyenne_vide = calculer_moyenne(donnees_vides) # ZeroDivisionError if __name__ == "__main__": main() # Le message d'erreur affiché sera : # Traceback (most recent call last): # File "messages_erreur.py", line 13, in <module> # main() # File "messages_erreur.py", line 10, in main # moyenne_vide = calculer_moyenne(donnees_vides) # File "messages_erreur.py", line 3, in calculer_moyenne # return sum(nombres) / len(nombres) # ZeroDivisionError: division by zero # Analyse du message d'erreur : # 1. "Traceback (most recent call last)" : indique le début de la trace d'exécution # 2. Les lignes suivantes montrent la pile d'appels dans l'ordre inverse # 3. Chaque ligne indique le fichier, le numéro de ligne et la fonction/méthode # 4. La dernière ligne montre le type d'exception et le message d'erreur # Pour mieux comprendre les erreurs, on peut utiliser le module traceback import traceback try: calculer_moyenne([]) except Exception as e: print("Exception attrapée:") print(f"Type: {type(e).__name__}") print(f"Message: {e}") print("Traceback complet:") traceback.print_exc() # Affiche la trace d'exécution complète
La lecture attentive des messages d'erreur et de la trace d'exécution (traceback) est cruciale pour identifier rapidement la source d'un problème et le corriger efficacement.
La structure try-except est le mécanisme fondamental de gestion des exceptions en Python. Elle permet d'intercepter et de traiter les erreurs qui pourraient survenir lors de l'exécution d'un programme.
La structure de base try-except permet d'encapsuler du code susceptible de générer des exceptions et de définir comment les traiter.
# Syntaxe de base try: # Code qui peut provoquer une exception nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") except: # Code exécuté si une exception est levée print("Une erreur s'est produite!") # Le programme continue après le bloc try-except print("Fin du programme") # Il est préférable de capturer des exceptions spécifiques try: nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") except ValueError: print("Erreur: Vous devez entrer un nombre valide!") except ZeroDivisionError: print("Erreur: Division par zéro impossible!") # Capturer plusieurs exceptions avec un tuple try: # Code susceptible de générer des exceptions pass except (ValueError, ZeroDivisionError): print("Erreur de valeur ou division par zéro!")
La structure try-except permet de séparer le code normal du code de gestion d'erreurs, rendant le programme plus lisible et maintenable.
Il est recommandé de capturer des exceptions spécifiques plutôt que toutes les exceptions, pour éviter de masquer des erreurs imprévues.
# Mauvaise pratique: capturer toutes les exceptions try: nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") except: print("Une erreur s'est produite") # Problème: on ne sait pas quelle erreur s'est produite # Bonne pratique: capturer des exceptions spécifiques try: nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") except ValueError: print("Erreur: Vous devez entrer un nombre valide!") except ZeroDivisionError: print("Erreur: Division par zéro impossible!") # Exemple avec gestion de fichier try: fichier = open("donnees.txt", "r") contenu = fichier.read() print(contenu) fichier.close() except FileNotFoundError: print("Erreur: Fichier introuvable!") except PermissionError: print("Erreur: Permission insuffisante pour lire le fichier!") except IOError: print("Erreur: Problème d'entrée/sortie avec le fichier!") # Capturer une exception spécifique et toutes les autres try: # Code susceptible de générer des exceptions pass except ValueError: print("Gestion spécifique des ValueError") except: print("Gestion de toutes les autres exceptions")
La capture d'exceptions spécifiques permet un traitement plus précis des erreurs et évite de masquer des problèmes inattendus.
Python permet de capturer plusieurs types d'exceptions dans une même clause except, soit en les regroupant dans un tuple, soit en utilisant plusieurs clauses except.
# Méthode 1: Capture avec un tuple try: nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") except (ValueError, ZeroDivisionError): print("Erreur: Entrée invalide ou division par zéro!") # Méthode 2: Capture avec plusieurs clauses except try: nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") except ValueError: print("Erreur: Vous devez entrer un nombre valide!") except ZeroDivisionError: print("Erreur: Division par zéro impossible!") # Capture avec gestion différente pour chaque exception try: liste = [1, 2, 3] index = int(input("Entrez un index: ")) valeur = liste[index] print(f"La valeur à l'index {index} est {valeur}") except ValueError: print("Erreur: L'index doit être un nombre entier!") except IndexError: print("Erreur: L'index est hors des limites de la liste!") # Capture groupée avec traitement commun try: # Code susceptible de générer différentes exceptions pass except (TypeError, ValueError, NameError) as e: print(f"Erreur de type, valeur ou nom: {e}") # Traitement commun pour ces types d'erreurs # Hiérarchie des exceptions: capturer une classe parent try: dico = {"a": 1, "b": 2} valeur = dico["c"] # KeyError except LookupError: # Classe parent de KeyError et IndexError print("Erreur d'accès à un élément!")
La capacité à capturer plusieurs types d'exceptions offre une grande flexibilité dans la gestion des erreurs, permettant soit un traitement commun pour plusieurs types d'erreurs, soit un traitement spécifique pour chaque type.
Python permet de capturer l'exception dans une variable pour accéder à ses informations (message, type, etc.) lors du traitement.
# Capture de l'exception avec 'as' try: nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") except ValueError as e: print(f"Erreur de valeur: {e}") print(f"Type d'erreur: {type(e).__name__}") except ZeroDivisionError as e: print(f"Erreur de division: {e}") print(f"Type d'erreur: {type(e).__name__}") # Accès aux attributs de l'exception try: open("fichier_inexistant.txt") except FileNotFoundError as e: print(f"Erreur: {e}") print(f"Fichier: {e.filename}") print(f"Code d'erreur: {e.errno}") print(f"Message: {e.strerror}") # Utilisation dans des blocs except multiples try: # Code susceptible de générer différentes exceptions valeur = int(input("Entrez un nombre: ")) resultat = 10 / valeur liste = [1, 2, 3] element = liste[valeur] except (ValueError, ZeroDivisionError, IndexError) as e: print(f"Une erreur s'est produite: {type(e).__name__}") print(f"Message: {e}") # Traitement spécifique selon le type d'erreur if isinstance(e, ValueError): print("C'était une erreur de valeur") elif isinstance(e, ZeroDivisionError): print("C'était une division par zéro") elif isinstance(e, IndexError): print("C'était un index hors limites") # Réutilisation de l'exception pour la relancer def traiter_fichier(nom_fichier): try: with open(nom_fichier, 'r') as f: contenu = f.read() return contenu except IOError as e: print(f"Erreur d'E/S: {e}") # On peut relancer l'exception si nécessaire raise # Relance la même exception # Utilisation avancée: logging des erreurs import logging try: # Code susceptible de générer une exception resultat = 10 / 0 except ZeroDivisionError as e: logging.error(f"Division par zéro: {e}", exc_info=True) print("Une erreur a été enregistrée dans les logs")
L'utilisation de la variable d'exception avec 'as' permet d'accéder aux informations détaillées de l'erreur, ce qui est essentiel pour un débogage efficace et pour fournir des messages d'erreur informatifs aux utilisateurs.
En plus des blocs try et except, Python propose deux blocs optionnels pour compléter la gestion des exceptions : else et finally. Ces blocs permettent d'organiser le code de manière plus claire et de garantir l'exécution de certaines opérations.
Le bloc else s'exécute uniquement si aucune exception n'est levée dans le bloc try. Il permet de séparer le code qui pourrait générer des exceptions du code qui devrait s'exécuter normalement.
# Syntaxe de base avec else try: # Code qui peut provoquer une exception nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre except ValueError: print("Erreur: Vous devez entrer un nombre valide!") except ZeroDivisionError: print("Erreur: Division par zéro impossible!") else: # Ce code s'exécute seulement si aucune exception n'est levée print(f"Le résultat est {resultat}") # Alternative sans else (moins claire) try: nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") # Mélange code risqué et code normal except ValueError: print("Erreur: Vous devez entrer un nombre valide!") except ZeroDivisionError: print("Erreur: Division par zéro impossible!") # Exemple avec lecture de fichier try: fichier = open("data.txt", "r") except FileNotFoundError: print("Fichier non trouvé!") else: # Le fichier est ouvert avec succès, on peut le traiter contenu = fichier.read() print(f"Contenu du fichier: {contenu}") fichier.close() # Fermeture dans le else # Avantage: séparation claire entre code risqué et code de succès
Le bloc else permet une séparation claire entre le code qui peut générer des exceptions et le code qui doit s'exécuter uniquement en cas de succès, améliorant la lisibilité et la maintenance.
Le bloc finally s'exécute toujours, qu'une exception ait été levée ou non. Il est généralement utilisé pour des opérations de nettoyage (fermeture de fichiers, libération de ressources, etc.).
# Syntaxe de base avec finally try: # Code qui peut provoquer une exception nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre print(f"Le résultat est {resultat}") except ValueError: print("Erreur: Vous devez entrer un nombre valide!") except ZeroDivisionError: print("Erreur: Division par zéro impossible!") finally: # Ce code s'exécute toujours, même si une exception est levée print("Exécution du bloc finally - Nettoyage terminé") # Exemple classique: gestion de fichier avec finally fichier = None try: fichier = open("important.txt", "r") contenu = fichier.read() # Traitement qui pourrait échouer nombre = int(contenu) resultat = 100 / nombre print(f"Résultat: {resultat}") except FileNotFoundError: print("Fichier non trouvé!") except ValueError: print("Le fichier ne contient pas un nombre valide!") except ZeroDivisionError: print("Division par zéro!") finally: # On s'assure que le fichier est fermé même en cas d'erreur if fichier is not None: fichier.close() print("Fichier fermé dans le bloc finally") # Utilisation avec with (équivalent mais plus propre) try: with open("important.txt", "r") as fichier: contenu = fichier.read() nombre = int(contenu) resultat = 100 / nombre print(f"Résultat: {resultat}") except FileNotFoundError: print("Fichier non trouvé!") except (ValueError, ZeroDivisionError) as e: print(f"Erreur de traitement: {e}") # Le with statement assure la fermeture automatique du fichier
Le bloc finally garantit que les opérations de nettoyage sont toujours exécutées, même en cas d'exception, ce qui est essentiel pour éviter les fuites de ressources.
L'ordre d'exécution des blocs try, except, else et finally suit des règles précises qui déterminent quel code s'exécute dans quelles conditions.
# Ordre d'exécution des différents blocs def demonstration_ordre(scenario): print(f"\n=== Scénario: {scenario} ===") try: print("1. Début du bloc try") if scenario == "exception": print("2. Levée d'une exception") raise ValueError("Exception de test") print("2. Exécution normale dans try") except ValueError as e: print(f"3. Bloc except: {e}") else: print("4. Bloc else (exécuté seulement si pas d'exception)") finally: print("5. Bloc finally (toujours exécuté)") print("6. Après le bloc try-except-else-finally") # Test avec différents scénarios demonstration_ordre("succès") # Aucune exception demonstration_ordre("exception") # Exception levée et attrapée # Cas avec exception non attrapée print("\n=== Scénario: exception non attrapée ===") try: print("1. Début du bloc try") raise RuntimeError("Exception non gérée") except ValueError: print("2. Bloc except (ne sera pas exécuté)") else: print("3. Bloc else (ne sera pas exécuté)") finally: print("4. Bloc finally (toujours exécuté, même avec exception non attrapée)") print("5. Ce code ne sera pas atteint à cause de l'exception non attrapée") # Règles d'ordre d'exécution: # 1. Le bloc try est toujours exécuté en premier # 2. Si une exception est levée dans try: # - Les clauses except correspondantes sont exécutées # - Le bloc else est sauté # 3. Si aucune exception n'est levée dans try: # - Les clauses except sont sautéess # - Le bloc else est exécuté # 4. Le bloc finally est TOUJOURS exécuté, quelle que soit la situation # 5. Si une exception n'est pas attrapée, le finally s'exécute quand même # avant que l'exception ne remonte dans la pile d'appels
Comprendre l'ordre d'exécution des différents blocs est essentiel pour écrire du code robuste et prévisible qui gère correctement les cas normaux et exceptionnels.
Les blocs else et finally sont particulièrement utiles dans des situations pratiques courantes où la gestion propre des ressources et la clarté du code sont importantes.
# Cas 1: Validation de données avec else def valider_et_traiter(donnees): try: # Validation qui peut échouer nombre = int(donnees) if nombre <= 0: raise ValueError("Le nombre doit être positif") except ValueError as e: print(f"Validation échouée: {e}") return None else: # Traitement seulement si la validation réussit resultat = nombre * 2 print(f"Traitement réussi: {resultat}") return resultat # Test valider_et_traiter("5") # Succès valider_et_traiter("abc") # Échec de conversion valider_et_traiter("-3") # Échec de validation # Cas 2: Gestion de connexion avec finally class ConnexionBDD: def __init__(self): self.connecte = False def connecter(self): print("Connexion à la base de données...") self.connecte = True def deconnecter(self): print("Déconnexion de la base de données...") self.connecte = False def executer_requete(self, requete): if not self.connecte: raise RuntimeError("Non connecté à la base de données") print(f"Exécution de: {requete}") # Simuler une erreur occasionnelle if "ERROR" in requete: raise RuntimeError("Erreur lors de l'exécution de la requête") return "Résultat de la requête" # Utilisation avec finally pour garantir la déconnexion bdd = ConnexionBDD() try: bdd.connecter() resultat = bdd.executer_requete("SELECT * FROM users") print(resultat) # Deuxième requête qui peut échouer resultat2 = bdd.executer_requete("SELECT ERROR") except RuntimeError as e: print(f"Erreur d'exécution: {e}") finally: # Garantir que la déconnexion a lieu même en cas d'erreur bdd.deconnecter() # Cas 3: Transaction avec rollback/commit def executer_transaction(): print("Début de la transaction") transaction_active = True try: # Opérations de la transaction print("Opération 1") print("Opération 2") # Simuler une erreur raise RuntimeError("Erreur lors de l'opération 3") print("Opération 3") except Exception as e: print(f"Erreur dans la transaction: {e}") print("Rollback de la transaction") transaction_active = False raise # Relance l'exception else: # Seulement si toutes les opérations réussissent print("Commit de la transaction") transaction_active = False finally: # Nettoyage final if transaction_active: print("Rollback dans le finally (transaction toujours active)") print("Nettoyage des ressources de transaction") # Test de la transaction try: executer_transaction() except RuntimeError: print("Transaction échouée")
Ces cas d'usage montrent comment les blocs else et finally permettent d'écrire du code plus robuste, plus lisible et plus maintenable dans des situations pratiques courantes.
Au-delà des bases de la structure try-except, Python offre des mécanismes avancés pour une gestion plus sophistiquée des exceptions, permettant un contrôle précis du flux d'exécution en cas d'erreurs.
Il est possible d'imbriquer des blocs try-except pour gérer différents niveaux d'erreurs ou pour effectuer un traitement d'erreur qui pourrait lui-même échouer.
# Exemple simple d'imbrication try: print("Niveau 1: Début") try: print("Niveau 2: Tentative de conversion") nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre except ValueError: print("Niveau 2: Erreur de valeur, tentative de récupération") # Tentative de récupération qui peut aussi échouer try: valeur_alternative = float(input("Entrez un nombre décimal: ")) resultat = 100 / valeur_alternative except ValueError: print("Niveau 3: Échec de la récupération") raise # Relance l'exception au niveau supérieur print(f"Résultat: {resultat}") except ZeroDivisionError: print("Niveau 1: Division par zéro détectée") except ValueError: print("Niveau 1: Erreur de valeur non récupérée") except Exception as e: print(f"Niveau 1: Exception inattendue: {e}") # Cas pratique: traitement de fichier avec journalisation def traiter_fichier(nom_fichier): try: print(f"Tentative d'ouverture de {nom_fichier}") try: # Tentative d'ouverture et lecture with open(nom_fichier, 'r') as f: contenu = f.read() # Tentative de traitement des données try: donnees = int(contenu.strip()) return donnees * 2 except ValueError: print("Erreur: le contenu n'est pas un nombre valide") return None except FileNotFoundError: print("Fichier non trouvé, tentative de création...") try: # Tentative de création du fichier with open(nom_fichier, 'w') as f: f.write("10") print("Fichier créé avec une valeur par défaut") return 20 # Valeur par défaut except IOError: print("Erreur: impossible de créer le fichier") return None except Exception as e: print(f"Erreur inattendue lors du traitement: {e}") return None # Test de la fonction resultat = traiter_fichier("donnees.txt") print(f"Résultat: {resultat}")
L'imbrication des blocs try-except permet une gestion fine des erreurs à différents niveaux d'abstraction, mais doit être utilisée avec modération pour éviter une complexité excessive.
L'instruction raise permet de relancer une exception actuellement traitée, soit pour la propager à un niveau supérieur, soit pour la transformer en une exception plus spécifique.
# Relance simple d'une exception def operation_risquee(): try: nombre = int(input("Entrez un nombre: ")) return 100 / nombre except (ValueError, ZeroDivisionError) as e: print(f"Erreur interceptée: {e}") # Journalisation ou traitement supplémentaire print("Journalisation de l'erreur...") # Relance de l'exception originale raise # Test try: resultat = operation_risquee() print(f"Résultat: {resultat}") except Exception as e: print(f"Erreur propagée: {e}") # Transformation d'exception def convertir_en_entier(valeur): try: return int(valeur) except ValueError as e: # Transformation en une exception plus spécifique raise TypeError(f"La valeur '{valeur}' ne peut pas être convertie en entier") from e # Chaînage d'exceptions avec 'from' def processus_complexe(donnees): try: # Tentative de traitement valeur = convertir_en_entier(donnees) return valeur * 2 except TypeError as e: # On enrichit l'exception avec plus de contexte raise RuntimeError(f"Échec du traitement des données: {donnees}") from e # Test du chaînage try: processus_complexe("abc") except RuntimeError as e: print(f"Exception principale: {e}") print(f"Exception d'origine: {e.__cause__}") # Recréation d'une exception différente def analyser_fichier(nom_fichier): try: with open(nom_fichier, 'r') as f: return f.read().strip() except FileNotFoundError: # On transforme l'exception en quelque chose de plus significatif raise ValueError(f"Le fichier {nom_fichier} est requis pour l'analyse") except IOError as e: # On garde le message original mais on change le type raise RuntimeError(f"Erreur d'accès au fichier: {e}")
La capacité à relancer ou transformer des exceptions permet de créer des abstractions propres où les erreurs de bas niveau peuvent être converties en erreurs plus significatives pour l'appelant.
La classe Exception est la classe de base pour la plupart des exceptions built-in. La capturer permet d'intercepter presque toutes les exceptions, mais cela doit être fait avec prudence.
# Capture générique avec Exception try: # Code qui peut générer diverses exceptions nombre = int(input("Entrez un nombre: ")) resultat = 100 / nombre liste = [1, 2, 3] element = liste[nombre] except Exception as e: print(f"Exception capturée: {type(e).__name__}: {e}") # Quand utiliser Exception? # 1. Dans un gestionnaire de haut niveau pour logger toutes les erreurs def main(): try: # Logique principale de l'application print("Démarrage de l'application...") # ... code de l'application ... except Exception as e: print(f"Erreur non gérée: {e}") # Journalisation détaillée import traceback traceback.print_exc() return 1 # Code d'erreur return 0 # Succès # 2. Pour nettoyer des ressources avant de propager l'erreur def operation_avec_ressources(): ressources = [] try: # Acquisition de ressources ressources.append("ressource1") ressources.append("ressource2") # Opération qui peut échouer nombre = int("abc") # ValueError except Exception as e: print("Nettoyage des ressources en cas d'erreur") # Nettoyage des ressources ressources.clear() # Propagation de l'erreur raise # 3. Pour éviter les arrêts brutaux (avec prudence!) def tache_critique(): try: # Code critique qui ne doit pas faire planter l'application print("Exécution de la tâche critique...") # Simulation d'une erreur raise RuntimeError("Erreur critique!") except Exception as e: print(f"Tâche critique a échoué mais l'application continue: {e}") # Journalisation mais pas d'arrêt # Mise en garde: ne pas abuser de Exception def mauvaise_pratique(): try: # Code avec des erreurs spécifiques open("fichier.txt") # FileNotFoundError except Exception: # Trop générique! print("Quelque chose s'est mal passé") # Problème: on ne sait pas quelle erreur s'est produite # et on pourrait masquer des erreurs importantes # Meilleure pratique: être spécifique quand c'est possible def bonne_pratique(): try: open("fichier.txt") except FileNotFoundError: print("Fichier non trouvé") except PermissionError: print("Permission refusée") except Exception as e: print(f"Erreur inattendue: {e}") # Journalisation détaillée pour investigation
Bien que puissante, la capture générique d'exceptions avec Exception doit être utilisée avec discernement, en privilégiant la capture d'exceptions spécifiques chaque fois que possible.
Il est parfois approprié d'ignorer délibérément certaines exceptions, mais cela doit être fait avec une grande prudence et seulement dans des cas bien spécifiques.
# Ignorer une exception avec pass def supprimer_fichier_silencieusement(nom_fichier): try: import os os.remove(nom_fichier) except FileNotFoundError: # Ignorer l'erreur si le fichier n'existe pas déjà pass except PermissionError: # Les autres erreurs doivent être propagées raise # Cas où ignorer une exception est acceptable: # 1. Lorsqu'une absence de ressource est acceptable def charger_configuration_facultative(chemin): try: with open(chemin, 'r') as f: return f.read() except FileNotFoundError: # Fichier de configuration facultatif absent return None # 2. Lorsqu'on teste l'existence d'une fonctionnalité def verifier_module_optional(): try: import module_optional return True except ImportError: # Module optionnel non installé return False # 3. Pour les opérations idempotentes def creer_repertoire_si_absent(chemin): try: import os os.makedirs(chemin) except FileExistsError: # Le répertoire existe déjà, c'est acceptable pass # CAS À ÉVITER: ignorer toutes les exceptions def mauvaise_fonction(): try: # Code avec des erreurs potentielles operation_importante() except:
Python permet de créer ses propres classes d'exception pour représenter des erreurs spécifiques à votre domaine d'application. Les exceptions personnalisées améliorent la clarté du code et facilitent la gestion d'erreurs métier.
Pour créer une exception personnalisée, il suffit de définir une nouvelle classe qui hérite de la classe Exception ou d'une de ses sous-classes.
# Exception personnalisée de base class MonErreur(Exception): """Exception personnalisée pour mon application""" pass # Utilisation simple def verifier_age(age): if age < 0: raise MonErreur("L'âge ne peut pas être négatif") if age > 150: raise MonErreur("L'âge semble invraisemblable") return age # Test try: verifier_age(-5) except MonErreur as e: print(f"Erreur personnalisée: {e}") # Exception avec initialisation personnalisée class ErreurValidation(Exception): """Exception pour les erreurs de validation""" def __init__(self, message, champ=None, valeur=None): self.message = message self.champ = champ self.valeur = valeur super().__init__(message) def __str__(self): if self.champ: return f"Erreur de validation sur {self.champ}: {self.message}" return self.message # Utilisation def valider_email(email): if "@" not in email: raise ErreurValidation( "L'email doit contenir un @", champ="email", valeur=email ) return email try: valider_email("invalid-email") except ErreurValidation as e: print(e) # Affiche: Erreur de validation sur email: L'email doit contenir un @ print(f"Valeur invalide: {e.valeur}")
Les exceptions personnalisées permettent de créer des erreurs significatives qui correspondent exactement aux besoins de votre application.
L'héritage permet de créer une hiérarchie d'exceptions personnalisées, organisant les erreurs par catégories logiques.
# Hiérarchie d'exceptions personnalisées class ErreurApplication(Exception): """Classe de base pour toutes les exceptions de l'application""" pass class ErreurValidation(ErreurApplication): """Erreurs de validation des données""" pass class ErreurEmailInvalide(ErreurValidation): """Email mal formaté""" pass class ErreurAgeInvalide(ErreurValidation): """Âge en dehors des limites acceptables""" pass class ErreurBaseDeDonnees(ErreurApplication): """Erreurs liées à la base de données""" pass class ErreurConnexionBDD(ErreurBaseDeDonnees): """Impossible de se connecter à la base de données""" pass # Utilisation de la hiérarchie def valider_utilisateur(email, age): if "@" not in email: raise ErreurEmailInvalide(f"Email invalide: {email}") if age < 0 or age > 150: raise ErreurAgeInvalide(f"Âge invalide: {age}") return True # Capture à différents niveaux de granularité try: valider_utilisateur("invalid", -5) except ErreurEmailInvalide as e: print(f"Erreur email spécifique: {e}") except ErreurValidation as e: print(f"Erreur de validation générale: {e}") except ErreurApplication as e: print(f"Erreur d'application: {e}") # Test avec différentes erreurs try: valider_utilisateur("test@example.com", -5) # ErreurAgeInvalide except ErreurValidation as e: print(f"Capture par la classe parent: {type(e).__name__}") # Utilisation avec isinstance try: valider_utilisateur("invalid", 25) # ErreurEmailInvalide except ErreurApplication as e: if isinstance(e, ErreurEmailInvalide): print("C'est une erreur d'email") elif isinstance(e, ErreurValidation): print("C'est une erreur de validation")
L'héritage permet d'organiser les exceptions en une hiérarchie logique, facilitant la capture groupée d'erreurs similaires tout en permettant un traitement spécifique lorsque nécessaire.
Les exceptions personnalisées peuvent contenir des informations supplémentaires pour faciliter le débogage et le traitement des erreurs.
# Exception avec des attributs personnalisés class ErreurApi(Exception): """Exception pour les erreurs d'API""" def __init__(self, message, url=None, code_status=None, reponse=None): self.message = message self.url = url self.code_status = code_status self.reponse = reponse super().__init__(message) def __str__(self): base = self.message if self.url: base += f" (URL: {self.url})" if self.code_status: base += f" [Status: {self.code_status}]" return base def afficher_details(self): """Méthode personnalisée pour afficher des détails""" print(f"Erreur API: {self.message}") if self.url: print(f"URL: {self.url}") if self.code_status: print(f"Status HTTP: {self.code_status}") if self.reponse: print(f"Réponse: {self.reponse}") # Utilisation def appeler_api(url): # Simulation d'une erreur d'API raise ErreurApi( "Service indisponible", url=url, code_status=503, reponse={"error": "maintenance"} ) try: appeler_api("https://api.example.com/data") except ErreurApi as e: print(f"Erreur: {e}") e.afficher_details() # Exception avec propriétés calculées class ErreurCalcul(Exception): """Exception pour les erreurs de calcul""" def __init__(self, operation, operandes, message): self.operation = operation self.operandes = operandes self.message = message super().__init__(message) @property def expression(self): """Retourne l'expression mathématique""" return f"{self.operandes[0]} {self.operation} {self.operandes[1]}" def __str__(self): return f"Erreur dans '{self.expression}': {self.message}" # Utilisation def diviser(a, b): if b == 0: raise ErreurCalcul( "/", [a, b], "Division par zéro" ) return a / b try: diviser(10, 0) except ErreurCalcul as e: print(e) # Erreur dans '10 / 0': Division par zéro print(f"Expression: {e.expression}") print(f"Opération: {e.operation}") print(f"Opérandes: {e.operandes}")
L'ajout d'informations personnalisées aux exceptions facilite le débogage et permet un traitement plus précis des erreurs en fournissant un contexte riche.
Voici les meilleures pratiques à suivre lors de la création et de l'utilisation d'exceptions personnalisées.
# 1. Nommage clair et explicite # ✔️ Bon class ErreurValidationEmail(Exception): pass # ❌ Mauvais (trop vague) class Erreur(Exception): pass # 2. Documentation avec docstring class ErreurBaseDeDonnees(Exception): """ Exception levée pour les erreurs liées à la base de données. Attributes: message (str): Description de l'erreur query (str): Requête SQL qui a échoué (optionnel) code (str): Code d'erreur de la base (optionnel) """ def __init__(self, message, query=None, code=None): self.message = message self.query = query self.code = code super().__init__(message) # 3. Héritage approprié # ✔️ Bon: hériter d'exceptions existantes quand c'est pertinent class ErreurFichierConfig(FileNotFoundError): """Fichier de configuration manquant""" pass # 4. Messages d'erreur informatifs class ErreurUtilisateurInexistant(Exception): def __init__(self, user_id): # ✔️ Message informatif message = f"L'utilisateur avec l'ID {user_id} n'existe pas" super().__init__(message) self.user_id = user_id # 5. Éviter les exceptions trop génériques # ❌ À éviter: une exception qui représente trop de choses class ErreurApplication(Exception): """Trop générique - à décomposer en exceptions plus spécifiques""" pass # 6. Utiliser des hiérarchies logiques class ErreurReseau(Exception): """Base pour les erreurs réseau""" pass class ErreurConnexion(ErreurReseau): """Impossible de se connecter""" pass class ErreurTimeout(ErreurReseau): """Délai de connexion dépassé""" pass # 7. Fournir des informations de contexte class ErreurValidation(Exception): def __init__(self, message, champ=None, valeur=None, regle=None): super().__init__(message) self.champ = champ self.valeur = valeur self.regle = regle def vers_dict(self): """Convertit l'erreur en dictionnaire pour sérialisation"""
Le débogage est une compétence essentielle en programmation. Python offre plusieurs outils et techniques pour identifier et corriger les erreurs dans votre code, depuis les méthodes simples jusqu'aux outils avancés.
La fonction print() est l'outil de débogage le plus simple et le plus accessible. Elle permet d'afficher des valeurs et de tracer l'exécution du programme.
# Débogage simple avec print() def calculer_moyenne(nombres): print(f"[DEBUG] calculer_moyenne appelée avec: {nombres}") if not nombres: print("[DEBUG] Liste vide, retourne 0") return 0 total = sum(nombres) count = len(nombres) print(f"[DEBUG] total={total}, count={count}") resultat = total / count print(f"[DEBUG] résultat={resultat}") return resultat # Test notes = [85, 92, 78, 90] moyenne = calculer_moyenne(notes) print(f"Moyenne: {moyenne}") # Techniques avancées avec print() def fonction_complexe(data): # Afficher le type et la valeur print(f"Type: {type(data)}, Valeur: {data}") # Afficher les attributs d'un objet if hasattr(data, '__dict__'): print(f"Attributs: {data.__dict__}") # Afficher la pile d'appels (pour les fonctions récursives) import traceback print("Pile d'appels:") traceback.print_stack(limit=3) # Débogage conditionnel DEBUG = True def debug_print(*args, **kwargs): if DEBUG: print("[DEBUG]", *args, **kwargs) def process_data(data): debug_print("Traitement des données:", data) # ... traitement ... debug_print("Traitement terminé") # Utilisation de f-strings pour un débogage avancé x = 10 y = 20 print(f"{x=}, {y=}, {x+y=}") # Affiche: x=10, y=20, x+y=30 # Débogage de structures complexes utilisateur = { "nom": "Alice", "age": 30, "emails": ["alice@example.com", "a.smith@work.com"] } print(f"Utilisateur: {utilisateur}") print("Utilisateur (pretty print):") import pprint pprint.pprint(utilisateur)
Bien que simple, print() reste un outil de débogage efficace pour comprendre le flux d'exécution et inspecter les valeurs des variables.
Le module logging offre un système de journalisation puissant et flexible, bien supérieur à l'utilisation de print() pour le débogage en production.
# Configuration de base du logging import logging # Configuration de base logging.basicConfig( level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler("debug.log"), logging.StreamHandler() ] ) # Création d'un logger logger = logging.getLogger(__name__) # Utilisation des différents niveaux de log def process_data(data): logger.debug("Début du traitement des données: %s", data) if not data: logger.warning("Aucune donnée à traiter") return None try: # Simulation de traitement result = [x * 2 for x in data] logger.info("Traitement réussi, %d éléments traités", len(result)) # Simulation d'une erreur if len(result) > 5: raise ValueError("Trop d'éléments") return result except Exception as e: logger.error("Erreur lors du traitement: %s", e, exc_info=True) return None # Test data = [1, 2, 3, 4, 5] process_data(data) process_data([]) process_data([1, 2, 3, 4, 5, 6, 7]) # Génère une erreur # Configuration avancée avec plusieurs handlers def setup_logging(): # Créer un logger logger = logging.getLogger("mon_application") logger.setLevel(logging.DEBUG) # Handler pour la console (niveau INFO et plus) console_handler = logging.StreamHandler() console_handler.setLevel(logging.INFO) console_format = logging.Formatter('%(levelname)s - %(message)s') console_handler.setFormatter(console_format) // Handler pour le fichier (niveau DEBUG et plus) file_handler = logging.FileHandler("app_debug.log") file_handler.setLevel(logging.DEBUG) file_format = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s' ) file_handler.setFormatter(file_format) // Ajouter les handlers au logger logger.addHandler(console_handler) logger.addHandler(file_handler) return logger // Utilisation du logger configuré app_logger = setup_logging() app_logger.debug("Message de debug (seulement dans le fichier)") app_logger.info("Message d'info (console et fichier)") app_logger.warning("Avertissement important") app_logger.error("Erreur critique", exc_info=True) // Logging avec contexte def traitement_utilisateur(user_id, data): // Ajouter des informations contextuelles extra = {'user_id': user_id} app_logger.info("Début du traitement utilisateur", extra=extra) try: // Traitement... app_logger.debug("Données traitées: %s", data, extra=extra) except Exception as e: app_logger.error("Erreur de traitement", exc_info=True, extra=extra) raise
Le module logging offre une solution professionnelle pour le débogage et la surveillance des applications, avec différents niveaux de gravité et une grande flexibilité de configuration.
Les assertions permettent de vérifier que des conditions sont respectées durant l'exécution du programme. Elles sont particulièrement utiles pour détecter des bugs during development.
// Assertions de base def calculer_racine_carree(x): // Vérification des préconditions assert x >= 0, "x doit être positif ou nul" assert isinstance(x, (int, float)), "x doit être un nombre" // Calcul resultat = x ** 0.5 // Vérification des postconditions assert resultat >= 0, "Le résultat doit être positif" assert abs(resultat * resultat - x) < 1e-10, "Calcul inexact" return resultat // Test des assertions try: calculer_racine_carree(25) // OK calculer_racine_carree(-1) // AssertionError except AssertionError as e: print(f"Assertion échouée: {e}") // Assertions pour les invariants de boucle def trier_liste(liste): // Vérifier que l'entrée est une liste assert isinstance(liste, list), "Input must be a list" // Algorithme de tri à bulles avec assertions n = len(liste) for i in range(n): // Invariant: les i derniers éléments sont triés for j in range(0, n-i-1): // Vérifier l'ordre avant l'échange if liste[j] > liste[j+1]: liste[j], liste[j+1] = liste[j+1], liste[j] // Assertion: vérifier que les éléments sont dans l'ordre assert liste[j] <= liste[j+1], f"Éléments non ordonnés: {liste[j]}, {liste[j+1]}" // Vérifier que les i+1 derniers éléments sont triés if i > 0: assert liste[-i-1] <= liste[-i], "Invariant de boucle violé" // Vérifier que la liste est triée assert all(liste[i] <= liste[i+1] for i in range(len(liste)-1)), "Liste non triée" return liste // Test du tri avec assertions liste_non_triee = [64, 34, 25, 12, 22, 11, 90] liste_triee = trier_liste(liste_non_triee) print(f"Liste triée: {liste_triee}") // Assertions pour les états d'objet class CompteBancaire: def __init__(self, solde_initial=0): self.solde = solde_initial self._verifier_invariant() def deposer(self, montant): assert montant > 0, "Le montant doit être positif" ancien_solde = self.solde self.solde += montant self._verifier_invariant() assert self.solde == ancien_solde + montant, "Incohérence de solde" def retirer(self, montant): assert montant > 0, "Le montant doit être positif" assert montant <= self.solde, "Solde insuffisant" ancien_solde = self.solde self.solde -= montant self._verifier_invariant() assert self.solde == ancien_solde - montant, "Incohérence de solde" def _verifier_invariant(self): // Invariant: le solde ne doit jamais être négatif assert self.solde >= 0, f"Solde négatif: {self.solde}" // Invariant: le solde doit être un nombre assert isinstance(self.solde, (int, float)), "Solde doit être un nombre" // Test du compte bancaire avec assertions compte = CompteBancaire(100) compte.deposer(50) compte.retirer(30) print(f"Solde final: {compte.solde}") // Désactivation des assertions en production (optionnel) // python -O script.py # Désactive les assertions
Les assertions sont un outil puissant pour détecter les erreurs de programmation during development, mais elles doivent être désactivées en production pour des raisons de performance.
Python offre plusieurs outils de débogage intégrés, dont le module pdb (Python Debugger) qui permet un débogage interactif.
// Utilisation de pdb (Python Debugger) import pdb def fonction_complexe(x, y): // Début du débogage pdb.set_trace() // Point d'arrêt resultat = 0 for i in range(x):
Une bonne gestion des erreurs ne se limite pas à la technique, elle implique également des principes de conception et des pratiques qui rendent le code plus robuste, maintenable et prévisible.
Savoir quand et comment gérer les exceptions est crucial pour écrire du code robuste. Voici les principes clés à suivre.
# 1. Gérer les exceptions au niveau approprié def lire_fichier_config(chemin): # Niveau bas: gestion technique des erreurs de fichier try: with open(chemin, 'r') as f: return f.read() except FileNotFoundError: # Ici on sait comment gérer un fichier manquant print(f"Fichier de configuration {chemin} non trouvé") return None except PermissionError: print(f"Permission refusée pour {chemin}") return None def charger_configuration(): # Niveau intermédiaire: logique métier contenu = lire_fichier_config("config.json") if contenu is None: # Utilisation d'une valeur par défaut print("Utilisation de la configuration par défaut") return {"port": 8080, "debug": False} try: # Tentative de parsing JSON import json return json.loads(contenu) except json.JSONDecodeError as e: print(f"Erreur de parsing JSON: {e}") raise ValueError("Configuration invalide") from e # 2. Ne gérer que les exceptions que vous pouvez traiter def calculer_statistiques(donnees): try: moyenne = sum(donnees) / len(donnees) return {"moyenne": moyenne} except ZeroDivisionError: # On sait gérer une liste vide print("Aucune donnée pour calculer la moyenne") return {"moyenne": 0} except TypeError: # On sait gérer un mauvais type de données print("Type de données incorrect") raise // On relève car on ne peut pas traiter cette erreur ici # 3. Utiliser des exceptions personnalisées pour les erreurs métier class ErreurValidation(Exception): pass def valider_utilisateur(utilisateur): if not utilisateur.get("nom"): raise ErreurValidation("Le nom est requis") if not utilisateur.get("email"): raise ErreurValidation("L'email est requis") return True # 4. Gestion différenciée selon le contexte def traiter_requete_utilisateur(donnees): try: valider_utilisateur(donnees) // Traitement principal... return {"success": True} except ErreurValidation as e: // Erreur métier: on informe l'utilisateur print(f"Validation échouée: {e}") return {"success": False, "error": str(e)} except Exception as e: // Erreur technique: on logue et on renvoie un message générique print(f"Erreur technique: {e}") return {"success": False, "error": "Erreur interne du serveur"} # 5. Éviter de gérer les exceptions trop tôt def fonction_bas_niveau(): // ❌ Mauvaise pratique: gestion trop précoce try: // Opération complexe... pass except Exception as e: print("Erreur") return None // On perd le contexte de l'erreur def fonction_bas_niveau_correction(): // ✅ Meilleure pratique: laisser remonter l'exception // Opération complexe... pass def fonction_haut_niveau(): try: fonction_bas_niveau_correction() except Exception as e: // Ici on a le contexte pour prendre une décision print(f"Erreur dans le traitement: {e}") // On peut décider de relancer, logger, ou traiter
La gestion des exceptions doit être stratégique : traiter les erreurs au niveau où on a le plus de contexte pour prendre une décision appropriée.
Le principe EAFP (Easier to Ask for Forgiveness than Permission) est un idiome Python qui favorise la tentative d'exécution suivie de la gestion des erreurs, plutôt que la vérification préalable des conditions.
# LBYL (Look Before You Leap) vs EAFP (Easier to Ask for Forgiveness than Permission) # ❌ Approche LBYL (vérification préalable) def diviser_lbyl(a, b): if b == 0: print("Division par zéro impossible") return None if not isinstance(a, (int, float)) or not isinstance(b, (int, float)): print("Les arguments doivent être des nombres") return None return a / b # ✅ Approche EAFP (gestion des exceptions) def diviser_eafp(a, b): try: return a / b except ZeroDivisionError: print("Division par zéro impossible") return None except TypeError: print("Les arguments doivent être des nombres") return None # Avantages de EAFP: # 1. Évite les conditions de course (race conditions) def verifier_et_supprimer_lbyl(chemin): import os if os.path.exists(chemin): // Condition de course possible os.remove(chemin) // Le fichier peut avoir été supprimé entre-temps def supprimer_eafp(chemin): import os try: os.remove(chemin) except FileNotFoundError: pass // Le fichier n'existe pas, c'est OK except PermissionError: print(f"Permission refusée pour {chemin}") // 2. Plus simple et plus lisible def acceder_element_lbyl(liste, index): if index < 0 or index >= len(liste): return None return liste[index] def acceder_element_eafp(liste, index): try: return liste[index] except IndexError: return None // 3. Meilleure pour les opérations atomiques def creer_repertoire_si_nexiste_lbyl(chemin): import os if not os.path.exists(chemin): os.makedirs(chemin) // Condition de race possible ici def creer_repertoire_si_nexiste_eafp(chemin): import os try: os.makedirs(chemin) except FileExistsError: pass // Le répertoire existe déjà // Cas où LBYL est préférable def traitement_couteux_avec_validation(donnees): // Validation préalable pour éviter un traitement coûteux if not est_valide(donnees): raise ValueError("Données invalides") // Traitement coûteux... resultat = traitement_long(donnees) return resultat // Bon usage de EAFP: accès aux dictionnaires config = {"port": 8080, "debug": True} // ❌ LBYL pour les dictionnaires if "host" in config: host = config["host"] else: host = "localhost" // ✅ EAFP pour les dictionnaires try: host = config["host"] except KeyError: host = "localhost" // ✅ Encore mieux: méthode get() host = config.get("host", "localhost") // EAFP avec context manager def lire_fichier_eafp(chemin): try: with open(chemin, 'r') as f: return f.read() except FileNotFoundError: print(f"Fichier {chemin} non trouvé") return None except IOError as e: print(f"Erreur E/S: {e}") return None
Le principe EAFP est un idiome fondamental en Python qui favorise la simplicité, la lisibilité et la robustesse face aux conditions de course.
Les exceptions silencieuses (celles qui sont attrapées et ignorées sans traitement approprié) sont une source courante de bugs difficiles à diagnostiquer.
# ❌ MAUVAISES PRATIQUES: exceptions silencieuses # 1. Except pass silencieux def mauvaise_fonction(): try: operation_risquee() except: pass // ❌ Exception complètement silencieuse # 2. Logging insuffisant def autre_mauvaise_fonction(): try: operation_risquee() except Exception as e: print("Erreur") // ❌ Information insuffisante # 3. Return None sans information def fonction_qui_echoue_silencieusement(): try: return operation_qui_peut_echouer() except Exception: return None // ❌ L'appelant ne sait pas pourquoi ça a échoué # ✅ BONNES PRATIQUES: gestion appropriée des erreurs # 1. Logging approprié import logging def bonne_fonction(): try: operation_risquee() except Exception as e: logging.error("Échec de operation_risquee: %s", e, exc_info=True) // Selon le contexte, on peut aussi: // - Relancer l'exception // - Retourner une valeur par défaut // - Lever une exception plus spécifique # 2. Exceptions spécifiques avec informations def traiter_fichier(chemin): try: with open(chemin, 'r') as f: return f.read() except FileNotFoundError: // ✅ On logue et on relance une exception métier logging.warning("Fichier %s non trouvé", chemin) raise ConfigurationError(f"Fichier de configuration {chemin} manquant") except PermissionError: logging.error("Permission refusée pour %s", chemin) raise ConfigurationError(f"Permission refusée pour {chemin}") // 3. Retour avec information d'erreur def operation_qui_peut_echouer(): try: result = operation_risquee() return {"success": True, "data": result} except ValueError as e: // ✅ On retourne une structure avec l'erreur return {"success": False, "error": str(e), "error_type": "VALUE_ERROR"} except Exception as e: logging.error("Erreur inattendue: %s", e) return {"success": False, "error": "Erreur interne", "error_type": "INTERNAL"} // 4. Utilisation de None avec prudence def trouver_utilisateur(user_id): try: return base_donnees.trouver(user_id) except NotFoundError: // ✅ OK de retourner None pour "non trouvé" logging.info("Utilisateur %s non trouvé", user_id) return None except DatabaseError as e: // ✅ Mais on logue les erreurs techniques logging.error("Erreur base de données: %s", e) raise // Et on les relance // 5. Context managers pour la gestion des ressources def copier_fichier(source, destination): try: with open(source, 'r') as src, open(destination, 'w') as dest: dest.write(src.read()) except IOError as e: // ✅ Les context managers assurent la fermeture des ressources logging.error("Erreur de copie: %s", e) raise // 6. Validation des entrées pour éviter les exceptions def calculer_moyenne(donnees): if not donnees: // ✅ Validation préalable plutôt qu'attendre ZeroDivisionError raise ValueError("La liste de données ne peut pas être vide") if not all(isinstance(x, (int, float)) for x in donnees): raise TypeError("Tous les éléments doivent être numériques") return sum(donnees) / len(donnees) // Cas où le silence est acceptable (rares) def supprimer_fichier_silencieux(chemin): import os try: os.remove(chemin) except FileNotFoundError: pass // ✅ Acceptable: le fichier n'existe pas, c'est le résultat souhaité except PermissionError: logging.warning("Permission refusée pour supprimer %s", chemin) // On logue quand même les autres erreurs
La gestion d'erreurs trouve son utilité dans des situations concrètes du développement d'applications. Voici des cas d'usage pratiques avec des implémentations détaillées.
La validation des entrées utilisateur est cruciale pour la sécurité et la robustesse des applications. Voici comment gérer les erreurs de validation efficacement.
# Classes d'exception pour la validation class ValidationError(Exception): """Exception de base pour les erreurs de validation""" def __init__(self, message, champ=None, valeur=None): self.message = message self.champ = champ self.valeur = valeur super().__init__(message) class EmailValidationError(ValidationError): """Erreur de validation d'email""" pass class PasswordValidationError(ValidationError): """Erreur de validation de mot de passe""" pass # Fonctions de validation def valider_email(email): """Valide une adresse email""" if not email or not isinstance(email, str): raise EmailValidationError("L'email est requis", "email", email) if "@" not in email: raise EmailValidationError("L'email doit contenir un @", "email", email) if len(email) > 254: raise EmailValidationError("L'email est trop long", "email", email) return email.lower().strip() def valider_mot_de_passe(mot_de_passe): """Valide un mot de passe""" if not mot_de_passe or not isinstance(mot_de_passe, str): raise PasswordValidationError("Le mot de passe est requis", "password", mot_de_passe) if len(mot_de_passe) < 8: raise PasswordValidationError( "Le mot de passe doit contenir au moins 8 caractères", "password", mot_de_passe ) if not any(c.isupper() for c in mot_de_passe): raise PasswordValidationError( "Le mot de passe doit contenir au moins une majuscule", "password", mot_de_passe ) if not any(c.isdigit() for c in mot_de_passe): raise PasswordValidationError( "Le mot de passe doit contenir au moins un chiffre", "password", mot_de_passe ) return mot_de_passe def valider_age(age): """Valide un âge""" try: age_int = int(age) except (ValueError, TypeError): raise ValidationError("L'âge doit être un nombre", "age", age) if age_int < 0: raise ValidationError("L'âge ne peut pas être négatif", "age", age) if age_int > 150: raise ValidationError("L'âge semble invraisemblable", "age", age) return age_int # Service de validation complet class ValidateurUtilisateur: """Service de validation des données utilisateur""" def __init__(self): self.erreurs = [] def valider_utilisateur(self, data): """Valide toutes les données utilisateur""" self.erreurs = [] resultat = {} # Validation email try: resultat["email"] = valider_email(data.get("email")) except EmailValidationError as e: self.erreurs.append({"champ": "email", "message": str(e)}) # Validation mot de passe try: resultat["password"] = valider_mot_de_passe(data.get("password")) except PasswordValidationError as e: self.erreurs.append({"champ": "password", "message": str(e)}) # Validation âge (optionnel) if "age" in data: try: resultat["age"] = valider_age(data.get("age")) except ValidationError as e: self.erreurs.append({"champ": "age", "message": str(e)}) return resultat def est_valide(self): return len(self.erreurs) == 0 def get_erreurs(self): return self.erreurs # Exemple d'utilisation def creer_utilisateur(data): validateur = ValidateurUtilisateur() donnees_validees = validateur.valider_utilisateur(data) if not validateur.est_valide(): raise ValidationError("Données invalides", erreurs=validateur.get_erreurs()) # Si validation réussie, créer l'utilisateur print("Utilisateur créé avec succès:", donnees_validees) return donnees_validees # Tests try: # Données valides utilisateur_valide = { "email": "test@example.com", "password": "Password123", "age": "25" } creer_utilisateur(utilisateur_valide) # Données invalides utilisateur_invalide = { "email": "invalid-email", "password": "short", "age": "abc" } creer_utilisateur(utilisateur_invalide) except ValidationError as e: print(f"Erreur de validation: {e}") if hasattr(e, 'erreurs'): for erreur in e.erreurs: print(f" - {erreur['champ']}: {erreur['message']}")
Cette approche de validation permet de collecter toutes les erreurs et de fournir un feedback complet à l'utilisateur, plutôt que de s'arrêter à la première erreur rencontrée.
La manipulation de fichiers est une source courante d'erreurs. Voici comment gérer robustement les opérations sur les fichiers.
# Exceptions personnalisées pour les fichiers class FichierError(Exception): """Exception de base pour les erreurs de fichiers""" pass class FichierNonTrouveError(FichierError): """Fichier introuvable""" pass class PermissionFichierError(FichierError): """Permission refusée sur le fichier""" pass class FormatFichierError(FichierError): """Format de fichier invalide""" pass # Utilitaire de lecture de fichier robuste def lire_fichier(chemin, encoding='utf-8'): """ Lit un fichier de manière robuste avec gestion d'erreurs complète Args: chemin (str): Chemin vers le fichier encoding (str): Encodage du fichier Returns: str: Contenu du fichier Raises: FichierNonTrouveError: Si le fichier n'existe pas PermissionFichierError: Si permission refusée FichierError: Pour autres erreurs de lecture """ try: with open(chemin, 'r', encoding=encoding) as f: return f.read() except FileNotFoundError: raise FichierNonTrouveError(f"Fichier non trouvé: {chemin}") except PermissionError: raise PermissionFichierError(f"Permission refusée: {chemin}") except UnicodeDecodeError as e: raise FichierError(f"Erreur d'encodage dans {chemin}: {e}") except OSError as e: raise FichierError(f"Erreur système avec {chemin}: {e}") except Exception as e: raise FichierError(f"Erreur inattendue avec {chemin}: {e}") # Utilitaire d'écriture de fichier robuste def ecrire_fichier(chemin, contenu, encoding='utf-8', mode='w'): """ Écrit dans un fichier de manière robuste Args: chemin (str): Chemin vers le fichier contenu (str): Contenu à écrire encoding (str): Encodage du fichier mode (str): Mode d'ouverture ('w' pour écriture, 'a' pour append) Raises: PermissionFichierError: Si permission refusée FichierError: Pour autres erreurs d'écriture """ try: with open(chemin, mode, encoding=encoding) as f: f.write(contenu) except PermissionError: raise PermissionFichierError(f"Permission refusée: {chemin}") except OSError as e: if e.errno == 28: # No space left on device raise FichierError(f"Espace disque insuffisant: {chemin}") else: raise FichierError(f"Erreur système avec {chemin}: {e}") except Exception as e: raise FichierError(f"Erreur inattendue avec {chemin}: {e}") # Gestionnaire de fichiers avec reprise sur erreur class GestionnaireFichiers: """Gestion robuste des opérations sur les fichiers""" def __init__(self, repertoire_backup=None): self.repertoire_backup = repertoire_backup def sauvegarder_fichier(self, chemin, contenu, max_tentatives=3): """Tente de sauvegarder un fichier avec plusieurs tentatives""" tentatives = 0 while tentatives < max_tentatives: try: ecrire_fichier(chemin, contenu) print(f"Fichier sauvegardé avec succès: {chemin}") return True except PermissionFichierError as e: tentatives += 1 print(f"Tentative {tentatives}/{max_tentatives}: {e}") self._attendre_retry(tentatives) except FichierError as e: print(f"Erreur irrécupérable: {e}") if self.repertoire_backup: self._sauvegarder_en_backup(chemin, contenu) return False print(f"Échec après {max_tentatives} tentatives") if self.repertoire_backup: self._sauvegarder_en_backup(chemin, contenu) return False def _attendre_retry(self, tentative): """Attendre avant une nouvelle tentative""" import time delai = 2 ** tentative # Backoff exponentiel print(f"Attente de {delai} secondes...") time.sleep(delai) def _sauvegarder_en_backup(self, chemin, contenu): """Sauvegarde de secours""" try: import os nom_fichier = os.path.basename(chemin) chemin_backup = os.path.join(self.repertoire_backup, nom_fichier) ecrire_fichier(chemin_backup, contenu) print(f"Sauvegarde de secours réussie: {chemin_backup}") except Exception as e: print(f"Échec de la sauvegarde de secours: {e}") # Exemple d'utilisation def traiter_fichiers_utilisateur(): gestionnaire = GestionnaireFichiers(repertoire_backup="/backup") fichiers_a_traiter = [ "/data/important.txt", "/data/config.json", "/data/report.csv" ] for chemin in fichiers_a_traiter: try: contenu = lire_fichier(chemin) # Traitement du contenu contenu_traite = contenu.upper() # Exemple de traitement # Sauvegarde succes = gestionnaire.sauvegarder_fichier(chemin, contenu_traite) if not succes: print(f"Attention: problème avec {chemin}") except FichierNonTrouveError: print(f"Fichier ignoré (non trouvé): {chemin}") except FichierError as e: print(f"Erreur avec {chemin}: {e}") except Exception as e: print(f"Erreur inattendue avec {chemin}: {e}") # Test if __name__ == "__main__": traiter_fichiers_utilisateur()
Cette implémentation montre comment gérer robustement les opérations sur les fichiers avec des tentatives de reprise, des sauvegardes de secours et une gestion d'erreurs détaillée.
Les applications réseau doivent gérer les pannes de connexion, les timeouts et les erreurs de service de manière élégante.
# Exceptions pour les erreurs réseau class ReseauError(Exception): """Exception de base pour les erreurs réseau""" pass class TimeoutReseauError(ReseauError): """Timeout réseau""" pass class ConnexionError(ReseauError): """Erreur de connexion""" pass class APIError(ReseauError): """Erreur d'API avec code HTTP""" def __init__(self, message, code_status=None, url=None, reponse=None): self.message = message self.code_status = code_status self.url = url self.reponse = reponse super().__init__(message) # Client API robuste avec gestion d'erreurs class ClientAPI: """Client HTTP avec gestion robuste des erreurs""" def __init__(self, base_url, timeout=10, max_retries=3): self.base_url = base_url.rstrip('/') self.timeout = timeout self.max_retries = max_retries def requete(self, endpoint, method='GET', params=None, data=None, headers=None): """ Execute une requête HTTP avec gestion d'erreurs et retry """ url = f"{self.base_url}/{endpoint.lstrip('/')}" for tentative in range(self.max_retries + 1): try: return self._executer_requete(url, method, params, data, headers) except (TimeoutReseauError, ConnexionError) as e: if tentative == self.max_retries: raise print(f"Tentative {tentative + 1}/{self.max_retries} échouée: {e}") self._attendre_retry(tentative + 1) except APIError as e: # Les erreurs 4xx/5xx ne bénéficient pas du retry if e.code_status and e.code_status >= 500: # On retry pour les erreurs serveur if tentative == self.max_retries: raise print(f"Tentative {tentative + 1}/{self.max_retries} échouée: {e}") self._attendre_retry(tentative + 1) else: raise def _executer_requete(self, url, method, params, data, headers): """Execute une seule requête HTTP""" import requests try: response = requests.request( method=method, url=url, params=params, json=data, headers=headers, timeout=self.timeout ) # Vérifier le statut HTTP if not response.ok: raise APIError( f"Erreur HTTP {response.status_code}", code_status=response.status_code, url=url, reponse=response.text ) return response.json() except requests.exceptions.Timeout: raise TimeoutReseauError(f"Timeout sur {url} après {self.timeout}s") except requests.exceptions.ConnectionError: raise ConnexionError(f"Erreur de connexion à {url}") except requests.exceptions.RequestException as e: raise ReseauError(f"Erreur réseau: {e}") except ValueError as e: raise APIError(f"Erreur de parsing JSON: {e}", url=url) def _attendre_retry(self, tentative): """Backoff exponentiel pour les retry""" import time delai = min(2 ** tentative, 60) # Max 60 secondes print(f"Attente de {delai} secondes avant retry...") time.sleep(delai) # Service utilisant l'API client class ServiceMeteo: """Service pour obtenir les données météo""" def __init__(self, api_key): self.client = ClientAPI
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!