Comment savoir si un objet a un attribut en Python

Existe-t-il un moyen en Python pour déterminer si un objet a un attribut? Par exemple:

>>> a = SomeClass()
>>> a.someProperty = value
>>> a.property
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: SomeClass instance has no attribute 'property'

Comment savoir si aa l'attribut propertyavant de l'utiliser?

Essayez hasattr():

if hasattr(a, 'property'):
    a.property

EDIT: Voir la réponse de zweiterlinde ci-dessous, qui offre de bons conseils pour demander pardon! Une approche très pythonique!

La pratique générale en python est que, si la propriété est susceptible d'être là la plupart du temps, il suffit de l'appeler et de laisser l'exception se propager, ou de la piéger avec un bloc try / except. Ce sera probablement plus rapide que hasattr. Si la propriété n'est probablement pas là la plupart du temps, ou si vous n'êtes pas sûr, l'utilisation hasattrsera probablement plus rapide que de tomber à plusieurs reprises dans un bloc d'exception.

Comme Jarret Hardie a répondu, hasattrfera l'affaire. Je voudrais cependant ajouter que de nombreux membres de la communauté Python recommandent une stratégie «plus facile de demander pardon que permission» (EAFP) plutôt que de «regarder avant de sauter» (LBYL). Voir ces références:

EAFP vs LBYL (était Re: Un peu déçu jusqu'à présent)
EAFP vs LBYL @Code Like a Pythonista: Idiomatic Python

c'est à dire:

try:
    doStuff(a.property)
except AttributeError:
    otherStuff()

... est préféré à:

if hasattr(a, 'property'):
    doStuff(a.property)
else:
    otherStuff()

Vous pouvez utiliser hasattr()ou attraper AttributeError, mais si vous voulez vraiment juste la valeur de l'attribut avec un défaut s'il n'est pas là, la meilleure option est simplement d'utiliser getattr():

getattr(a, 'property', 'default value')

Je pense que ce que vous recherchez est hasattr . Cependant, je recommanderais quelque chose comme ça si vous voulez détecter les propriétés de python -

try:
    getattr(someObject, 'someProperty')         
except AttributeError:
    print "Doesn't exist"
else
    print "Exists"

L'inconvénient ici est que les erreurs d'attribut dans le __get__code de propriétés sont également détectées.

Sinon, faites-

if hasattr(someObject, 'someProp'):
    #Access someProp/ set someProp
    pass

Docs: http://docs.python.org/library/functions.html
Avertissement:
La raison de ma recommandation est que hasattr ne détecte pas les propriétés.
Lien: http://mail.python.org/pipermail/python-dev/2005-December/058498.html

Selon pydoc, hasattr (obj, prop) appelle simplement getattr (obj, prop) et intercepte les exceptions. Ainsi, il est tout aussi valide d'envelopper l'accès aux attributs avec une instruction try et d'attraper AttributeError que d'utiliser auparavant hasattr ().

a = SomeClass()
try:
    return a.fake_prop
except AttributeError:
    return default_value

Je voudrais suggérer d'éviter cela:

try:
    doStuff(a.property)
except AttributeError:
    otherStuff()

L'utilisateur @jpalecek l'a mentionné: Si un AttributeErrorse produit à l'intérieur doStuff(), vous êtes perdu.

Peut-être que cette approche est meilleure:

try:
    val = a.property
except AttributeError:
    otherStuff()
else:
    doStuff(val)

Selon la situation, vous pouvez vérifier avec isinstancequel type d'objet vous disposez, puis utiliser les attributs correspondants. Avec l'introduction de classes de base abstraites dans Python 2.6 / 3.0, cette approche est également devenue beaucoup plus puissante (les ABC permettent essentiellement une manière plus sophistiquée de taper du canard).

Une situation où cela est utile serait si deux objets différents ont un attribut avec le même nom, mais avec une signification différente. Utiliser uniquement hasattrpeut alors conduire à des erreurs étranges.

Un bel exemple est la distinction entre les itérateurs et les itérables (voir cette question). Les __iter__méthodes d'un itérateur et d'un itérable ont le même nom mais sont sémantiquement assez différentes! hasattrEst donc inutile, mais isinstanceavec ABC fournit une solution propre.

Cependant, je conviens que dans la plupart des situations, l' hasattrapproche (décrite dans d'autres réponses) est la solution la plus appropriée.

J'espère que vous attendez hasattr (), mais essayez d'éviter hasattr () et préférez getattr (). getattr () est plus rapide que hasattr ()

en utilisant hasattr ():

 if hasattr(a, 'property'):
     print a.property

même ici, j'utilise getattr pour obtenir une propriété s'il n'y a pas de propriété, il ne retourne aucun

   property = getattr(a,"property",None)
    if property:
        print property

EDIT : Cette approche a de sérieuses limites. Cela devrait fonctionner si l'objet est itérable . Veuillez vérifier les commentaires ci-dessous.

Si vous utilisez Python 3.6 ou supérieur comme moi, il existe une alternative pratique pour vérifier si un objet a un attribut particulier:

if 'attr1' in obj1:
    print("attr1 = {}".format(obj1["attr1"]))

Cependant, je ne sais pas quelle est la meilleure approche en ce moment. en utilisant hasattr(), en utilisant getattr()ou en utilisant in. Les commentaires sont les bienvenus.

Voici une approche très intuitive:

if 'property' in dir(a):
    a.property

C'est super simple, il suffit d'utiliser l' dir(objet)
Cela retournera une liste de toutes les fonctions et attributs disponibles de l'objet.

Une autre option possible, mais cela dépend de ce que vous entendez par avant :

undefined = object()

class Widget:

    def __init__(self):
        self.bar = 1

    def zoom(self):
        print("zoom!")

a = Widget()

bar = getattr(a, "bar", undefined)
if bar is not undefined:
    print("bar:%s" % (bar))

foo = getattr(a, "foo", undefined)
if foo is not undefined:
    print("foo:%s" % (foo))

zoom = getattr(a, "zoom", undefined)
if zoom is not undefined:
    zoom()

production:

bar:1
zoom!

Cela vous permet même de vérifier les attributs sans valeur.

Mais! Faites très attention de ne pas instancier accidentellement et de comparer undefinedplusieurs endroits car iscela ne fonctionnera jamais dans ce cas.

Mise à jour:

à cause de ce que j'avertissais dans le paragraphe ci-dessus, ayant plusieurs indéfinis qui ne correspondent jamais, j'ai récemment légèrement modifié ce modèle:

undefined = NotImplemented

NotImplemented, à ne pas confondre avec NotImplementedError, est un intégré: il correspond semi à l'intention d'un JS undefinedet vous pouvez réutiliser sa définition partout et il correspondra toujours. L'inconvénient est qu'il est "véridique" chez les booléens et qu'il peut paraître bizarre dans les journaux et les traces de pile (mais vous vous en remettez rapidement lorsque vous savez qu'il n'apparaît que dans ce contexte).

Vous pouvez vérifier si objectcontient un attribut à l'aide de la hasattrméthode intégrée.

Pour une instance si votre objet est aet que vous souhaitez vérifier l'attributstuff

>>> class a:
...     stuff = "something"
... 
>>> hasattr(a,'stuff')
True
>>> hasattr(a,'other_stuff')
False

La signature de la méthode elle-même est hasattr(object, name) -> boolce qui signifie si objecta un attribut qui est passé au deuxième argument dans hasattrce qu'il donne booléen Trueou Falseselon la présence d' nameattribut dans l'objet.

hasattr()est la bonne réponse. Ce que je veux ajouter, c'est que cela hasattr()peut également être bien utilisé en conjonction avec assert (pour éviter les ifinstructions inutiles et rendre le code plus lisible):

assert hasattr(a, 'property'), 'object lacks property' 

Comme indiqué dans une autre réponse sur SO : les assertions doivent être utilisées pour tester des conditions qui ne devraient jamais se produire. Le but est de planter tôt dans le cas d'un état de programme corrompu.