Iterar sobre atributos de objeto em python

Eu tenho um objeto python com vários atributos e métodos. Eu quero iterar sobre os atributos do objeto.

class my_python_obj(object):
    attr1='a'
    attr2='b'
    attr3='c'

    def method1(self, etc, etc):
        #Statements

Quero gerar um dicionário que contenha todos os atributos dos objetos e seus valores atuais, mas quero fazê-lo de maneira dinâmica (se mais tarde adicionar outro atributo, não preciso me lembrar de atualizar também minha função).

No php, variáveis ​​podem ser usadas como chaves, mas os objetos em python são indescritíveis e, se eu usar a notação de ponto, cria um novo atributo com o nome da minha var, que não é minha intenção.

Apenas para esclarecer as coisas:

def to_dict(self):
    '''this is what I already have'''
    d={}
    d["attr1"]= self.attr1
    d["attr2"]= self.attr2
    d["attr3"]= self.attr3
    return d

·

def to_dict(self):
    '''this is what I want to do'''
    d={}
    for v in my_python_obj.attributes:
        d[v] = self.v
    return d

Atualização: com atributos, quero dizer apenas as variáveis ​​deste objeto, não os métodos.

Supondo que você tenha uma classe como

>>> class Cls(object):
...     foo = 1
...     bar = 'hello'
...     def func(self):
...         return 'call me'
...
>>> obj = Cls()

chamar diro objeto devolve todos os atributos desse objeto, incluindo atributos especiais do python. Embora alguns atributos do objeto possam ser chamados, como métodos.

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']

Você sempre pode filtrar os métodos especiais usando uma compreensão de lista.

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']

ou se você preferir mapas / filtros.

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']

Se você deseja filtrar os métodos, pode usar o built-in callablecomo uma verificação.

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']

Você também pode inspecionar a diferença entre sua classe e seu objeto de instância usando.

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])

em geral, coloque um __iter__método em sua classe e repita os atributos do objeto ou coloque essa classe mixin em sua classe.

class IterMixin(object):
    def __iter__(self):
        for attr, value in self.__dict__.iteritems():
            yield attr, value

Sua classe:

>>> class YourClass(IterMixin): pass
...
>>> yc = YourClass()
>>> yc.one = range(15)
>>> yc.two = 'test'
>>> dict(yc)
{'one': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 'two': 'test'}

Como já mencionado em algumas respostas / comentários, os objetos Python já armazenam um dicionário de seus atributos (os métodos não estão incluídos). Isso pode ser acessado como __dict__, mas a melhor maneira é usar vars(a saída é a mesma). Observe que a modificação deste dicionário modificará os atributos na instância! Isso pode ser útil, mas também significa que você deve ter cuidado com a forma como usa este dicionário. Aqui está um exemplo rápido:

class A():
    def __init__(self, x=3, y=2, z=5):
        self.x = x
        self._y = y
        self.__z__ = z

    def f(self):
        pass

a = A()
print(vars(a))
# {'x': 3, '_y': 2, '__z__': 5}
# all of the attributes of `a` but no methods!

# note how the dictionary is always up-to-date
a.x = 10
print(vars(a))
# {'x': 10, '_y': 2, '__z__': 5}

# modifying the dictionary modifies the instance attribute
vars(a)["_y"] = 20
print(vars(a))
# {'x': 10, '_y': 20, '__z__': 5}

Usar dir(a)é uma abordagem estranha, se não totalmente ruim, para esse problema. É bom se você realmente precisa iterar sobre todos os atributos e métodos da classe (incluindo métodos especiais como __init__). No entanto, isso não parece ser o que você deseja, e até a resposta aceita é mal aplicada aplicando uma filtragem frágil para tentar remover métodos e deixar apenas os atributos; você pode ver como isso falharia para a classe Adefinida acima.

(o uso __dict__foi feito em algumas respostas, mas todos definem métodos desnecessários em vez de usá-lo diretamente. Apenas um comentário sugere o uso vars).

Objetos em python armazenam seus atributos (incluindo funções) em um ditado chamado __dict__. Você pode (mas geralmente não deveria) usar isso para acessar os atributos diretamente. Se você deseja apenas uma lista, também pode chamar dir(obj), que retorna uma iterável com todos os nomes de atributos, para os quais você poderia passar getattr.

No entanto, a necessidade de fazer qualquer coisa com os nomes das variáveis ​​geralmente é um design ruim. Por que não mantê-los em uma coleção?

class Foo(object):
    def __init__(self, **values):
        self.special_values = values

Em seguida, você pode percorrer as teclas com for key in obj.special_values:

class someclass:
        x=1
        y=2
        z=3
        def __init__(self):
           self.current_idx = 0
           self.items = ["x","y","z"]
        def next(self):
            if self.current_idx < len(self.items):
                self.current_idx += 1
                k = self.items[self.current_idx-1]
                return (k,getattr(self,k))
            else:
                raise StopIteration
        def __iter__(self):
           return self

então chame isso de iterável

s=someclass()
for k,v in s:
    print k,"=",v

A resposta correta para isso é que você não deveria. Se você deseja esse tipo de coisa, basta usar um dict, ou precisará adicionar explicitamente atributos a algum contêiner. Você pode automatizar isso aprendendo sobre decoradores.

Em particular, a propósito, o método1 no seu exemplo é tão bom quanto um atributo.

Para python 3.6

class SomeClass:

    def attr_list(self, should_print=False):

        items = self.__dict__.items()
        if should_print:
            [print(f"attribute: {k}    value: {v}") for k, v in items]

        return items

Por todos os fanáticos pitonianos por aí, tenho certeza de que Johan Cleeze aprovaria seu dogmatismo;). Estou deixando esta resposta, continuando a deméritá-la. Isso realmente me deixa mais confidente. Deixe um comentário, galinhas!

Para python 3.6

class SomeClass:

    def attr_list1(self, should_print=False):

        for k in self.__dict__.keys():
            v = self.__dict__.__getitem__(k)
            if should_print:
                print(f"attr: {k}    value: {v}")

    def attr_list(self, should_print=False):

        b = [(k, v) for k, v in self.__dict__.items()]
        if should_print:
            [print(f"attr: {a[0]}    value: {a[1]}") for a in b]
        return b