with : le nettoyage garanti with: guaranteed cleanup

f.close() écrit en dernière ligne d'une fonction a l'air de garantir la fermeture du fichier. Il ne le fait pas : une exception levée plus haut saute directement par-dessus cette ligne, sans jamais l'exécuter. with appelle __exit__ quoi qu'il arrive à l'intérieur du bloc — return anticipé, exception, ou sortie normale — le même contrat que finally, mais porté par l'objet lui-même. f.close() written on a function's last line looks like it guarantees the file gets closed. It doesn't: an exception raised further up jumps straight over that line, never running it. with calls __exit__ no matter what happens inside the block — early return, exception, or normal exit — the same contract as finally, but carried by the object itself.

Audience
Dev qui a vu un fichier ou une connexion rester ouverte après un crash au milieu d'une fonction Dev who's watched a file or connection stay open after a crash mid-function
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●●○
Date
Juil 2026 Jul 2026

Context managerswithExceptions

SommaireContents ·
№ 01CadrageFraming3 min

f.close() en dernière ligne ressemble à une garantie. Ce n'est qu'un espoir.f.close() on the last line looks like a guarantee. It's only a hope.

Le Vol. VI a fermé sur une question de mémoire ; ce volume ouvre sur une question de nettoyage. Le numéro 08 a montré que la syntaxe de Python passe par des dunders ; with n'y échappe pas — ce numéro met au travail les siens, __enter__ et __exit__. Le réflexe le plus répandu pour fermer un fichier consiste à appeler close() en dernière ligne d'une fonction. Ce réflexe suppose, à tort, que le contrôle atteindra toujours cette ligne. Toute exception levée entre l'ouverture et cette dernière ligne saute directement par-dessus elle — le fichier reste ouvert, sans qu'aucune erreur ne le signale jamais.Vol. VI closed on a question of memory; this volume opens on a question of cleanup. Issue 08 showed that Python's syntax runs through dunders; with is no exception — this issue puts its own, __enter__ and __exit__, to work. The most common reflex for closing a file is calling close() on a function's last line. That reflex wrongly assumes control will always reach that line. Any exception raised between the opening and that last line jumps straight over it — the file stays open, with no error ever signaling it.

Une exception saute directement par-dessus f.close()An exception jumps straight over f.close()
def traiter(chemin):
    f = open(chemin)
    donnees = f.read()
    resultat = 1 / len(donnees)     # lève ZeroDivisionError si le fichier est vide
    f.close()                        # cette ligne ne s'exécute JAMAIS dans ce cas
    return resultat

traiter("vide.txt")
# ZeroDivisionError -- et le fichier reste ouvert, personne n'a appelé close()
Le sous-réflexe du numéroThis issue's sub-reflex

Face à toute ressource ouverte — fichier, verrou, connexion — demande : ce nettoyage s'exécute-t-il seulement si tout se passe bien, ou même si une exception traverse le bloc ? S'il ne s'exécute que dans le premier cas, ce n'est pas une garantie.Facing any opened resource — file, lock, connection — ask: does this cleanup run only if everything goes well, or even if an exception crosses the block? If it only runs in the first case, it isn't a guarantee.

Ce n'est pas propre à open()It's not specific to open()

Le même problème touche un verrou (threading.Lock), une connexion réseau ou base de données, une transaction : toute ressource acquise puis censée être libérée par une dernière ligne de code, jamais garantie d'être atteinte.The same problem hits a lock (threading.Lock), a network or database connection, a transaction: any resource acquired and supposedly released by a final line of code, never guaranteed to be reached.

№ 02La surpriseThe surprise4 min

with ne déplace pas simplement close() : il l'exécute avant même que l'exception ne quitte le bloc.with doesn't just relocate close(): it runs it before the exception even leaves the block.

La surprise n'est pas que with évite l'exception — elle continue de se propager, identique, jusqu'à l'appelant. La surprise est que le nettoyage a déjà eu lieu au moment où elle sort du bloc. Le fichier ne reste jamais entrouvert le temps que l'exception remonte la pile d'appels : __exit__ s'exécute en premier, systématiquement, que le bloc se termine normalement, par un return anticipé, ou par une exception de n'importe quel type.The surprise isn't that with avoids the exception — it keeps propagating, unchanged, all the way to the caller. The surprise is that cleanup has already happened by the time it leaves the block. The file is never left half-open while the exception climbs the call stack: __exit__ runs first, systematically, whether the block ends normally, via an early return, or via an exception of any kind.

close() jamais atteint si l'exception survient avantclose() never reached if the exception occurs first
def traiter(chemin):
    f = open(chemin)
    donnees = f.read()
    resultat = 1 / len(donnees)   # ZeroDivisionError si fichier vide
    f.close()
    return resultat

# f reste ouvert si l'exception survient -- confirmé au chapitre 1
with ne rend pas le code plus court. Il rend le nettoyage indépendant de la façon dont le bloc se termine.with doesn't make the code shorter. It makes the cleanup independent of how the block ends.
№ 03La mécaniqueThe mechanics5 min

with est un try/finally — mais le contrat est porté par l'objet, pas répété à chaque appelant.with is a try/finally — but the contract is carried by the object, not repeated at every call site.

Un context manager n'est qu'un objet qui définit deux méthodes spéciales : __enter__, appelée à l'ouverture du bloc et dont la valeur de retour devient ce que reçoit as, et __exit__, appelée à la sortie — normale ou par exception — avec le type, la valeur et la traceback de l'exception en cours, ou trois None si tout s'est bien passé. with n'est rien de plus qu'un try/finally où __exit__ tient la place du bloc finally, mais écrit une seule fois dans la classe plutôt que dupliqué à chaque endroit où la ressource est utilisée.A context manager is just an object defining two special methods: __enter__, called on entering the block, whose return value becomes what as receives, and __exit__, called on exit — normal or via exception — with the current exception's type, value and traceback, or three Nones if all went well. with is nothing more than a try/finally where __exit__ stands in for the finally block, but written once in the class rather than duplicated everywhere the resource is used.

Ce que with fait réellement, une fois désucréWhat with actually does, once desugared
with open("data.txt") as f:
    contenu = f.read()

# se désucre, à peu près, en :

gestionnaire = open("data.txt")
f = gestionnaire.__enter__()          # __enter__ retourne CE QUI SERA "f"
try:
    contenu = f.read()
finally:
    gestionnaire.__exit__(*sys.exc_info())   # appelé QUOI QU'IL ARRIVE dans le try
    # sys.exc_info() : (None, None, None) si tout s'est bien passé,
    # ou (type, valeur, traceback) de l'exception en cours sinon
Un context manager écrit à la mainA hand-written context manager
class Chronometre:
    def __enter__(self):
        import time
        self.debut = time.perf_counter()
        return self                       # ce que "as x" reçoit

    def __exit__(self, exc_type, exc_value, traceback):
        import time
        ecoule = time.perf_counter() - self.debut
        print(f"écoulé : {ecoule:.4f}s")
        return False        # False (ou None) : NE PAS avaler l'exception

with Chronometre() as chrono:
    total = sum(range(10_000_000))
# "écoulé : 0.1234s" -- affiché même si le bloc avait levé une exception
Pourquoi __exit__ reçoit trois argumentsWhy __exit__ receives three arguments

Ces arguments permettent à __exit__ de réagir différemment selon le type d'exception — par exemple relâcher un verrou dans tous les cas, mais ne journaliser que certaines erreurs précises. Sa valeur de retour compte aussi : True supprime l'exception en cours, comme si elle n'avait jamais été levée — le sujet du prochain chapitre.These arguments let __exit__ react differently depending on the exception type — for example always releasing a lock, but only logging certain specific errors. Its return value matters too: True suppresses the current exception, as if it had never been raised — the subject of the next chapter.

№ 04Le piègeThe trap4 min

Un __exit__ qui renvoie la valeur d'une méthode de nettoyage peut avaler une exception sans le vouloir.An __exit__ that returns a cleanup method's value can swallow an exception without meaning to.

Le chapitre 3 a mentionné en passant que la valeur de retour de __exit__ compte : une valeur vraie supprime l'exception en cours, comme si elle n'avait jamais existé. C'est un outil volontairement puissant — et le piège le plus classique consiste à l'activer par accident. Écrire return self.deconnecter() semble anodin ; si deconnecter() renvoie True pour signaler son propre succès, ce True devient la valeur de retour de __exit__ — et n'importe quelle exception levée dans le bloc disparaît silencieusement, sans message, sans trace, sans que rien ne l'indique jamais.Chapter 3 mentioned in passing that __exit__'s return value matters: a truthy value suppresses the current exception, as if it had never existed. It's a deliberately powerful tool — and the most classic trap is triggering it by accident. Writing return self.deconnecter() looks harmless; if deconnecter() returns True to signal its own success, that True becomes __exit__'s return value — and any exception raised inside the block vanishes silently, with no message, no trace, nothing ever indicating it happened.

return self.deconnecter() renvoie accidentellement Truereturn self.deconnecter() accidentally returns True
class Connexion:
    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        return self.deconnecter()   # deconnecter() renvoie True si succès

    def deconnecter(self):
        print("déconnexion...")
        return True                  # "l'opération de nettoyage a réussi"

with Connexion() as c:
    resultat = 1 / 0        # ZeroDivisionError

print("on arrive ici !")    # ... et pourtant ce print s'exécute !
# __exit__ a renvoyé True (la valeur de deconnecter()), donc Python croit
# qu'on a VOULU avaler l'exception -- ZeroDivisionError a disparu SANS TRACE
Le réflexe à retenirThe reflex to keep

__exit__ ne devrait quasiment jamais renvoyer la valeur d'une autre méthode. Termine-le explicitement par return False, ou ne mets aucun return (None est également faux) — sauf le cas rare et volontaire où supprimer un type d'exception précis est exactement l'intention, auquel cas issubclass(exc_type, ...) doit être testé avant de renvoyer True.__exit__ should almost never return another method's value. End it explicitly with return False, or leave out the return entirely (None is also falsy) — except in the rare, deliberate case where suppressing a specific exception type is exactly the intent, in which case issubclass(exc_type, ...) should be checked before returning True.

№ 05Bilan & éditoWrap-up & editorial2 min

with ne raccourcit pas le code. Il transforme un espoir — « ça finira bien par se fermer » — en contrat.with doesn't shorten the code. It turns a hope — "it'll eventually get closed" — into a contract.

Ce numéro a montré qu'un close() en fin de fonction n'est qu'une convention silencieuse, jamais garantie face à une exception. with transforme cette convention en contrat, porté par deux méthodes spéciales — __enter__ et __exit__ — activées par Python lui-même, quoi qu'il arrive dans le bloc. Le piège du chapitre 4 a montré la contrepartie de ce pouvoir : __exit__ peut, par accident, supprimer une exception réelle en renvoyant une valeur vraie sans le vouloir — un bug d'autant plus dangereux qu'il ne laisse absolument aucune trace.This issue showed that a close() at a function's end is only a silent convention, never guaranteed against an exception. with turns that convention into a contract, carried by two special methods — __enter__ and __exit__ — activated by Python itself, no matter what happens inside the block. Chapter 4's trap showed this power's flip side: __exit__ can, by accident, suppress a real exception by unintentionally returning a truthy value — a bug all the more dangerous for leaving absolutely no trace.

NotionConceptCe qu'il faut en retenirWhat to take away
__enter__ / __exit__Appelées à l'ouverture et à la fermeture du bloc with, quelle que soit la façon dont il se termine.Called on opening and closing the with block, regardless of how it ends.
with = try/finallywith = try/finallyMême garantie que finally, mais portée par l'objet plutôt que dupliquée à chaque appelant.Same guarantee as finally, but carried by the object rather than duplicated at every call site.
Valeur de retour de __exit____exit__'s return valueUne valeur vraie supprime l'exception en cours ; toujours finir par return False, sauf intention explicite contraire.A truthy value suppresses the current exception; always end with return False unless explicitly intended otherwise.
Une ressource ne se ferme pas parce qu'on l'a écrit. Elle se ferme parce que quelqu'un — l'objet lui-même — s'y est engagé.A resource doesn't close because you wrote it down. It closes because someone — the object itself — committed to it.
Mot de l'éditeurFrom the editor

with garantit le nettoyage après une exception. Reste une question plus large : Python veut-il qu'on prévienne l'exception, ou qu'on la laisse survenir ?with guarantees cleanup after an exception. A broader question remains: does Python want you to prevent the exception, or let it happen?

Ce numéro a traité l'exception comme un accident dont il faut limiter les dégâts. Beaucoup de développeurs venus d'un langage plus défensif réflexent à vérifier avant d'agir — tester qu'une clé existe avant de la lire, qu'un fichier existe avant de l'ouvrir. Python encourage l'inverse : tenter l'opération directement, et attraper l'exception si elle survient. Ce style a un nom — EAFP, « il est plus facile de demander pardon que la permission » — et une contrepartie : un except trop large qui avale de vraies erreurs, exactement le risque révélé au chapitre 4 de ce numéro, mais généralisé à tout le langage.This issue treated the exception as an accident whose damage must be contained. Many developers coming from a more defensive language reflexively check before acting — testing that a key exists before reading it, that a file exists before opening it. Python encourages the opposite: attempting the operation directly, and catching the exception if it occurs. This style has a name — EAFP, "easier to ask forgiveness than permission" — and a counterpart: an overly broad except that swallows real errors, exactly the risk this issue's chapter 4 revealed, generalized to the whole language.

Prochain numéro : EAFP contre LBYL, l'exception comme flux. try/except/else/finally ; demander pardon plutôt que la permission ; l'except trop large qui avale les vrais bugs.Next issue: EAFP versus LBYL, the exception as control flow. try/except/else/finally; asking forgiveness rather than permission; the overly broad except that swallows real bugs.