Réponse.

Les gestionnaires de contexte permettent d'automatiser et de contrôler l'exécution de blocs de code avec une finalisation garantie des ressources — par exemple, fermer automatiquement des fichiers, libérer des gestionnaires de transactions en base de données ou verrouiller/déverrouiller des flux. Dans la norme Python, ce paradigme a été introduit pour une gestion sécurisée et pratique des ressources externes sans avoir à suivre manuellement la phase finale du travail.

Histoire :

Avant l'introduction des gestionnaires de contexte, il était nécessaire d'appeler explicitement les méthodes close()/release() pour libérer les ressources, ce qui entraînait des erreurs si des exceptions se produisaient. Avec la structure with ... as ...:, Python a permis de définir explicitement "la portée de la ressource", en appelant automatiquement les méthodes pour initialiser et terminer le travail avec celle-ci.

Problème :

La gestion manuelle de la "fermeture" d'une ressource est dangereuse — si l'on oublie de faire close() (ou release()), les ressources resteront occupées jusqu'à la fin du processus ou même se bloqueront définitivement. Cela est particulièrement aigu pour les fichiers, les connexions réseau et les transactions en base de données.

Solution :

Les gestionnaires de contexte sont réalisés via des méthodes magiques enter() et exit(). Lors de l'entrée dans le bloc with, Python appelle enter, et lors de la sortie, exit, même si une exception s'est produite à l'intérieur du bloc.

Exemple de code :

class ManagedFile:
    def __init__(self, filename):
        self.filename = filename
        self.file = None
    def __enter__(self):
        self.file = open(self.filename, 'w')
        return self.file
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()
        # On peut supprimer l'exception en renvoyant True, généralement on renvoie False

with ManagedFile('demo.txt') as f:
    f.write('Hello, world!\n')
# le fichier est garanti être fermé

Caractéristiques clés :

Automatisation et sécurité de la libération des ressources externes
Interface universelle via enter/exit adaptée pour les fichiers, les transactions et les verrous
Permet de gérer les erreurs sans répéter le code try-finally

Questions pièges.

Peut-on utiliser la même instance de gestionnaire de contexte plusieurs fois consécutivement dans différents with ?

Non : généralement, la ressource est ouverte dans enter, libérée dans exit, et l'objet devient incorrect pour une réutilisation. Il vaut mieux créer un nouvel objet pour chaque bloc with.

Que faire si plusieurs ressources doivent être utilisées dans un seul with ?

On peut séparer les variables par une virgule :

with open('a.txt') as fa, open('b.txt') as fb:
    ...

ou utiliser contextlib.ExitStack pour des cas complexes.

Quelle est la différence entre l'écriture d'un gestionnaire de contexte comme une classe avec enter/exit et comme un générateur avec le décorateur @contextmanager ?

Le décorateur @contextmanager du module contextlib permet de réaliser le gestionnaire plus simplement, via yield :

from contextlib import contextmanager
@contextmanager
def open_file(name):
    f = open(name)
    try:
        yield f
    finally:
        f.close()

with open_file('file.txt') as f:
    ...

Erreurs typiques et anti-modèles

Ouverture/fermeture de la ressource en dehors de enter/exit
Exception capturée avec return True de exit — supprime complètement l'erreur
Cas mal géré d'une entrée répétée dans le contexte

Exemple de la vie quotidienne

Cas négatif

Un développeur ouvre un fichier via open(), écrit dedans, et oublie d'appeler close() — le fichier peut rester ouvert (surtout en cas d'erreurs), les données ne seront pas enregistrées.

Avantages :

Code minimal, sans "structure superflue"

Inconvénients :

Fuite de ressources, casse du programme lors d'une exécution longue, pannes inattendues

Cas positif

Utilisation systématique de with open() comme standard (ou ressource gérée personnalisée), le gestionnaire de contexte réalise correctement la libération de la ressource.