Gestion des erreurs en Python

Pourquoi Gestion des erreurs en Python ?

La gestion des erreurs est une compétence essentielle pour tout développeur Python. Elle permet de rendre votre code plus robuste et de fournir des informations précieuses sur ce qui ne va pas lorsqu'une erreur se produit. Dans un environnement réel, les erreurs sont inévitables. Que ce soit la lecture d'un fichier qui n'existe pas ou une requête HTTP qui retourne une erreur 404, il est crucial de savoir comment traiter ces situations.

Un cas concret serait l'essayer d'ouvrir un fichier qui n'existe pas. Sans gestion des erreurs, le programme plante et ne peut plus continuer son exécution. Avec une gestion appropriée des erreurs, on peut afficher un message d'erreur amical à l'utilisateur ou enregistrer cette erreur pour un traitement posterior.

Prerequis

• Connaissances de base de Python (structures de données, boucles, fonctions)
• Compréhension des types de bases (integers, strings, floats)
• Compétences en programmation orientée objet
• Un environnement de développement intégré (IDE) comme PyCharm, VSCode, ou Sublime Text
• Python 3.x installé sur votre machine

Concepts fondamentaux

Exceptions et Erreurs Built-in

En Python, les erreurs sont représentées par des exceptions. Lorsque le programme rencontre une erreur qui ne peut pas être traitée, il lève une exception. Ces exceptions peuvent être de types intégrés comme ValueError, TypeError ou FileNotFoundError.

try:
    # Tentative d'ouvrir un fichier qui n'existe pas
    with open("inexistant.txt", "r") as file:
        content = file.read()
except FileNotFoundError as e:
    print(f"Erreur : {e}")

Blocs try-except

Le bloc try contient le code que vous pensez qu'il peut lever une erreur. Le bloc except s'exécute si une exception est levée dans le bloc try. Vous pouvez avoir plusieurs blocs except pour gérer différents types d'exceptions.

def diviser(x, y):
    try:
        result = x / y
        return result
    except ZeroDivisionError as e:
        print(f"Erreur : {e}")
        return None

print(diviser(10, 2))  # Affiche 5.0
print(diviser(10, 0))  # Affiche "Erreur : division by zero"

Blocs try-except-else

Le bloc else s'exécute si aucune exception n'est levée dans le bloc try.

def lire_fichier(nom_fichier):
    try:
        with open(nom_fichier, "r") as file:
            content = file.read()
    except FileNotFoundError as e:
        print(f"Erreur : {e}")
    else:
        print("Fichier lu avec succès")
        return content

print(lire_fichier("existant.txt"))  # Affiche "Fichier lu avec succès"
print(lire_fichier("inexistant.txt"))  # Affiche l'erreur

Blocs try-except-finally

Le bloc finally s'exécute peu importe ce qui arrive, même si une exception est levée. C'est utile pour nettoyer les ressources.

def lire_fichier(nom_fichier):
    file = None
    try:
        file = open(nom_fichier, "r")
        content = file.read()
        return content
    except FileNotFoundError as e:
        print(f"Erreur : {e}")
    finally:
        if file is not None:
            file.close()

print(lire_fichier("existant.txt"))  # Affiche le contenu du fichier et ferme le fichier

Mise en pratique : projet fil rouge

Nous allons créer un mini-projet de gestionnaire de tâches. Le but est d'avoir une application simple qui permet d'ajouter, afficher et supprimer des tâches.

Étape 1 : Création du fichier main.py

from tasks_manager import TasksManager

def main():
    manager = TasksManager()
    while True:
        print("\nGestionnaire de Tâches")
        print("1. Ajouter une tâche")
        print("2. Afficher les tâches")
        print("3. Supprimer une tâche")
        print("4. Quitter")
        choix = input("Choix : ")

        if choix == '1':
            task = input("Ajoutez une tâche : ")
            manager.add_task(task)
        elif choix == '2':
            tasks = manager.get_tasks()
            for i, task in enumerate(tasks):
                print(f"{i + 1}. {task}")
        elif choix == '3':
            index = int(input("Numéro de la tâche à supprimer : ")) - 1
            manager.remove_task(index)
        elif choix == '4':
            break
        else:
            print("Choix invalide")

if __name__ == "__main__":
    main()

Étape 2 : Création du fichier tasks_manager.py

class TasksManager:
    def __init__(self):
        self.tasks = []

    def add_task(self, task):
        self.tasks.append(task)

    def get_tasks(self):
        return self.tasks

    def remove_task(self, index):
        if 0 <= index < len(self.tasks):
            del self.tasks[index]
        else:
            print("Numéro de tâche invalide")

Étape 3 : Exécution du programme

python main.py

Erreurs frequentes et debugging

Erreur 1 : Indice de liste hors limites

tasks = ["Acheter du pain", "Faire la lessive"]
print(tasks[2])  # IndexError: list index out of range

## 
if 0 <= index < len(tasks):
    print(tasks[index])
else:
    print("Numéro de tâche invalide")

Erreur 2 : Division par zéro

result = 10 / 0  # ZeroDivisionError: division by zero

## 
try:
    result = 10 / y
except ZeroDivisionError as e:
    print(f"Erreur : {e}")

Erreur 3 : Fichier non trouvé

with open("inexistant.txt", "r") as file:  # FileNotFoundError: [Errno 2] No such file or directory: 'inexistant.txt'
    content = file.read()

## 
try:
    with open("inexistant.txt", "r") as file:
        content = file.read()
except FileNotFoundError as e:
    print(f"Erreur : {e}")

Pour aller plus loin

1. Gestion des exceptions personnalisées : Créer vos propres exceptions pour mieux structurer votre code et communiquer les erreurs.
2. Utilisation du module logging : Enregistrer les erreurs dans un fichier de journal au lieu d'afficher directement à l'utilisateur.
3. Traitement asynchrone avec asyncio : Gérer les exceptions dans des fonctions asynchrones pour une meilleure performance.

Défi pratique

Créez une application CLI simple qui permet d'ajouter et de retirer des éléments d'une liste, en utilisant la gestion des erreurs pour traiter les cas où l'utilisateur tente d'opérer sur un élément inexistant.