Cómo saber si un objeto tiene un atributo en Python

¿Hay alguna manera en Python para determinar si un objeto tiene algún atributo? Por ejemplo:

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

¿Cómo puede saber si atiene el atributo propertyantes de usarlo?

Prueba hasattr():

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

EDITAR: Vea la respuesta de zweiterlinde a continuación, ¡que ofrece buenos consejos sobre pedir perdón! ¡Un enfoque muy pitónico!

La práctica general en python es que, si es probable que la propiedad esté allí la mayor parte del tiempo, simplemente llámela y deje que la excepción se propague o atrape con un bloque try / except. Esto probablemente será más rápido que hasattr. Si es probable que la propiedad no esté allí la mayor parte del tiempo, o no está seguro, el uso hasattrprobablemente será más rápido que caer repetidamente en un bloque de excepción.

Como respondió Jarret Hardie , hasattrhará el truco. Sin embargo, me gustaría agregar que muchos en la comunidad de Python recomiendan una estrategia de "más fácil pedir perdón que permiso" (EAFP) en lugar de "mirar antes de saltar" (LBYL). Ver estas referencias:

EAFP vs LBYL (estaba Re: un poco decepcionado hasta el momento)
EAFP vs LBYL @Code Like a Pythonista: Idiomatic Python

es decir:

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

... se prefiere a:

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

Puede usar hasattr()o capturar AttributeError, pero si realmente solo desea el valor del atributo con un valor predeterminado si no está allí, la mejor opción es simplemente usar getattr():

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

Creo que lo que estás buscando es hasattr . Sin embargo, recomendaría algo como esto si desea detectar las propiedades de Python :

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

La desventaja aquí es que los errores de atributo en el __get__código de propiedades también se detectan.

De lo contrario, haga

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

Documentos: http://docs.python.org/library/functions.html
Advertencia:
El motivo de mi recomendación es que hasattr no detecta propiedades.
Enlace: http://mail.python.org/pipermail/python-dev/2005-December/058498.html

Según pydoc, hasattr (obj, prop) simplemente llama a getattr (obj, prop) y captura excepciones. Por lo tanto, es tan válido envolver el acceso al atributo con una instrucción try y atrapar AttributeError como usar hasattr () de antemano.

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

Me gustaría sugerir evitar esto:

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

El usuario @jpalecek lo mencionó: si AttributeErrorocurre algo dentro doStuff(), está perdido.

Quizás este enfoque sea mejor:

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

Dependiendo de la situación, puede verificar con isinstancequé tipo de objeto tiene, y luego usar los atributos correspondientes. Con la introducción de clases base abstractas en Python 2.6 / 3.0, este enfoque también se ha vuelto mucho más poderoso (básicamente, los ABC permiten una forma más sofisticada de tipear patos).

Una situación en la que esto es útil sería si dos objetos diferentes tienen un atributo con el mismo nombre, pero con un significado diferente. Usar solo hasattrpodría provocar errores extraños.

Un buen ejemplo es la distinción entre iteradores e iterables (vea esta pregunta). ¡Los __iter__métodos en un iterador y un iterable tienen el mismo nombre pero son semánticamente bastante diferentes! Por hasattrlo tanto, es inútil, pero isinstancejunto con ABC proporciona una solución limpia.

Sin embargo, estoy de acuerdo en que, en la mayoría de las situaciones, el hasattrenfoque (descrito en otras respuestas) es la solución más adecuada.

Espero que esperes hasattr (), pero trata de evitar hasattr () y prefiere getattr (). getattr () es más rápido que hasattr ()

usando hasattr ():

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

lo mismo aquí estoy usando getattr para obtener propiedad si no hay ninguna propiedad, no devuelve ninguna

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

EDITAR : Este enfoque tiene serias limitaciones. Debería funcionar si el objeto es iterable . Por favor revise los comentarios a continuación.

Si está utilizando Python 3.6 o superior como yo, existe una alternativa conveniente para verificar si un objeto tiene un atributo particular:

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

Sin embargo, no estoy seguro de cuál es el mejor enfoque en este momento. usando hasattr(), usando getattr()o usando in. Comentarios son bienvenidos

Aquí hay un enfoque muy intuitivo:

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

Esto es súper simple, solo use dir(object)
Esto devolverá una lista de todas las funciones y atributos disponibles del objeto.

Otra opción posible, pero depende de a qué te refieres antes :

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

salida:

bar:1
zoom!

Esto le permite incluso verificar los atributos sin valor.

¡Pero! Tenga mucho cuidado de no crear instancias accidentalmente y comparar undefinedvarios lugares porque isnunca funcionará en ese caso.

Actualizar:

Debido a lo que estaba advirtiendo en el párrafo anterior, al tener múltiples indefinidos que nunca coinciden, recientemente he modificado ligeramente este patrón:

undefined = NotImplemented

NotImplemented, que no debe confundirse con NotImplementedError, es una función incorporada: coincide con la intención de un JS undefinedy puede reutilizar su definición en todas partes y siempre coincidirá. El inconveniente es que es "verdadero" en los booleanos y puede verse raro en los registros y los rastros de la pila (pero lo superas rápidamente cuando sabes que solo aparece en este contexto).

Puede verificar si objectcontiene un atributo utilizando el hasattrmétodo incorporado.

Por ejemplo, si su objeto es ay desea verificar el atributostuff

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

La firma del método en sí es lo hasattr(object, name) -> boolque significa si objecttiene un atributo que se pasa al segundo argumento en lugar hasattrde lo que da booleano Trueo de Falseacuerdo con la presencia del nameatributo en el objeto.

hasattr()es la respuesta correcta Lo que quiero agregar es que hasattr()también se puede usar bien junto con afirmar (para evitar ifdeclaraciones innecesarias y hacer que el código sea más legible):

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

Como se indicó en otra respuesta sobre SO : Las afirmaciones deben usarse para probar condiciones que nunca deberían suceder. El propósito es colapsar temprano en el caso de un estado corrupto del programa.