Les blocs try / except imbriqués en python sont-ils une bonne pratique de programmation?

J'écris mon propre conteneur, qui doit donner accès à un dictionnaire à l'intérieur par des appels d'attribut. L'utilisation typique du conteneur serait comme ceci:

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

Je sais qu'il peut être stupide d'écrire quelque chose comme ça, mais c'est la fonctionnalité que je dois fournir. Je pensais à mettre en œuvre cela de la manière suivante:

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"

Je ne sais pas si les blocs try / except imbriqués sont une bonne pratique, donc une autre façon serait d'utiliser hasattr()et 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 pour en utiliser un et essayer un bloc catch comme ceci:

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

Quelle option est la plus pythonique et élégante?

Votre premier exemple est parfaitement bien. Même les documents officiels de Python recommandent ce style appelé EAFP .

Personnellement, je préfère éviter d'imbriquer quand ce n'est pas nécessaire:

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()est obsolète depuis longtemps dans Python 2. Utilisez-le à la item in self.dictplace.

Alors qu'en Java c'est en effet une mauvaise pratique d'utiliser les exceptions pour le contrôle de flux (principalement parce que les exceptions forcent le jvm à rassembler des ressources ( plus ici )), en Python vous avez 2 principes importants: Duck Typing et EAFP . Cela signifie essentiellement que vous êtes encouragé à essayer d'utiliser un objet de la façon dont vous pensez qu'il fonctionnerait, et à gérer lorsque les choses ne sont pas comme ça.

En résumé, le seul problème serait que votre code soit trop indenté. Si vous en avez envie, essayez de simplifier certains des emboîtements comme suggéré par lqc

Pour votre exemple spécifique, vous n'avez pas réellement besoin de les imbriquer. Si l'expression dans le trybloc réussit, la fonction retournera, donc tout code après le bloc try / except entier ne sera exécuté que si la première tentative échoue. Vous pouvez donc simplement faire:

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"

Les imbriquer n'est pas mauvais, mais j'ai l'impression que le laisser à plat rend la structure plus claire: vous essayez séquentiellement une série de choses et retournez la première qui fonctionne.

Soit dit en passant, vous voudrez peut-être vous demander si vous voulez vraiment utiliser __getattribute__plutôt __getattr__qu'ici. L'utilisation __getattr__simplifiera les choses, car vous saurez que le processus de recherche d'attribut normal a déjà échoué.

Faites juste attention - dans ce cas, finallyon touche d'abord MAIS sauté aussi.

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

À mon avis, ce serait la façon la plus pythonique de le gérer, bien que cela rende votre question sans objet. Notez que cela définit __getattr__()au lieu de __getattribute__()parce que cela signifie qu'il n'a à gérer que les attributs "spéciaux" conservés dans le dictionnaire interne.

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

En Python, il est plus facile de demander pardon que permission. Ne transpirez pas la gestion des exceptions imbriquées.

(De plus, has*il utilise presque toujours des exceptions sous le couvert de toute façon.)

Selon la documentation , il est préférable de gérer plusieurs exceptions via des tuples ou comme ceci:

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

Un bon et simple exemple d'imbrication try / except pourrait être le suivant:

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

Essayez maintenant différentes combinaisons et vous obtiendrez le résultat correct:

divide(15, 3)
# 5.0

divide(15, 0)
# inf

divide(-15, 0)
# -inf

divide(0, 0)
# nan

[bien sûr, nous avons numpy donc nous n'avons pas besoin de créer cette fonction]

Une chose que j'aime éviter est de lever une nouvelle exception lors de la gestion d'une ancienne. Cela rend les messages d'erreur déroutants à lire.

Par exemple, dans mon code, j'ai écrit à l'origine

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

Et j'ai reçu ce message.

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

Ce que je voulais c'était:

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

Cela n'affecte pas la façon dont les exceptions sont gérées. Dans l'un ou l'autre bloc de code, une erreur KeyError aurait été interceptée. Il s'agit simplement d'obtenir des points de style.

Si try-except-finally est imbriqué dans le bloc finally, le résultat de "l'enfant" est finalement conservé. Je n'ai pas encore trouvé d'expiration officielle, mais l'extrait de code suivant montre ce comportement dans 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

Je ne pense pas qu'il s'agisse d'être pythonique ou élégant. Il s'agit d'empêcher autant que possible les exceptions. Les exceptions sont destinées à gérer les erreurs pouvant survenir dans le code ou les événements sur lesquels vous n'avez aucun contrôle. Dans ce cas, vous avez un contrôle total lorsque vous vérifiez si un élément est un attribut ou dans un dictionnaire, évitez donc les exceptions imbriquées et respectez votre deuxième tentative.