Como saber se um objeto tem um atributo em Python

Existe uma maneira no Python para determinar se um objeto tem algum atributo? Por exemplo:

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

Como você pode saber se atem o atributo propertyantes de usá-lo?

Tente hasattr():

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

EDIT: Veja a resposta de zweiterlinde abaixo, que oferece bons conselhos sobre pedir perdão! Uma abordagem muito pitônica!

A prática geral em python é que, se é provável que a propriedade esteja lá a maior parte do tempo, simplesmente chame-a e deixe a exceção se propagar, ou prenda-a com um bloco try / except. Provavelmente será mais rápido que hasattr. Se a propriedade provavelmente não estiver lá a maior parte do tempo, ou você não tiver certeza, o uso hasattrprovavelmente será mais rápido do que cair repetidamente em um bloco de exceção.

Como Jarret Hardie respondeu, hasattrfará o truque. Gostaria de acrescentar, no entanto, que muitos na comunidade Python recomendam uma estratégia "mais fácil pedir perdão do que permissão" (EAFP) do que "olhar antes de pular" (LBYL). Veja estas referências:

EAFP vs LBYL (Re: um pouco decepcionado até agora)
EAFP vs LBYL @Code Como um Pythonista: Idiomatic Python

ou seja:

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

... é preferido para:

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

Você pode usar hasattr()ou capturar AttributeError, mas se você realmente deseja apenas o valor do atributo com um padrão, se ele não estiver lá, a melhor opção é usar getattr():

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

Eu acho que o que você está procurando é hasattr . No entanto, eu recomendaria algo assim se você quiser detectar propriedades python -

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

A desvantagem aqui é que os erros de atributo no __get__código de propriedades também são capturados.

Caso contrário,

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

Documentos: http://docs.python.org/library/functions.html
Aviso:
O motivo da minha recomendação é que o hasattr não detecta propriedades.
Link: http://mail.python.org/pipermail/python-dev/2005-December/058498.html

De acordo com o pydoc, o hasattr (obj, prop) simplesmente chama getattr (obj, prop) e captura exceções. Portanto, é tão válido envolver o acesso ao atributo com uma instrução try e capturar o AttributeError quanto usar hasattr () antecipadamente.

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

Eu gostaria de sugerir evitar isso:

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

O usuário @jpalecek mencionou: Se AttributeErrorocorrer um dentro doStuff(), você estará perdido.

Talvez essa abordagem seja melhor:

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

Dependendo da situação, você pode verificar com isinstanceque tipo de objeto você possui e, em seguida, usar os atributos correspondentes. Com a introdução de classes base abstratas no Python 2.6 / 3.0, essa abordagem também se tornou muito mais poderosa (basicamente os ABCs permitem uma maneira mais sofisticada de digitação de patos).

Uma situação em que isso é útil seria se dois objetos diferentes tivessem um atributo com o mesmo nome, mas com significado diferente. Usando apenashasattr pode levar a erros estranhos.

Um bom exemplo é a distinção entre iteradores e iterables (consulte esta pergunta). Os __iter__métodos em um iterador e um iterável têm o mesmo nome, mas são semanticamente bem diferentes! Então hasattré inútil, masisinstance junto com o ABC fornece uma solução limpa.

No entanto, concordo que, na maioria das situações, a hasattrabordagem (descrita em outras respostas) é a solução mais apropriada.

Espero que você esteja esperando hasattr (), mas tente evitar hasattr () e, por favor, prefira getattr (). getattr () é mais rápido que hasattr ()

usando hasattr ():

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

mesmo aqui estou usando getattr para obter propriedade, se não houver propriedade, ele retornará nenhum

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

EDIT : Esta abordagem tem sérias limitações. Deverá funcionar se o objeto for iterável . Por favor, verifique os comentários abaixo.

Se você estiver usando o Python 3.6 ou superior como eu, há uma alternativa conveniente para verificar se um objeto tem um atributo específico:

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

No entanto, não tenho certeza de qual é a melhor abordagem no momento. usando hasattr(), usando getattr()ou usando in. Comentários são bem-vindos.

Aqui está uma abordagem muito intuitiva:

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

Isso é super simples, basta usar o dir(objeto.)
Isso retornará uma lista de todas as funções e atributos disponíveis do objeto.

Outra opção possível, mas depende se o que você quer dizer com 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()

resultado:

bar:1
zoom!

Isso permite que você verifique se há atributos sem valor.

Mas! Tenha muito cuidado para não instanciar acidentalmente e comparar undefinedvários locais, porque isnunca funcionará nesse caso.

Atualizar:

por causa do que eu estava avisando no parágrafo acima, tendo vários indefinidos que nunca correspondem, recentemente modifiquei ligeiramente esse padrão:

undefined = NotImplemented

NotImplemented, para não confundir NotImplementedError, é um built-in: ele combina semitendamente a intenção de um JS undefinede você pode reutilizar sua definição em qualquer lugar e sempre corresponderá. A desvantagem é que ele é "verdadeiro" nos booleanos e pode parecer estranho nos logs e nos rastreamentos de pilha (mas você rapidamente supera isso quando sabe que só aparece nesse contexto).

Você pode verificar se objectcontém atributo usando o hasattrmétodo interno.

Por exemplo, se seu objeto é ae você deseja verificar o atributostuff

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

A própria assinatura do método é hasattr(object, name) -> boolo que significa que se objecttem atributo que é passado para o segundo argumento em hasattrque ele dá booleana Trueou Falsede acordo com a presença de nameatributo no objecto.

hasattr()é a resposta certa. O que eu quero acrescentar é que hasattr()também pode ser usado bem em conjunto com assert (para evitar ifdeclarações desnecessárias e tornar o código mais legível):

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

Conforme indicado em outra resposta no SO : As declarações devem ser usadas para testar condições que nunca devem acontecer. O objetivo é travar no início no caso de um estado de programa corrompido.