Come sapere se un oggetto ha un attributo in Python

C'è un modo in Python per determinare se un oggetto ha qualche attributo? Per esempio:

>>> 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'

Come puoi sapere se aha l'attributo propertyprima di usarlo?

Prova hasattr():

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

EDIT: Vedi la risposta di zweiterlinde di seguito, che offre buoni consigli su come chiedere perdono! Un approccio molto pitonico!

La pratica generale in Python è che, se è probabile che la proprietà sia presente per la maggior parte del tempo, è sufficiente chiamarla e lasciare che l'eccezione si propaga o intrappolarla con un blocco try / tranne. Questo sarà probabilmente più veloce di hasattr. Se è probabile che la proprietà non ci sia la maggior parte del tempo, o non sei sicuro, l'utilizzo hasattrsarà probabilmente più veloce rispetto alla caduta ripetuta in un blocco di eccezioni.

Come Jarret Hardie ha risposto, hasattrfarà il trucco. Vorrei aggiungere, tuttavia, che molti nella comunità di Python raccomandano una strategia di "più facile chiedere perdono che permesso" (EAFP) piuttosto che "guardare prima di saltare" (LBYL). Vedi questi riferimenti:

EAFP vs LBYL (era Re: un po 'deluso finora)
EAFP vs LBYL @Code Like a Pythonista: Idiomatic Python

vale a dire:

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

... è preferito a:

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

Puoi usare hasattr()o catturare AttributeError, ma se vuoi davvero solo il valore dell'attributo con un valore predefinito se non c'è, l'opzione migliore è solo usare getattr():

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

Penso che quello che stai cercando sia hasattr . Tuttavia, consiglierei qualcosa di simile se si desidera rilevare le proprietà di Python :

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

Lo svantaggio è che vengono rilevati anche gli errori di attributo nel __get__codice delle proprietà .

Altrimenti, do-

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

Documenti: http://docs.python.org/library/functions.html
Avvertenza:
il motivo della mia raccomandazione è che hasattr non rileva le proprietà.
Link: http://mail.python.org/pipermail/python-dev/2005-December/058498.html

Secondo pydoc, hasattr (obj, prop) chiama semplicemente getattr (obj, prop) e cattura le eccezioni. Quindi, è altrettanto valido racchiudere l'accesso all'attributo con un'istruzione try e catturare AttributeError come usare hasattr () in anticipo.

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

Vorrei suggerire di evitare questo:

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

L'utente @jpalecek lo ha menzionato: se si AttributeErrorverifica all'interno doStuff(), ci si perde.

Forse questo approccio è migliore:

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

A seconda della situazione, puoi verificare con isinstancequale tipo di oggetto hai, quindi utilizzare gli attributi corrispondenti. Con l'introduzione di classi di base astratte in Python 2.6 / 3.0, questo approccio è diventato anche molto più potente (sostanzialmente gli ABC consentono un modo più sofisticato di scrivere l'anatra).

Una situazione in cui ciò sarebbe utile sarebbe se due oggetti diversi hanno un attributo con lo stesso nome, ma con significato diverso. L'uso di solo hasattrpotrebbe quindi portare a strani errori.

Un bell'esempio è la distinzione tra iteratori e iterabili (vedi questa domanda). I __iter__metodi in un iteratore e in un iterabile hanno lo stesso nome ma sono semanticamente abbastanza diversi! Quindi hasattrè inutile, ma isinstanceinsieme a ABC fornisce una soluzione pulita.

Tuttavia, concordo sul fatto che nella maggior parte dei casi l' hasattrapproccio (descritto in altre risposte) è la soluzione più appropriata.

Spero che ti aspetti hasattr (), ma cerca di evitare hasattr () e preferisci getattr (). getattr () è più veloce di hasattr ()

usando hasattr ():

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

stesso qui sto usando getattr per ottenere proprietà se non c'è proprietà che non restituisce nessuno

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

EDIT : questo approccio ha serie limitazioni. Dovrebbe funzionare se l'oggetto è iterabile . Si prega di controllare i commenti qui sotto.

Se stai usando Python 3.6 o versioni successive come me, c'è una comoda alternativa per verificare se un oggetto ha un attributo particolare:

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

Tuttavia, non sono sicuro di quale sia l'approccio migliore in questo momento. usando hasattr(), usando getattr()o usando in. I commenti sono ben accetti

Ecco un approccio molto intuitivo:

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

Questo è super semplice, basta usare l' dir(oggetto.)
Restituirà un elenco di tutte le funzioni e gli attributi disponibili dell'oggetto.

Un'altra possibile opzione, ma dipende da cosa intendi prima :

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

produzione:

bar:1
zoom!

Ciò consente di verificare anche la presenza di attributi con valore Nessuno.

Ma! Fai molta attenzione a non istanziare e confrontare accidentalmente undefinedpiù posti perché isnon funzionerà mai in quel caso.

Aggiornare:

a causa di ciò di cui stavo avvertendo nel paragrafo precedente, con più indefiniti che non corrispondono mai, ho recentemente modificato leggermente questo schema:

undefined = NotImplemented

NotImplemented, da non confondere NotImplementedError, è un built-in: abbina l'intento di un JS undefinede puoi riutilizzare la sua definizione ovunque e corrisponderà sempre. Lo svantaggio è che è "veritiero" nei booleani e può apparire strano nei registri e nelle tracce dello stack (ma lo si supera rapidamente quando si sa che appare solo in questo contesto).

È possibile verificare se objectcontiene l'attributo utilizzando il hasattrmetodo incorporato.

Ad esempio, se l'oggetto è ae si desidera verificare l'attributostuff

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

La stessa firma del metodo è hasattr(object, name) -> boolche significa se objectha un attributo che viene passato al secondo argomento in hasattrquanto fornisce un valore booleano Trueo in Falsebase alla presenza namedell'attributo nell'oggetto.

hasattr()è la risposta giusta. Quello che voglio aggiungere è che hasattr()può anche essere usato bene insieme a assert (per evitare ifdichiarazioni non necessarie e rendere il codice più leggibile):

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

Come affermato in un'altra risposta su SO : gli asserti dovrebbero essere usati per testare condizioni che non dovrebbero mai accadere. Lo scopo è quello di arrestarsi in anticipo nel caso di uno stato di programma corrotto.