Como limpar try / except / else aninhado?

Ao escrever código, geralmente quero fazer algo assim:

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, isso é completamente ilegível. Mas está expressando uma idéia relativamente simples: execute uma série de funções (ou trechos de código curto), com um manipulador de exceção para cada uma, e pare assim que uma função falhar. Eu imagino que o Python poderia fornecer açúcar sintático para esse código, talvez algo como isto:

# 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()

Se nenhuma exceção for gerada, isso será equivalente a foo();bar();baz();qux();cleanup(). Se as exceções são geradas, elas são tratadas pelo manipulador de exceções apropriado (se houver) e pulamos para cleanup(). Em particular, se bar()gerar a FooErrorou BazError, a exceção não será capturada e será propagada para o chamador. Isso é desejável, de modo que apenas capturamos exceções que realmente esperamos tratar.

Independentemente da feiura sintática, esse tipo de código é apenas uma má idéia em geral? Se sim, como você o refatoraria? Imagino que os gerentes de contexto possam ser usados ​​para absorver parte da complexidade, mas não entendo realmente como isso funcionaria no caso geral.

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

O que handle_foofaz? Existem algumas coisas que normalmente fazemos nos blocos de manipulação de exceções.

1. Limpeza após o erro: Mas, neste caso, foo () deve limpar depois de si mesmo, não nos deixe fazer isso. Além disso, a maioria dos trabalhos de limpeza é melhor gerenciada comwith
2. Recupere para o caminho feliz: mas você não está fazendo isso porque não continua com o restante das funções.
3. Traduz o tipo de exceção: mas você não está lançando outra exceção
4. Registre o erro: mas não deve haver necessidade de blocos de exceção especiais para cada tipo.

Parece-me que você está fazendo algo estranho no tratamento de exceções. Sua pergunta aqui é um sintoma simples do uso de exceções de maneira incomum. Você não está caindo no padrão típico, e é por isso que isso se tornou estranho.

Sem uma idéia melhor do que você está fazendo nessas handle_funções, é tudo o que posso dizer.

Parece que você tem uma sequência de comandos que podem gerar uma exceção que precisa ser tratada antes de retornar. Tente agrupar seu código e manipulação de exceções em locais separados. Eu acredito que isso faz o que você pretende.

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

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

finally:
    cleanup()

Existem algumas maneiras diferentes, dependendo do que você precisa.

Aqui está uma maneira com loops:

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()

Aqui está uma maneira com uma saída após o 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()

Pessoalmente, acho que a versão em loop é mais fácil de ler.

Antes de tudo, o uso apropriado de withmuitas vezes pode reduzir ou até eliminar grande parte do código de manipulação de exceções, melhorando a capacidade de manutenção e a legibilidade.

Agora, você pode reduzir o aninhamento de várias maneiras; outros pôsteres já forneceram alguns, então aqui está minha própria variação:

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()