EAFP contre LBYL : l'exception comme flux EAFP versus LBYL: the exception as control flow

Vérifier qu'une clé existe avant de la lire semble plus prudent que d'essayer et de rattraper l'échec. Mais entre la vérification et la lecture s'ouvre un intervalle — le temps qu'un autre thread, un autre processus, ou simplement le disque, change l'état vérifié. Python préfère EAFP : tenter l'opération directement, attraper l'exception si elle survient — sans jamais laisser cet intervalle s'ouvrir. Checking that a key exists before reading it looks more careful than trying and catching the failure. But between the check and the read opens a gap — time enough for another thread, another process, or simply the disk, to change the state just checked. Python prefers EAFP: attempting the operation directly, catching the exception if it happens — never leaving that gap open.

Audience
Dev qui a écrit if cle in dictionnaire: avant de lire dictionnaire[cle], et se demande pourquoi Python trouve ça suspect Dev who's written if key in dictionary: before reading dictionary[key], and wonders why Python finds that suspicious
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●●○
Date
Juil 2026 Jul 2026

ExceptionsEAFPtry/except

SommaireContents ·
№ 01CadrageFraming3 min

Vérifier avant d'agir semble plus prudent. Ça ouvre pourtant un intervalle que Python préfère ne jamais laisser exister.Checking before acting looks more careful. Yet it opens a gap Python prefers to never let exist.

Le numéro précédent a traité l'exception comme un accident à contenir — with garantissait le nettoyage après coup. Ce numéro retourne la question : Python encourage-t-il à prévenir l'erreur, ou à la laisser survenir puis à la rattraper ? Deux styles s'opposent. LBYL — Look Before You Leap — vérifie une condition avant d'agir : tester qu'une clé existe avant de la lire, qu'un fichier existe avant de l'ouvrir. EAFP — Easier to Ask Forgiveness than Permission — tente l'opération directement, et attrape l'exception si elle échoue. Le second style est idiomatique en Python ; le premier, hérité d'habitudes plus défensives, cache un défaut structurel que ce numéro va exposer.The previous issue treated the exception as an accident to contain — with guaranteed cleanup after the fact. This issue flips the question: does Python encourage preventing the error, or letting it happen and then catching it? Two styles compete. LBYL — Look Before You Leap — checks a condition before acting: testing that a key exists before reading it, that a file exists before opening it. EAFP — Easier to Ask Forgiveness than Permission — attempts the operation directly, and catches the exception if it fails. The latter style is idiomatic in Python; the former, inherited from more defensive habits, hides a structural flaw this issue is about to expose.

LBYL : deux lectures, un intervalle entre les deuxLBYL: two reads, a gap between them
# LBYL -- "Look Before You Leap" : vérifier, PUIS agir
if "utilisateur" in cache:
    valeur = cache["utilisateur"]
else:
    valeur = charger_depuis_la_base()

# deux lectures de "cache" : une pour vérifier, une pour lire
# -- rien ne garantit que l'état est LE MÊME entre les deux
EAFP : une seule lecture, aucun intervalleEAFP: one read, no gap
# EAFP -- "Easier to Ask Forgiveness than Permission" : agir, PUIS gérer l'échec
try:
    valeur = cache["utilisateur"]
except KeyError:
    valeur = charger_depuis_la_base()

# une seule lecture de "cache" -- pas d'intervalle entre vérifier et lire
Le sous-réflexe du numéroThis issue's sub-reflex

Face à un if condition: agir(), demande : entre la vérification et l'action, l'état pourrait-il changer — par un autre thread, un autre processus, ou simplement le temps qui passe ? Si oui, LBYL ouvre une fenêtre que EAFP referme.Facing an if condition: act(), ask: between the check and the action, could the state change — via another thread, another process, or simply the passage of time? If so, LBYL opens a window that EAFP closes.

№ 02La surpriseThe surprise4 min

Une vérification n'est vraie qu'à l'instant où elle a lieu. Ce qui suit peut déjà être faux.A check is only true at the instant it happens. What follows might already be false.

La surprise n'est pas que LBYL soit toujours faux — pour du code strictement séquentiel, sur des données qu'aucune autre force ne peut modifier, il fonctionne très bien. La surprise est l'ampleur de ce qui peut s'immiscer dans l'intervalle entre la vérification et l'action : un autre thread du même processus, un autre processus du système, un appel réseau qui expire, ou simplement le disque qui change entre deux appels système. Ce délai porte un nom — une fenêtre TOCTOU, Time-Of-Check to Time-Of-Use — et EAFP la ferme entièrement, en ne faisant jamais qu'une seule tentative, sans vérification préalable séparée.The surprise isn't that LBYL is always wrong — for strictly sequential code, on data no other force can touch, it works perfectly well. The surprise is the range of things that can sneak into the gap between the check and the action: another thread in the same process, another process on the system, a network call that times out, or simply the disk changing between two system calls. That delay has a name — a TOCTOU window, Time-Of-Check to Time-Of-Use — and EAFP closes it entirely, by only ever making one attempt, with no separate prior check.

Vraie à l'instant T, fausse à l'instant T+1True at instant T, false at instant T+1
import os

def lire_config(chemin):
    if os.path.exists(chemin):     # instant T : le fichier existe
        # ... un autre processus supprime le fichier ICI, entre les deux lignes ...
        with open(chemin) as f:     # instant T+1 : FileNotFoundError, malgré la vérification
            return f.read()
    return "{}"

# la vérification était VRAIE au moment où elle a eu lieu -- mais rien ne
# garantit qu'elle est ENCORE vraie une ligne plus tard. Ce délai s'appelle
# une fenêtre TOCTOU (Time-Of-Check to Time-Of-Use).
Vérifier n'est jamais gratuit. Ça consomme du temps — et le temps est exactement ce que le bug attend pour s'y glisser.Checking is never free. It costs time — and time is exactly what the bug is waiting for to slip in.
№ 03La mécaniqueThe mechanics5 min

Quatre blocs, quatre garanties différentes — et else existe pour dire « ce code suppose la réussite ».Four blocks, four different guarantees — and else exists to say "this code assumes success".

try délimite la seule zone réellement surveillée — si une exception survient ailleurs, aucun except de ce bloc ne la voit. except ne s'exécute que si le type d'exception attendu est levé dans le try. else, la clause la moins connue, ne s'exécute que si le try n'a levé aucune exception — et sert précisément à séparer le code qui peut échouer de celui qui suppose que tout s'est bien passé, évitant qu'un except trop généreux n'attrape par accident une exception qui n'a rien à voir avec l'opération surveillée. finally s'exécute toujours, exception ou non — le même contrat que __exit__ au numéro précédent.try delimits the only zone actually being watched — if an exception occurs elsewhere, no except in this block ever sees it. except only runs if the expected exception type is raised inside try. else, the least-known clause, only runs if try raised nothing at all — and exists precisely to separate code that can fail from code that assumes everything went fine, preventing an overly generous except from accidentally catching an exception that has nothing to do with the operation being watched. finally always runs, exception or not — the same contract as __exit__ from the previous issue.

Les quatre clauses et leur condition d'exécutionThe four clauses and their execution condition
try:
    valeur = dictionnaire["cle"]      # 1. la zone SURVEILLÉE -- la seule
except KeyError:
    valeur = None                      # 2. exécuté SEULEMENT si try lève KeyError
else:
    print("clé trouvée, aucune exception")   # 3. exécuté SEULEMENT si try n'a RIEN levé
finally:
    print("nettoyage, dans tous les cas")     # 4. exécuté TOUJOURS, exception ou pas
else réduit la surface de ce que le except peut attraper par erreurelse shrinks the surface of what except can accidentally catch
# SANS else -- le traitement du succès est écrit DANS le try
try:
    valeur = dictionnaire["cle"]
    resultat = 100 / valeur          # si valeur == 0, ZeroDivisionError...
except KeyError:
    resultat = 0
# ...capturée par erreur ? NON -- ZeroDivisionError n'est pas un KeyError,
# elle remonte quand même. Mais le risque existe : plus le try est GROS,
# plus il attrape (par erreur de conception) des exceptions imprévues.

# AVEC else -- seul le code qui PEUT échouer reste dans le try
try:
    valeur = dictionnaire["cle"]     # SEULE opération qui peut lever KeyError
except KeyError:
    valeur = 0
else:
    resultat = 100 / valeur          # si ÇA lève, ce n'est PAS un problème de "cle"
    # -- else documente : "ce code suppose que le try a réussi"
Le réflexe : un try aussi court que possibleThe reflex: a try as short as possible

Plus le bloc try contient de lignes, plus il risque d'attraper une exception qui n'a rien à voir avec ce qu'il était censé surveiller. else permet de garder try réduit à la seule opération risquée, sans pour autant abandonner le code qui suit à l'extérieur du try/except.The more lines a try block contains, the more it risks catching an exception unrelated to what it was meant to watch. else lets try stay reduced to the one risky operation, without abandoning the code that follows to outside the try/except entirely.

№ 04Le piègeThe trap4 min

except Exception n'attrape pas que l'erreur prévue — il attrape aussi celle que personne n'attendait.except Exception doesn't just catch the expected error — it catches the one nobody expected too.

EAFP repose sur un pari implicite : l'exception attrapée est bien celle qu'on anticipait, pas une autre. except Exception (ou pire, un except nu) rompt ce pari en attrapant absolument toute erreur, y compris une faute de frappe dans un nom d'attribut, un TypeError sur un argument mal passé, ou toute autre erreur de programmation réelle qui n'a rien à voir avec le cas qu'on cherchait à gérer. Le code semble fonctionner — il retourne une valeur de repli — mais le vrai bug ne remonte jamais nulle part, ni dans les logs, ni dans un test, jusqu'à ce qu'il cause un dégât bien plus difficile à retracer.EAFP rests on an implicit bet: the exception caught is really the one anticipated, not another. except Exception (or worse, a bare except) breaks that bet by catching absolutely any error, including a typo in an attribute name, a TypeError from a badly passed argument, or any other genuine programming error that has nothing to do with the case being handled. The code looks like it works — it returns a fallback value — but the real bug never surfaces anywhere, not in the logs, not in a test, until it causes damage far harder to trace back.

Un AttributeError réel disparaît derrière la valeur de repliA real AttributeError vanishes behind the fallback value
def charger_utilisateur(id_utilisateur):
    try:
        utilisateur = base.get(id_utilisateur)
        return utilisateur.nom.upper()   # faute de frappe : "nom" n'existe pas, c'est "nom_complet"
    except Exception:
        return "inconnu"                  # AttributeError attrapée -- le VRAI bug disparaît

print(charger_utilisateur(42))   # "inconnu" -- semble fonctionner, sans jamais alerter personne
# le développeur pensait ne capturer QUE l'absence d'utilisateur en base.
# except Exception attrape TOUT -- y compris une erreur de programmation
# qui n'a rien à voir avec l'utilisateur manquant
Le réflexe à retenirThe reflex to keep

Attrape le type d'exception le plus précis possible, jamais Exception par réflexe, et jamais un except nu. Un except large peut se justifier tout en haut d'une application (un serveur qui ne doit jamais crasher) — mais alors seulement pour journaliser l'erreur en entier, jamais pour la remplacer silencieusement par une valeur de repli.Catch the most precise exception type possible, never Exception by reflex, and never a bare except. A broad except can be justified at the very top of an application (a server that must never crash) — but only to log the error in full, never to silently replace it with a fallback value.

№ 05Bilan & éditoRecap & editorial2 min

Ce numéro en une tableThis issue in one table

№No.TitreTitleTensionTension
20EAFP contre LBYLEAFP vs LBYLL'exception comme flux normal plutôt qu'accident ; le prix d'un except trop largeThe exception as normal flow rather than accident; the cost of an overly broad except
Tenter plutôt que vérifier ferme une fenêtre. Mais attraper trop large en rouvre une autre — celle où le vrai bug se cache derrière la valeur de repli.Trying instead of checking closes one window. But catching too broadly opens another — the one where the real bug hides behind the fallback value.
Prochain numéro — №21Next issue — No. 21

Ce numéro a montré qu'un except trop large avale un bug par accident. Le №21 referme Volume VII en posant une question plus fine encore : quand finally et return se disputent la dernière parole dans une fonction, qui gagne ? Et que se passe-t-il quand on referme un générateur — via GeneratorExit — qui tenait encore une ressource, jamais épuisé jusqu'au bout ?This issue showed how an overly broad except swallows a bug by accident. No. 21 closes Volume VII with an even finer question: when finally and return both compete for the last word in a function, which one wins? And what happens when a generator — never fully exhausted, still holding a resource — gets closed via GeneratorExit?