finally, return et le générateur qui lève finally, return, and the generator that raises

with garantissait le nettoyage ; l'except précis évitait d'avaler un vrai bug. Reste une dernière subtilité : que se passe-t-il quand finally et return se disputent la dernière parole dans une même fonction ? Et quand un générateur, jamais épuisé jusqu'au bout, tient encore un fichier ouvert — qui referme sa ressource, et comment ? with guaranteed cleanup; a precise except avoided swallowing a real bug. One last subtlety remains: what happens when finally and return both compete for the last word in the same function? And when a generator, never fully exhausted, is still holding a file open — who closes its resource, and how?

Audience
Dev qui a déjà écrit un finally: return et n'a jamais vérifié ce que devenait la valeur du try Dev who's already written a finally: return and never checked what happened to the try's return value
ChapitresChapters
5
LectureReading
≈ 19 min
NiveauLevel
●●●●
Date
Juil 2026 Jul 2026

finallyGénérateursGeneratorExit

SommaireContents ·
№ 01CadrageFraming3 min

return ne quitte pas la fonction tout de suite — il attend que finally ait fini de parler.return doesn't leave the function right away — it waits for finally to finish speaking.

Le numéro précédent a détaillé les quatre clauses de try/except/else/finally et leur condition d'exécution respective — finally s'exécute toujours, avait-on dit, exception ou pas. Reste une question que ce résumé laisse ouverte : que se passe-t-il quand un return se trouve DANS le try, et que finally s'exécute juste après ? Lequel a le dernier mot sur ce que la fonction retourne réellement ? La réponse tient en une ligne : return met sa valeur de côté, laisse finally s'exécuter jusqu'au bout, et ne rend la main qu'ensuite — ce qui ouvre la porte à un cas bien plus troublant que ce numéro va exposer.The previous issue detailed the four clauses of try/except/else/finally and their respective execution condition — finally always runs, we said, exception or not. One question that summary leaves open remains: what happens when a return sits INSIDE the try, and finally runs right after? Which one gets the last word on what the function actually returns? The answer fits in one line: return sets its value aside, lets finally run to completion, and only then hands back control — which opens the door to a far more troubling case this issue is about to expose.

finally s'intercale entre le return et la sortie réelle de la fonctionfinally slots in between the return and the function's actual exit
def statut():
    try:
        return "ok"
    finally:
        print("nettoyage")   # s'exécute AVANT que "ok" ne soit vraiment retourné

print(statut())
# affiche :
# nettoyage
# ok
# -- return ne "sort" pas immédiatement de la fonction : il met la valeur
# de côté, laisse finally s'exécuter, PUIS seulement rend la main.
La question qui suitThe question that follows

Ici, finally ne fait qu'imprimer — il ne touche pas à la valeur de retour. Mais s'il contenait, lui aussi, un return ?Here, finally only prints — it doesn't touch the return value. But what if it contained a return of its own?

№ 02La surpriseThe surprise4 min

Un return dans finally n'écrase pas que la valeur — il avale l'exception en cours de route.A return inside finally doesn't just override the value — it swallows the in-flight exception too.

La surprise dépasse largement le cas anodin du chapitre précédent. Si finally contient lui-même un return, ce return a la priorité absolue : il remplace la valeur que le try s'apprêtait à renvoyer — mais surtout, si une exception était en train de se propager au moment où finally s'est déclenché, ce return l'interrompt purement et simplement. L'exception ne remonte JAMAIS à l'appelant. Elle disparaît sans message, sans trace, comme si elle n'avait jamais existé — un except trop large du numéro précédent laissait au moins une trace dans le except ; ici, il n'y a même pas de except : le silence est total.The surprise goes well beyond the harmless case from the previous chapter. If finally itself contains a return, that return has absolute priority: it replaces the value the try was about to send back — but more importantly, if an exception was propagating at the moment finally kicked in, that return interrupts it outright. The exception NEVER reaches the caller. It vanishes with no message, no trace, as if it never existed — the overly broad except from the previous issue at least left a trace inside the except; here there isn't even an except: the silence is total.

Le ValueError disparaît sans laisser aucune traceThe ValueError disappears without a single trace
def verifier_solde(compte):
    try:
        if compte.solde < 0:
            raise ValueError("solde négatif")
        return "compte valide"
    finally:
        return "nettoyage terminé"   # écrase silencieusement la valeur ET l'exception

print(verifier_solde(compte_negatif))
# affiche : "nettoyage terminé"
# -- le ValueError a été levé... puis avalé. Aucune trace de l'exception.
# finally avait un return : il a eu le DERNIER mot, sur la valeur ET sur l'exception.
# Depuis Python 3.14 (PEP 765), ce return dans finally déclenche au moins
# un SyntaxWarning à la compilation -- le langage lui-même le déconseille.
Un finally censé garantir le nettoyage peut, avec un simple return, garantir aussi que l'erreur ne sera plus jamais vue. La garantie se retourne contre elle-même.A finally meant to guarantee cleanup can, with a plain return, also guarantee the error is never seen again. The guarantee turns against itself.
№ 03La mécaniqueThe mechanics5 min

Fermer un générateur, c'est lever une exception à l'intérieur — au point exact où il était suspendu.Closing a generator means raising an exception inside it — at the exact point where it was suspended.

Un générateur suspendu par yield n'est ni terminé ni inerte : il attend, avec tout son état local intact, y compris un éventuel try/finally en cours. Quand on appelle gen.close() — ou que le garbage collector le fait à sa place — Python lève GeneratorExit exactement à l'endroit du yield où le générateur était suspendu. Si ce yield se trouve dans un try, le finally associé s'exécute normalement. contextlib.contextmanager s'appuie sur la même propriété — un yield placé dans un try/finally — mais reprend le générateur autrement : next() à la sortie normale du with, gen.throw() de l'exception du corps sinon. C'est ainsi qu'il transforme une fonction génératrice en context manager complet, sans jamais écrire __enter__ ni __exit__ à la main — le with du n°19, réduit à un seul yield.A generator suspended by yield is neither finished nor inert: it waits, with all its local state intact, including any try/finally in progress. When gen.close() is called — or the garbage collector does it in the generator's place — Python raises GeneratorExit exactly at the yield point where the generator was suspended. If that yield sits inside a try, the associated finally runs normally. contextlib.contextmanager relies on the same property — a yield inside a try/finally — but resumes the generator differently: next() on a normal exit from the with, gen.throw() with the body's exception otherwise. That's how it turns a generator function into a full context manager, without ever writing __enter__ or __exit__ by hand — the with from issue №19, reduced to a single yield.

close() lève GeneratorExit au yield ; finally s'exécute normalementclose() raises GeneratorExit at the yield; finally runs normally
def compteur():
    try:
        n = 0
        while True:
            yield n
            n += 1
    finally:
        print("générateur fermé, nettoyage exécuté")

gen = compteur()
print(next(gen))   # 0
print(next(gen))   # 1
gen.close()         # lève GeneratorExit AU POINT DE SUSPENSION (le yield)
# affiche : "générateur fermé, nettoyage exécuté"
# -- puis GeneratorExit se propage et le générateur s'arrête proprement.

next(gen)   # StopIteration -- le générateur est définitivement épuisé
@contextmanager : le protocole du n°19, généré à partir d'un yield@contextmanager: issue №19's protocol, generated from a yield
from contextlib import contextmanager

@contextmanager
def fichier_ouvert(chemin):
    f = open(chemin)
    try:
        yield f          # tout le corps du "with" s'exécute ICI, au point du yield
    finally:
        f.close()        # garanti -- que le corps ait levé ou non

with fichier_ouvert("data.txt") as f:
    contenu = f.read()
# à la sortie normale du with, contextmanager relance le générateur (next),
# qui sort du yield ; si le corps a levé, il RELANCE l'exception au yield
# (gen.throw) -- dans les deux cas, le finally referme le fichier.
# C'est exactement le protocole __enter__/__exit__ du n°19, généré
# automatiquement à partir d'UN SEUL yield.
Ce que garantit close()What close() guarantees

Un générateur ne peut pas se relancer après avoir reçu GeneratorExit — s'il tente un autre yield en réponse, Python lève RuntimeError. GeneratorExit n'est donc pas une exception ordinaire à intercepter pour continuer : c'est un signal d'arrêt définitif, dont le seul usage légitime est de nettoyer puis de laisser le générateur s'éteindre.A generator can't resume after receiving GeneratorExit — if it attempts another yield in response, Python raises RuntimeError. GeneratorExit is therefore not an ordinary exception to intercept and carry on from: it's a final stop signal, whose only legitimate use is to clean up and then let the generator die.

№ 04Le piègeThe trap4 min

Un générateur qu'on abandonne à mi-course peut tenir un fichier ouvert bien après le break.A generator abandoned halfway through can keep a file open long after the break.

Un générateur qui ouvre une ressource avant sa boucle interne, et la referme après, suppose implicitement que l'itération ira jusqu'au bout. Un simple break dans la boucle appelante contredit cette hypothèse : le générateur reste suspendu au yield, le code de fermeture placé après la boucle n'est jamais atteint, et la ressource reste ouverte jusqu'à ce que le garbage collector détruise le générateur — un instant que le langage ne garantit précisément pas. CPython, grâce au comptage de références, le fait en général tout de suite ; mais rien dans la spécification du langage ne l'impose, et le compter dessus est un pari implicite sur un détail d'implémentation.A generator that opens a resource before its inner loop, and closes it after, implicitly assumes iteration will run to completion. A plain break in the calling loop contradicts that assumption: the generator stays suspended at the yield, the closing code placed after the loop is never reached, and the resource stays open until the garbage collector destroys the generator — a moment the language specifically does not guarantee. CPython, thanks to reference counting, usually does it right away; but nothing in the language specification requires it, and relying on that is an implicit bet on an implementation detail.

Le code de fermeture, après la boucle, n'est jamais atteintThe closing code, after the loop, is never reached
def lignes_du_fichier(chemin):
    f = open(chemin)
    for ligne in f:
        yield ligne
    f.close()          # jamais atteint si on sort de la boucle avant la fin

for ligne in lignes_du_fichier("gros_fichier.log"):
    if "ERREUR" in ligne:
        break            # on quitte -- le générateur reste SUSPENDU au yield
    # ... f n'est jamais fermé explicitement.
    # Le fichier reste ouvert jusqu'à ce que le garbage collector détruise
    # le générateur -- CPython le fait vite (refcount), mais l'instant
    # exact n'est PAS garanti par le langage, et d'autres implémentations
    # (PyPy) peuvent attendre bien plus longtemps.
Le réflexe à retenirThe reflex to keep

Un générateur qui détient une ressource doit toujours l'acquérir et la libérer dans un try/finally, jamais avant et après la boucle. Et côté appelant, s'il est possible de sortir tôt de l'itération, envelopper le générateur dans contextlib.closing — with closing(gen()) as g: — pour garantir sa fermeture immédiate plutôt que de compter sur le garbage collector.A generator holding a resource should always acquire and release it inside a try/finally, never before and after the loop. And on the caller side, if early exit from the iteration is possible, wrap the generator in contextlib.closing — with closing(gen()) as g: — to guarantee immediate closure rather than relying on the garbage collector.

№ 05Bilan & éditoRecap & editorial2 min

Volume VII en une tableVolume VII in one table

№No.TitreTitleTensionTension
19with : le nettoyage garantiwith: guaranteed cleanup__enter__/__exit__ ; le nettoyage n'attend pas la fin normale d'une fonction__enter__/__exit__; cleanup doesn't wait for a function's normal end
20EAFP contre LBYLEAFP vs LBYLL'exception comme flux normal ; le prix d'un except trop largeThe exception as normal flow; the cost of an overly broad except
21finally, return et le générateur qui lèvefinally, return, and the generator that raisesfinally a le dernier mot ; GeneratorExit ferme un générateur suspendufinally gets the last word; GeneratorExit closes a suspended generator
Le nettoyage n'est jamais un détail qu'on ajoute après coup. C'est un contrat — et Python offre trois façons de le faire honorer : with, finally, et GeneratorExit.Cleanup is never a detail bolted on afterward. It's a contract — and Python offers three ways to have it honored: with, finally, and GeneratorExit.
Prochain numéro — №22, ouverture du Volume VIIINext issue — No. 22, opening Volume VIII

Volume VII a montré qui garantit le nettoyage d'une ressource. Volume VIII pose une question voisine mais différente : qui détient le GIL ? Le №22 explique pourquoi deux threads Python ne calculent jamais vraiment en parallèle — et pourquoi les threads restent malgré tout parfaitement adaptés à l'attente I/O, pas au calcul.Volume VII showed who guarantees a resource's cleanup. Volume VIII asks a related but different question: who holds the GIL? No. 22 explains why two Python threads never truly compute in parallel — and why threads remain, despite that, perfectly suited to I/O waiting, not to computation.