EAFP vs LBYL

Python favorece EAFP (Easier to Ask Forgiveness than Permission - Más fácil pedir perdón que permiso): intenta la operación y maneja el fallo con excepciones. LBYL (Look Before You Leap - Mira antes de saltar) comprueba las condiciones primero. Ambas son válidas; EAFP es idiomático cuando la ruta feliz es común y los fallos son excepcionales.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

# EAFP - intenta, luego maneja
try:
    value = mapping[key]
except KeyError:
    value = default
 
# LBYL - guarda, luego actúa
if key in mapping:
    value = mapping[key]
else:
    value = default

Cuándo recurrir a esto:

• EAFP cuando la ruta de éxito domina y una búsqueda fallida es rara
• LBYL cuando el fallo es esperado y quieres evitar la sobrecarga de excepciones
• EAFP cuando comprobar todas las precondiciones es más difícil que intentarlo (tipado de pato)
• LBYL en bucles ajustados donde las excepciones se dispararían miles de veces por segundo
• EAFP cuando múltiples modos de fallo colapsan en un solo bloque except

Ejemplo de Trabajo

Un analizador acepta entradas de dict o de objeto usando el tipado de pato EAFP, con LBYL solo para ramificación de tipos barata.

from typing import Any
 
def get_name(record: Any, default: str = "unknown") -> str:
    """Extrae un nombre de un registro similar a un dict o basado en atributos."""
    if isinstance(record, dict):
        return record.get("name", default)
    try:
        return record.name
    except AttributeError:
        return default
 
def parse_user_id(raw: str) -> int:
    try:
        return int(raw)
    except ValueError as exc:
        raise ValueError(f"id de usuario inválido: {raw!r}") from exc
 
samples = [
    {"name": "Ada"},
    type("User", (), {"name": "Grace"})(),
    object(),
]
 
for sample in samples:
    print(get_name(sample))
 
print(parse_user_id("42"))

Lo que esto demuestra:

• La ruta del dict usa .get() (guarda estilo LBYL a través de la API) - sin excepción para claves faltantes
• El acceso a atributos usa EAFP - un try cubre muchas formas de objetos
• Volver a lanzar con from exc preserva la cadena de traceback original
• El tipado de pato evita cadenas hasattr que compiten con atributos dinámicos

Inmersión Profunda

Cómo Funciona

• EAFP ejecuta la operación; Python lanza una excepción específica en caso de fallo
• LBYL evalúa predicados (in, isinstance, hasattr) antes de la operación
• El manejo de excepciones tiene un pequeño coste de configuración; en bucles calientes, millones de excepciones perjudican
• try/except alrededor de la ruta de éxito mantiene el código lineal y legible
• Múltiples cláusulas de guarda (LBYL) a menudo duplican el trabajo que la operación haría de todos modos

EAFP vs LBYL de un Vistazo

Notas de Python

# Prefiere EAFP para la existencia de archivos si vas a abrirlos inmediatamente de todos modos
try:
    with open(path) as f:
        data = f.read()
except FileNotFoundError:
    data = ""
 
# Prefiere LBYL cuando el fallo es la norma (escaneo de claves opcionales)
for key in optional_keys:
    if key in cache:
        process(cache[key])

Trampas

• TOCTOU con LBYL - comprobar key in dict y luego dict[key] puede fallar si otro hilo elimina la clave. Solución: usa EAFP (try/except KeyError) o .get().
• except: desnudo - EAFP tienta a capturar todo. Solución: captura excepciones específicas (KeyError, ValueError, AttributeError).
• Duplicación hasattr + getattr - if hasattr(x, "foo"): x.foo llama a getattr dos veces. Solución: usa EAFP con try/except AttributeError.
• Flujo de control impulsado por excepciones en bucles - analizar cada línea con int() en un bucle ajustado es lento cuando la mayoría de las líneas fallan. Solución: pre-filtra con regex o validación LBYL.
• Ignorar excepciones - un except: pass vacío oculta errores. Solución: registra, vuelve a lanzar o devuelve un centinela con tipado explícito.

Alternativas

Preguntas Frecuentes

Relacionado

• Context Managers as a Pattern - EAFP para limpieza de recursos
• Null Object & Sentinels - evita valores faltantes ambiguos
• Pythonic Patterns Basics - resumen de la sección
• Common Anti-Patterns - cuando las guardas salen mal

Versiones de Stack: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.