img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Python les Bases
Chapitre 10 : Gestion d'erreurs de base

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.

Sommaire du Chapitre
Introduction à la gestion d'erreurs Qu'est-ce qu'une erreur en programmation ? Types d'erreurs : syntaxe, logique et runtime Importance de la gestion d'erreurs Conséquences des erreurs non gérées Les exceptions en Python Concept d'exception Hiérarchie des exceptions Python Exceptions courantes (ValueError, TypeError, IndexError, etc.) Lecture et interprétation des messages d'erreur La structure try-except Syntaxe de base try-except Capture d'exceptions spécifiques Capture de plusieurs types d'exceptions La variable d'exception (as e) Les blocs else et finally Le bloc else dans la gestion d'erreurs Le bloc finally pour le nettoyage Ordre d'exécution des blocs Cas d'usage pratiques Gestion avancée des exceptions Exceptions imbriquées (try-except dans try-except) Re-lancer une exception avec raise L'exception générique Exception Ignorer les exceptions (pass) Création d'exceptions personnalisées Définir ses propres classes d'exception Héritage des classes d'exception Ajouter des informations personnalisées Bonnes pratiques pour les exceptions personnalisées Techniques de débogage Utilisation de print() pour le débogage Le module logging pour tracer les erreurs Assertions avec assert Outils de débogage intégrés Bonnes pratiques et patterns Quand et comment gérer les exceptions Principe "Better ask forgiveness than permission" (EAFP) Éviter les exceptions silencieuses Documentation des exceptions dans les fonctions Applications pratiques Validation d'entrées utilisateur Gestion d'erreurs de fichiers Gestion d'erreurs réseau et API Exercices pratiques et cas d'étude

Introduction à la gestion d'erreurs

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.

Qu'est-ce qu'une erreur en programmation ?

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.

concept_erreur.py
# 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.

Types d'erreurs : syntaxe, logique et runtime

On distingue généralement trois catégories d'erreurs en programmation :

types_erreurs.py
# 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.

Importance de la gestion d'erreurs

Une bonne gestion des erreurs est essentielle pour plusieurs raisons :

importance_gestions.py
# 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.

Conséquences des erreurs non gérées

Ne pas gérer correctement les erreurs peut avoir plusieurs conséquences négatives :

consequences_erreurs.py
# 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.

Les exceptions en Python

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.

Concept d'exception

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.

concept_exception.py
# 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.

Hiérarchie des exceptions Python

Les exceptions en Python sont organisées dans une hiérarchie de classes. Toutes les exceptions héritent de la classe de base BaseException.

hierarchie_exceptions.py
# 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.

Exceptions courantes (ValueError, TypeError, IndexError, etc.)

Python dispose de nombreuses exceptions intégrées. Voici les plus courantes :

exceptions_courantes.py
# 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é.

Lecture et interprétation des messages d'erreur

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.

messages_erreur.py
# 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

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.

Syntaxe de base try-except

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_base.py
# 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.

Capture d'exceptions spécifiques

Il est recommandé de capturer des exceptions spécifiques plutôt que toutes les exceptions, pour éviter de masquer des erreurs imprévues.

exceptions_specifiques.py
# 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.

Capture de plusieurs types d'exceptions

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.

capture_multiple.py
# 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.

La variable d'exception (as e)

Python permet de capturer l'exception dans une variable pour accéder à ses informations (message, type, etc.) lors du traitement.

variable_exception.py
# 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.

Les blocs else et finally

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 dans la gestion d'erreurs

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.

bloc_else.py
# 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 pour le nettoyage

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.).

bloc_finally.py
# 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.

Ordre d'exécution des blocs

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_execution.py
# 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.

Cas d'usage pratiques

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_usage.py
# 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.

Gestion avancée des exceptions

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.

Exceptions imbriquées (try-except dans try-except)

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.

exceptions_imbriquees.py
# 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.

Re-lancer une exception avec raise

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.

relancer_exception.py
# 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.

L'exception générique Exception

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.

exception_generique.py
# 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.

Ignorer les exceptions (pass)

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_exceptions.py
# 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:
        
			

Création d'exceptions personnalisées

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.

Définir ses propres classes d'exception

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.

exceptions_personnalisees.py
# 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.

Héritage des classes d'exception

L'héritage permet de créer une hiérarchie d'exceptions personnalisées, organisant les erreurs par catégories logiques.

heritage_exceptions.py
# 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.

Ajouter des informations personnalisées

Les exceptions personnalisées peuvent contenir des informations supplémentaires pour faciliter le débogage et le traitement des erreurs.

informations_personnalisees.py
# 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.

Bonnes pratiques pour les exceptions personnalisées

Voici les meilleures pratiques à suivre lors de la création et de l'utilisation d'exceptions personnalisées.

bonnes_pratiques.py
# 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"""
	

Techniques de débogage

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.

Utilisation de print() pour le débogage

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.

debug_print.py
# 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 pour tracer les erreurs

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.

debug_logging.py
# 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.

Assertions avec assert

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.

debug_assert.py
// 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.

Outils de débogage intégrés

Python offre plusieurs outils de débogage intégrés, dont le module pdb (Python Debugger) qui permet un débogage interactif.

outils_debogage.py
// 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):

			

Bonnes pratiques et patterns

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.

Quand et comment gérer les exceptions

Savoir quand et comment gérer les exceptions est crucial pour écrire du code robuste. Voici les principes clés à suivre.

quand_gerer_exceptions.py
# 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.

Principe "Better ask forgiveness than permission" (EAFP)

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.

principe_eafp.py
# 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.

Éviter les exceptions silencieuses

Les exceptions silencieuses (celles qui sont attrapées et ignorées sans traitement approprié) sont une source courante de bugs difficiles à diagnostiquer.

exceptions_silencieuses.py
# ❌ 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
<

Applications pratiques

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.

Validation d'entrées utilisateur

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.

validation_utilisateur.py
# 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.

Gestion d'erreurs de fichiers

La manipulation de fichiers est une source courante d'erreurs. Voici comment gérer robustement les opérations sur les fichiers.

gestion_fichiers.py
# 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.

Gestion d'erreurs réseau et API

Les applications réseau doivent gérer les pannes de connexion, les timeouts et les erreurs de service de manière élégante.

gestion_reseau.py
# 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
		
			
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!

Revenir aux chapitres : Python les Bases | Allez au cours gratuits