Os blocos try / except aninhados em python são uma boa prática de programação?

Estou escrevendo meu próprio contêiner, que precisa dar acesso a um dicionário dentro por chamadas de atributo. O uso típico do contêiner seria assim:

dict_container = DictContainer()
dict_container['foo'] = bar
...
print dict_container.foo

Sei que pode ser estúpido escrever algo assim, mas essa é a funcionalidade que preciso fornecer. Eu estava pensando em implementar isso da seguinte maneira:

def __getattribute__(self, item):
    try:
        return object.__getattribute__(item)
    except AttributeError:
        try:
            return self.dict[item]
        except KeyError:
            print "The object doesn't have such attribute"

Não tenho certeza se os blocos try / except aninhados são uma boa prática; portanto, outra maneira seria usar hasattr()e has_key():

def __getattribute__(self, item):
        if hasattr(self, item):
            return object.__getattribute__(item)
        else:
            if self.dict.has_key(item):
                return self.dict[item]
            else:
                raise AttributeError("some customised error")

Ou, para usar um deles e tentar um bloco de captura como este:

def __getattribute__(self, item):
    if hasattr(self, item):
        return object.__getattribute__(item)
    else:
        try:
            return self.dict[item]
        except KeyError:
            raise AttributeError("some customised error")

Qual opção é mais pitônica e elegante?

Seu primeiro exemplo está perfeitamente bem. Até os documentos oficiais do Python recomendam esse estilo conhecido como EAFP .

Pessoalmente, prefiro evitar o aninhamento quando não for necessário:

def __getattribute__(self, item):
    try:
        return object.__getattribute__(item)
    except AttributeError:
        pass  # fallback to dict
    try:
        return self.dict[item]
    except KeyError:
        raise AttributeError("The object doesn't have such attribute") from None

PS. has_key()foi descontinuado por muito tempo no Python 2. Use em item in self.dictvez disso.

Enquanto em Java é realmente uma má prática usar Exceções para controle de fluxo (principalmente porque as exceções forçam a jvm a reunir recursos ( mais aqui )), em Python você tem 2 princípios importantes: Duck Typing e EAFP . Isso basicamente significa que você é incentivado a tentar usar um objeto da maneira que você acha que ele funcionaria, e a lidar quando as coisas não são assim.

Em resumo, o único problema seria seu código ficar muito recuado. Se você quiser, tente simplificar alguns dos aninhamentos, como o lqc sugerido

Para o seu exemplo específico, você realmente não precisa aninhá-los. Se a expressão no trybloco for bem-sucedida, a função retornará, portanto, qualquer código após todo o bloco try / except será executado apenas se a primeira tentativa falhar. Então você pode fazer:

def __getattribute__(self, item):
    try:
        return object.__getattribute__(item)
    except AttributeError:
        pass
    # execution only reaches here when try block raised AttributeError
    try:
        return self.dict[item]
    except KeyError:
        print "The object doesn't have such attribute"

Aninhando-os não é ruim, mas sinto que deixá-lo plano torna a estrutura mais clara: você está tentando seqüencialmente uma série de coisas e retornando a primeira que funciona.

Aliás, você pode querer pensar se realmente deseja usar em __getattribute__vez de __getattr__aqui. O uso __getattr__simplificará as coisas porque você saberá que o processo normal de pesquisa de atributos já falhou.

Apenas tenha cuidado - neste caso, primeiro finallyé tocado, mas também ignorado.

def a(z):
    try:
        100/z
    except ZeroDivisionError:
        try:
            print('x')
        finally:
            return 42
    finally:
        return 1


In [1]: a(0)
x
Out[1]: 1

Na minha opinião, essa seria a maneira mais pitônica de lidar com isso, embora e porque torne sua pergunta discutível. Observe que isso define em __getattr__()vez de __getattribute__()fazê-lo, porque isso significa que ele só precisa lidar com os atributos "especiais" mantidos no dicionário interno.

def __getattr__(self, name):
    """only called when an attribute lookup in the usual places has failed"""
    try:
        return self.my_dict[name]
    except KeyError:
        raise AttributeError("some customized error message")

No Python, é mais fácil pedir perdão do que permissão. Não se preocupe com o tratamento de exceções aninhadas.

(Além disso, has*quase sempre usa exceções nos bastidores).

De acordo com a documentação , é melhor lidar com várias exceções por meio de tuplas ou assim:

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except IOError as e:
    print "I/O error({0}): {1}".format(e.errno, e.strerror)
except ValueError:
    print "Could not convert data to an integer."
except:
    print "Unexpected error:", sys.exc_info()[0]
    raise

Um exemplo bom e simples para try / except aninhado pode ser o seguinte:

import numpy as np

def divide(x, y):
    try:
        out = x/y
    except:
        try:
            out = np.inf * x / abs(x)
        except:
            out = np.nan
    finally:
        return out

Agora tente várias combinações e você obterá o resultado correto:

divide(15, 3)
# 5.0

divide(15, 0)
# inf

divide(-15, 0)
# -inf

divide(0, 0)
# nan

[é claro que estamos entorpecidos e não precisamos criar essa função]

Uma coisa que eu gosto de evitar é criar uma nova exceção ao lidar com uma antiga. Isso torna as mensagens de erro confusas para serem lidas.

Por exemplo, no meu código, escrevi originalmente

try:
    return tuple.__getitem__(self, i)(key)
except IndexError:
    raise KeyError(key)

E eu recebi esta mensagem.

>>> During handling of above exception, another exception occurred.

O que eu queria era isso:

try:
    return tuple.__getitem__(self, i)(key)
except IndexError:
    pass
raise KeyError(key)

Não afeta como as exceções são tratadas. Em qualquer bloco de código, um KeyError teria sido capturado. Isso é apenas uma questão de obter pontos de estilo.

Se tentar, exceto, finalmente, estiver aninhado dentro do bloco finalmente, o resultado de "filho" finalmente será preservado. Ainda não encontrei a expainação oficial, mas o seguinte trecho de código mostra esse comportamento no Python 3.6.

def f2():
    try:
        a = 4
        raise SyntaxError
    except SyntaxError as se:
        print('log SE')
        raise se from None
    finally:
        try:
            raise ValueError
        except ValueError as ve:
            a = 5
            print('log VE')
            raise ve from None
        finally:
            return 6       
        return a

In [1]: f2()
log SE
log VE
Out[2]: 6

Não acho que seja uma questão de ser pitônico ou elegante. É uma questão de evitar exceções, tanto quanto possível. Exceções destinam-se a manipular erros que podem ocorrer em código ou eventos sobre os quais você não tem controle. Nesse caso, você tem controle total ao verificar se um item é um atributo ou um dicionário, portanto, evite exceções aninhadas e continue com sua segunda tentativa.