hasattr() vs essayez-à l'exception du bloc pour faire face à l'absence d'attributs

if hasattr(obj, 'attribute'):
    # do somthing

try:
    # access obj.attribute
except AttributeError, e:
    # deal with AttributeError

Qui devrait être préféré et pourquoi?

Dupliquer: stackoverflow.com/questions/598157/..., stackoverflow.com/questions/610883/...

InformationsquelleAutor Imran | 2009-05-24

78

hasattr en interne et rapidement effectue la même tâche que le try/except bloquer: c'est un très spécifique, optimisé, une tâche de l'outil, et devrait donc être privilégiées, le cas échéant, à la très polyvalent alternative.
- Sauf vous avez encore besoin du bloc try/catch pour gérer les conditions de course (si vous êtes à l'aide de threads).
- Ou, le cas particulier que je viens de découvrir: django OneToOneField sans valeur: hasattr(obj, field_name) renvoie la valeur Faux, mais il y a un attribut avec field_name: il soulève un DoesNotExist erreur.
- Notez que hasattr sera intercepter toutes les exceptions en Python 2.x. Voir ma réponse pour un exemple et le trivial solution de contournement.
- Un intéressant commentaire: try peut donner l'impression d'une opération de doit de travail. Si tryl'objectif n'est pas toujours tel, il est fréquent, il peut donc être considéré comme plus lisible.
- Découvrez ce réponse ici.
InformationsquelleAutor Alex Martelli
83

Toute bancs qui illustrent la différence de performance?

timeit c'est votre ami
```
$ python -mtimeit -s 'class C(object): a = 4
c = C()' 'hasattr(c, "nonexistent")'
1000000 loops, best of 3: 1.87 usec per loop
$ python -mtimeit -s 'class C(object): a = 4
c = C()' 'hasattr(c, "a")'
1000000 loops, best of 3: 0.446 usec per loop
$ python -mtimeit -s 'class C(object): a = 4
c = C()' 'try:
 c.a
except:
 pass'
1000000 loops, best of 3: 0.247 usec per loop
$ python -mtimeit -s 'class C(object): a = 4
c = C()' 'try:
 c.nonexistent
except:
 pass'
100000 loops, best of 3: 3.13 usec per loop
$

       |positive|negative
hasattr|  0.446 |  1.87 
try    |  0.247 |  3.13
```
- +1 pour la fourniture d'intéressant, tangible numéros. En fait, les "essayer" est efficace lorsqu'il contient la plupart des cas (c'est à dire quand un Python exception est vraiment exceptionnel).
- Je ne suis pas sûr de savoir comment interpréter ces résultats. Ce qui est plus rapide ici, et de combien?
- Si l'attribut existe, try est deux fois plus rapide que hasattr(). Si ça ne marche pas, try est d'environ 1,5 x plus lent que hasattr() (et les deux sont sensiblement plus lent que si l'attribut n'existe pas). C'est probablement parce que, sur le chemin d'accès joyeux, try à peine n'importe quoi (Python est en train de payer pour les frais généraux d'exceptions, indépendamment de savoir si vous les utilisez), mais hasattr() nécessite une recherche de nom et d'appel de fonction. Sur le malheureux chemin, ils ont tous deux faire quelques manipulation d'exception et un goto, mais hasattr() t-il en C plutôt que de bytecode Python.
InformationsquelleAutor ZeD
20

Il ya un tiers, et souvent mieux, alternative:
```
attr = getattr(obj, 'attribute', None)
if attr is not None:
     print attr
```
Avantages:
1. getattr ne pas avoir de mauvaise exception-de la déglutition comportement l'a souligné Martin Geiser - dans le vieux Pythons, hasattr va même avaler un KeyboardInterrupt.
2. La raison habituelle pour vérifier si l'objet possède un attribut est de sorte que vous pouvez utiliser l'attribut, et cela conduit naturellement à elle.
3. L'attribut est de lire de façon atomique, et est à l'abri d'autres threads changer l'objet. (Si, si c'est une préoccupation majeure, vous pourriez envisager de verrouillage de l'objet avant d'y accéder.)
4. C'est plus courte que try/finally et souvent plus courte que hasattr.
5. Un large except AttributeError bloc peut attraper d'autres AttributeErrors - vous que vous êtes enceinte, qui peut donner lieu à confusion comportement.
6. Accéder à un attribut est plus lent que l'accès à une variable locale (surtout si c'est pas une simple instance de l'attribut). (Si, pour être honnête, micro-optimisation en Python est souvent sans issue.)
Une chose à faire attention est si vous vous souciez le cas où obj.attribute est défini sur Aucun, vous aurez besoin d'utiliser une sentinelle de la valeur.
- +1 - C'est dans la ligue avec les dict.get('my_key', 'default_value') et devrait être plus largement connu au sujet de
- Grand pour l'usage commun cas où vous souhaitez vérifier l'existence et l'utilisation de l'attribut avec la valeur par défaut.
InformationsquelleAutor poolie
17

J'ai presque toujours utiliser hasattr: c'est le bon choix pour la plupart des cas.

Le cas problématique, c'est quand une classe substitue __getattr__: hasattr sera attraper toutes les exceptions au lieu de l'attraper juste AttributeError comme vous vous attendez. En d'autres termes, le code ci-dessous impression b: False même s'il serait plus approprié de voir un ValueError exception:
```
class X(object):
    def __getattr__(self, attr):
        if attr == 'a':
            return 123
        if attr == 'b':
            raise ValueError('important error from your database')
        raise AttributeError

x = X()
print 'a:', hasattr(x, 'a')
print 'b:', hasattr(x, 'b')
print 'c:', hasattr(x, 'c')
```
L'erreur importantes a donc disparu. Cela a été fixe en Python 3.2 (issue9666) où hasattr maintenant seulement attrape AttributeError.

Une simple solution de contournement consiste à écrire une fonction d'utilité comme ceci:
```
_notset = object()

def safehasattr(thing, attr):
    return getattr(thing, attr, _notset) is not _notset
```
Ce let's getattr face à la situation et il peut alors soulever l'exception appropriée.
- Ce fut aussi amélioré un peu en Python2.6 de sorte que hasattr permettra au moins de ne pas attraper KeyboardInterrupt etc.
- Ou, plutôt que de safehasattr, il suffit d'utiliser getattr pour copier la valeur dans une variable locale si vous allez l'utiliser, qui vous avez presque toujours.
- C'est gentil, je ne savais pas que hasattr a été améliorée comme ça.
- Oui, c'est bon. Je ne le savais pas jusqu'à aujourd'hui, quand j'étais sur le point de dire à quelqu'un pour éviter hasattr, et est allé vérifier. Nous avons eu quelques drôle bzr bugs où hasattr juste avalé ^C.
InformationsquelleAutor Martin Geisler
13

Je dirais que cela dépend de la fonction peut accepter des objets sans l'attribut par la conception, par exemple, si vous avez deux appelants à la fonction, l'un fournissant un objet avec l'attribut et l'autre qui fournit un objet sans elle.

Si le seul cas où vous pouvez obtenir un objet sans l'attribut est due à une erreur, je vous conseille d'utiliser le mécanisme des exceptions, même si il peut être plus lent, parce que je crois que c'est un nettoyeur de conception.

Bottom line: je pense que c'est un de la conception et de la lisibilité problème plutôt que de l'efficacité de la question.
- +1 pour insister sur les raisons de "l'essayer" a un sens pour les gens qui ont lu le code. 🙂
InformationsquelleAutor Roee Adler
4

Si c'est juste un attribut que vous faites des tests, je dirais que l'utilisation hasattr. Toutefois, si vous êtes en train de faire plusieurs accède aux attributs qui peuvent exister ou non, puis à l'aide d'un try bloc peut vous faire économiser un peu de temps.

InformationsquelleAutor n8gray
4

Si ce n'est avoir l'attribut est pas une condition d'erreur, la gestion de l'exception de la variante a un problème: il attrape aussi AttributeErrors qui pourrait venir en interne lors de l'accès à obj.attribut (par exemple parce que l'attribut est une propriété de sorte que l'accès il demande un peu de code).
- c'est un problème majeur qui a été largement ignorée est, à mon avis.
InformationsquelleAutor UncleZeiv
3

Je vous suggère de l'option 2. L'Option 1 a une condition de concurrence si un autre thread est de l'ajout ou de la suppression de l'attribut.

Aussi python a une L'idiome, que l'aeap ("plus facile de demander pardon que la permission") est mieux que LBYL ('regarder avant de sauter').

InformationsquelleAutor Douglas Leeder
2

À partir d'un point de vue pratique, dans la plupart des langues à l'aide d'un conditionnelle sera toujours consderably plus rapide que de la gestion d'une exception.

Si vous êtes désireux de traiter le cas d'un attribut n'existe pas quelque part à l'extérieur de la fonction courante, l'exception est la meilleure façon d'aller. Un indicateur que vous voudrez peut-être à l'aide d'une exception au lieu d'une condition, c'est que le conditionnel ne fixe un drapeau et s'interrompt l'opération en cours, et quelque chose d'ailleurs vérifie ce drapeau et d'agir sur cette base.

Cela dit, comme Rax Olgud points, la communication avec les autres est un attribut important de code, et ce que vous voulez dire en disant "c'est une situation exceptionnelle" plutôt que "c'est quelque chose que je attendre" peut-être plus important.
- +1 pour insister sur le fait que "d'essayer" peut être interprété comme "c'est une situation exceptionnelle", par rapport au test conditionnel. 🙂
InformationsquelleAutor Curt J. Sampson
2

Ce sujet est couvert dans le EuroPython 2016 parler L'écriture plus rapide Python par Sebastian Witowski. Voici une reproduction de sa lame avec la synthèse des performances. Il utilise également la terminologie de regarder avant de sauter dans cette discussion, il convient de mentionner ici à la balise de mots clés.

Si l'attribut est manquant, alors la mendicité pour le pardon sera
être plus lent que de demander des autorisations. Donc, en règle générale, vous pouvez
utiliser le demander la permission de façon si sais qu'il est très probable que l'
attribut est manquant ou d'autres problèmes que vous pouvez prévoir.
Sinon, si vous vous attendez à ce code aura pour résultat la plupart du temps lisible
code

3 LES AUTORISATIONS OU LE PARDON?
```
# CASE 1 -- Attribute Exists
class Foo(object):
    hello = 'world'
foo = Foo()

if hasatter(foo, 'hello'):
    foo.hello
## 149ns ##

try:
    foo.hello
except AttributeError:
    pass
## 43.1 ns ##
## 3.5 times faster


# CASE 2 -- Attribute Absent
class Bar(object):
    pass
bar = Bar()

if hasattr(bar, 'hello'):
    bar.hello
## 428 ns ##

try:
    bar.hello
except AttributeError :
    pass
## 536 ns ##
## 25% slower
```
InformationsquelleAutor jxramos
0

La première.

Plus court, c'est mieux. Les Exceptions doivent être exceptionnelles.
- Les Exceptions sont très fréquents en Python, il y a une à la fin de chaque for déclaration, et hasattr utilise aussi. Cependant, "plus court, mieux c'est" (et "le plus simple est mieux"!) FAIRE appliquer, de sorte que le plus simple, plus court, plus spécifiques hasattr est en effet préférable.
- tout simplement parce que le Python analyseur transforme ces déclarations pour avoir 1 ne veut pas dire son très commun. Il ya une raison pourquoi ils ont fait ce sucre syntaxique: si vous n'êtes pas coincé avec la cruftiness de taper l'essayer à l'exception du bloc.
- Si l'exception est exceptionnel, alors "explicite, c'est mieux", et l'original de l'affiche du 2ème option est la meilleure, je dirais...
InformationsquelleAutor Unknown
0

Au moins quand c'est juste ce qui se passe dans le programme, laissant de côté la partie humaine de la lisibilité, etc. (qui est en fait la plupart du temps plus importantes que les performances (au moins dans ce cas - avec des performances en durée), comme Roee Adler et d'autres ont souligné).

Néanmoins en regardant cela de ce point de vue,
il devient alors une question de choix entre
```
try: getattr(obj, attr)
except: ...
```
et
```
try: obj.attr
except: ...
```
depuis hasattr utilise le premier cas, pour déterminer le résultat.
De la nourriture pour la pensée 😉

InformationsquelleAutor Levite

Vous devez vous connecter pour publier un commentaire.

3 LES AUTORISATIONS OU LE PARDON?