Gestionnaires de contexte et l'instruction `with` (approfondissement)

Qu'est-ce qu'un gestionnaire de contexte ? Le protocole

Un gestionnaire de contexte est un objet Python qui définit un contexte d'exécution pour un bloc de code. Il garantit que certaines opérations sont effectuées avant et après l'exécution du bloc de code, même si des exceptions se produisent.

Le protocole de gestion de contexte repose sur deux méthodes spéciales :

• `__enter__(self)` : Cette méthode est appelée lorsque l'exécution entre dans le bloc `with`. Elle peut retourner une valeur qui sera affectée à la variable spécifiée après le mot-clé `as` (si une variable est spécifiée). C'est dans cette méthode que l'on effectue généralement l'acquisition de la ressource.
• `__exit__(self, exc_type, exc_value, traceback)` : Cette méthode est appelée lorsque l'exécution quitte le bloc `with`, que ce soit normalement ou en raison d'une exception. Elle est responsable de la libération des ressources. Les arguments `exc_type`, `exc_value`, et `traceback` contiennent des informations sur l'exception si une exception s'est produite.

Un objet qui implémente ces deux méthodes est un gestionnaire de contexte.

L'instruction with : simplifier la gestion des ressources

L'instruction `with` fournit une syntaxe concise pour utiliser les gestionnaires de contexte.

Syntaxe de base :

with gestionnaire_de_contexte as variable:
    # Bloc de code à exécuter dans le contexte
    # ...

• `gestionnaire_de_contexte` : Une expression qui évalue à un objet gestionnaire de contexte (un objet qui implémente les méthodes `__enter__` et `__exit__`).
• `as variable` : (Optionnel) Si cette clause est présente, la valeur retournée par la méthode `__enter__` du gestionnaire de contexte est affectée à la `variable`.
• Le bloc de code indenté après le `:` est exécuté dans le contexte géré par le gestionnaire de contexte.

Lorsque l'instruction `with` est exécutée, Python effectue les opérations suivantes :

1. L'expression `gestionnaire_de_contexte` est évaluée.
2. La méthode `__enter__` du gestionnaire de contexte est appelée.
3. Si la clause `as variable` est présente, la valeur retournée par `__enter__` est affectée à la `variable`.
4. Le bloc de code à l'intérieur du `with` est exécuté.
5. La méthode `__exit__` du gestionnaire de contexte est appelée, *quelle que soit la manière dont le bloc `with` se termine* (normalement, par une exception, par une instruction `return`, `break`, ou `continue`).

L'avantage principal de l'instruction `with` est qu'elle garantit que la méthode `__exit__` sera *toujours* appelée, même si une exception se produit dans le bloc `with`. Cela permet de s'assurer que les ressources sont correctement libérées.

Exemple classique : gestion des fichiers

L'exemple le plus courant d'utilisation de l'instruction `with` est la gestion des fichiers. Les objets fichiers en Python sont des gestionnaires de contexte.

Exemple :

with open("mon_fichier.txt", "r") as fichier:
    contenu = fichier.read()
    print(contenu)
# Le fichier est automatiquement fermé ici, même en cas d'exception

Dans cet exemple :

• `open("mon_fichier.txt", "r")` retourne un objet fichier (qui est un gestionnaire de contexte).
• La méthode `__enter__` de l'objet fichier (implicitement appelée) ouvre le fichier.
• La valeur retournée par `__enter__` (l'objet fichier lui-même) est affectée à la variable `fichier`.
• Le bloc de code à l'intérieur du `with` lit le contenu du fichier.
• La méthode `__exit__` de l'objet fichier (implicitement appelée) ferme le fichier, que le bloc `with` se termine normalement ou en raison d'une exception.

L'utilisation de `with` est la manière recommandée de gérer les fichiers en Python, car elle garantit que le fichier sera fermé, même en cas d'erreur.

Créer ses propres gestionnaires de contexte

Vous pouvez créer vos propres gestionnaires de contexte en définissant une classe qui implémente les méthodes `__enter__` et `__exit__`.

Exemple : Un gestionnaire de contexte simple qui mesure le temps d'exécution d'un bloc de code :

import time

class Chronometre:
    def __enter__(self):
        self.debut = time.time()
        return self  # On pourrait retourner une autre valeur si nécessaire

    def __exit__(self, exc_type, exc_value, traceback):
        self.fin = time.time()
        self.duree = self.fin - self.debut
        print(f"Durée d'exécution : {self.duree:.4f} secondes")

# Utilisation
with Chronometre() as chrono:
    # Code dont on veut mesurer le temps d'exécution
    time.sleep(1)  # Simule une opération qui prend du temps

print(chrono.duree) #On peut récupérer la durée

Dans cet exemple :

• La classe `Chronometre` implémente le protocole de gestion de contexte.
• `__enter__` enregistre le temps de début et retourne l'objet lui-même (qui sera affecté à la variable `chrono` dans le bloc `with`).
• `__exit__` enregistre le temps de fin, calcule la durée, et affiche la durée.

Le module contextlib : utilitaires pour les gestionnaires de contexte

Le module `contextlib` de la bibliothèque standard Python fournit des utilitaires pour créer et utiliser des gestionnaires de contexte.

Quelques fonctions utiles de `contextlib` :

• `@contextmanager` : Un décorateur qui permet de créer un gestionnaire de contexte à partir d'une fonction génératrice (utilisant `yield`). C'est une alternative à la création d'une classe avec `__enter__` et `__exit__`.
• `closing(thing)` : Crée un gestionnaire de contexte qui appelle la méthode `close()` de l'objet `thing` à la fin du bloc `with`. Utile pour les objets qui doivent être fermés mais qui n'implémentent pas le protocole de gestion de contexte.
• `suppress(*exceptions)` : Crée un gestionnaire de contexte qui supprime les exceptions spécifiées (similaire à un bloc `try...except` sans gestionnaire).
• `redirect_stdout(new_target)`, `redirect_stderr(new_target)` : Redirigent temporairement la sortie standard ou la sortie d'erreur.

Exemple (utilisation de `@contextmanager`) :

from contextlib import contextmanager
import time

@contextmanager
def chronometre():
    debut = time.time()
    try:
        yield  # La valeur après 'yield' est ce qui est retourné par __enter__ (ici, rien)
    finally:
        fin = time.time()
        duree = fin - debut
        print(f"Durée d'exécution : {duree:.4f} secondes")

# Utilisation
with chronometre():
    time.sleep(1)

Dans cet exemple, la fonction `chronometre` est une fonction génératrice. Le décorateur `@contextmanager` la transforme en gestionnaire de contexte. Le code avant le `yield` correspond à la méthode `__enter__`. Le code après le `yield` (dans le bloc `finally`) correspond à la méthode `__exit__`. La valeur après `yield` est ce qui serait retourné par `__enter__`.

Le module `contextlib` offre des outils pratiques pour simplifier la création et l'utilisation de gestionnaires de contexte.