¿Cómo limpiar try / except / else anidado?

Cuando escribo código, a menudo quiero hacer algo como esto:

try:
    foo()
except FooError:
    handle_foo()
else:
    try:
        bar()
    except BarError:
        handle_bar()
    else:
        try:
            baz()
        except BazError:
            handle_baz()
        else:
            qux()
finally:
    cleanup()

Obviamente, esto es completamente ilegible. Pero está expresando una idea relativamente simple: ejecutar una serie de funciones (o fragmentos de código cortos), con un controlador de excepción para cada una, y detenerse tan pronto como una función falle. Me imagino que Python podría proporcionar azúcar sintáctico para este código, quizás algo como esto:

# NB: This is *not* valid Python
try:
    foo()
except FooError:
    handle_foo()
    # GOTO finally block
else try:
    bar()
except BarError:
    handle_bar()
    # ditto
else try:
    baz()
except BazError:
    handle_baz()
    # ditto
else:
    qux()
finally:
    cleanup()

Si no se generan excepciones, esto es equivalente a foo();bar();baz();qux();cleanup(). Si se generan excepciones, las maneja el manejador de excepciones apropiado (si corresponde) y pasamos a cleanup(). En particular, si bar()aumenta un FooErroro BazError, la excepción no se detectará y se propagará a la persona que llama. Esto es deseable por lo que solo detectamos excepciones que realmente esperamos manejar.

Independientemente de la fealdad sintáctica, ¿es este tipo de código una mala idea en general? Si es así, ¿cómo lo refactorizaría? Me imagino que los gestores de contexto podrían usarse para absorber parte de la complejidad, pero realmente no entiendo cómo funcionaría eso en el caso general.

try:
    foo()
except FooError:
    handle_foo()
else:
    ...
finally:
    cleanup()

¿Qué handle_foohacer? Hay algunas cosas que normalmente hacemos en los bloques de manejo de excepciones.

1. Limpieza después del error: Pero en este caso, foo () debería limpiar después de sí mismo, no dejar que lo hagamos. Además, la mayoría de los trabajos de limpieza se manejan mejor conwith
2. Recupere el camino feliz: pero no está haciendo esto ya que no continúa con el resto de las funciones.
3. Traduce el tipo de excepción: pero no está lanzando otra excepción
4. Registre el error: Pero no debería ser necesario tener bloques de excepción especiales para cada tipo.

Me parece que está haciendo algo extraño en su manejo de excepciones. Su pregunta aquí es un síntoma simple sobre el uso de excepciones de una manera inusual. No estás cayendo en el patrón típico, y es por eso que esto se ha vuelto incómodo.

Sin una mejor idea de lo que estás haciendo en esas handle_funciones, eso es todo lo que puedo decir.

Parece que tiene una secuencia de comandos que pueden generar una excepción que debe manejarse antes de regresar. Intente agrupar su código y el manejo de excepciones en ubicaciones separadas. Creo que esto hace lo que pretendes.

try:
    foo()
    bar()
    baz()
    qux()

except FooError:
    handle_foo()
except BarError:
    handle_bar()
except BazError:
    handle_baz()

finally:
    cleanup()

Hay un par de formas diferentes, según lo que necesite.

Aquí hay una manera con bucles:

try:
    for func, error, err_handler in (
            (foo, FooError, handle_foo),
            (bar, BarError, handle_bar),
            (baz, BazError, handle_baz),
        ):
        try:
            func()
        except error:
            err_handler()
            break
finally:
    cleanup()

Aquí hay una manera con una salida después del error_handler:

def some_func():
    try:
        try:
            foo()
        except FooError:
            handle_foo()
            return
        try:
            bar()
        except BarError:
            handle_bar()
            return
        try:
            baz()
        except BazError:
            handle_baz()
            return
        else:
            qux()
    finally:
        cleanup()

Personalmente, creo que la versión en bucle es más fácil de leer.

En primer lugar, el uso adecuado de a withmenudo puede reducir o incluso eliminar gran parte del código de manejo de excepciones, mejorando tanto la facilidad de mantenimiento como la legibilidad.

Ahora, puede reducir el anidamiento de muchas maneras; otros carteles ya han proporcionado algunos, así que aquí está mi propia variación:

for _ in range(1):
    try:
        foo()
    except FooError:
        handle_foo()
        break
    try:
        bar()
    except BarError:
        handle_bar()
        break
    try:
        baz()
    except BazError:
        handle_baz()
        break
    qux()
cleanup()