Diccionario de Python de los campos de un objeto

¿Sabes si hay una función incorporada para construir un diccionario a partir de un objeto arbitrario? Me gustaría hacer algo como esto:

>>> class Foo:
...     bar = 'hello'
...     baz = 'world'
...
>>> f = Foo()
>>> props(f)
{ 'bar' : 'hello', 'baz' : 'world' }

NOTA: No debe incluir métodos. Solo campos.

Tenga en cuenta que la mejor práctica en Python 2.7 es usar clases de estilo nuevo (no necesarias con Python 3), es decir

class Foo(object):
   ...

Además, hay una diferencia entre un 'objeto' y una 'clase'. Para construir un diccionario a partir de un objeto arbitrario , es suficiente usarlo __dict__. Por lo general, declarará sus métodos a nivel de clase y sus atributos a nivel de instancia, por lo que __dict__debería estar bien. Por ejemplo:

>>> class A(object):
...   def __init__(self):
...     self.b = 1
...     self.c = 2
...   def do_nothing(self):
...     pass
...
>>> a = A()
>>> a.__dict__
{'c': 2, 'b': 1}

Un mejor enfoque (sugerido por Robert en los comentarios) es la varsfunción incorporada :

>>> vars(a)
{'c': 2, 'b': 1}

Alternativamente, dependiendo de lo que quieras hacer, puede ser bueno heredar de dict. Entonces su clase ya es un diccionario, y si lo desea, puede anular getattry / o setattrllamar y establecer el dict. Por ejemplo:

class Foo(dict):
    def __init__(self):
        pass
    def __getattr__(self, attr):
        return self[attr]

    # etc...

En lugar de x.__dict__, en realidad es más pitónico de usar vars(x).

El dirbuiltin le dará todos los atributos del objeto, incluidos métodos especiales como __str__, __dict__y un montón de otros que probablemente no desee. Pero puedes hacer algo como:

>>> class Foo(object):
...     bar = 'hello'
...     baz = 'world'
...
>>> f = Foo()
>>> [name for name in dir(f) if not name.startswith('__')]
[ 'bar', 'baz' ]
>>> dict((name, getattr(f, name)) for name in dir(f) if not name.startswith('__')) 
{ 'bar': 'hello', 'baz': 'world' }

Entonces, puede extender esto para devolver solo atributos de datos y no métodos, definiendo su propsfunción de esta manera:

import inspect

def props(obj):
    pr = {}
    for name in dir(obj):
        value = getattr(obj, name)
        if not name.startswith('__') and not inspect.ismethod(value):
            pr[name] = value
    return pr

Me decidí con una combinación de ambas respuestas:

dict((key, value) for key, value in f.__dict__.iteritems() 
    if not callable(value) and not key.startswith('__'))

Pensé que me tomaría un tiempo mostrarle cómo puede traducir un objeto para dictarlo dict(obj).

class A(object):
    d = '4'
    e = '5'
    f = '6'

    def __init__(self):
        self.a = '1'
        self.b = '2'
        self.c = '3'

    def __iter__(self):
        # first start by grabbing the Class items
        iters = dict((x,y) for x,y in A.__dict__.items() if x[:2] != '__')

        # then update the class items with the instance items
        iters.update(self.__dict__)

        # now 'yield' through the items
        for x,y in iters.items():
            yield x,y

a = A()
print(dict(a)) 
# prints "{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'f': '6'}"

La sección clave de este código es la __iter__función.

Como explican los comentarios, lo primero que hacemos es tomar los elementos de la Clase y evitar cualquier cosa que comience con '__'.

Una vez que haya creado eso dict, puede usar la updatefunción dict y pasar la instancia __dict__.

Estos le darán un diccionario completo de clase + instancia de miembros. Ahora todo lo que queda es iterar sobre ellos y obtener los rendimientos.

Además, si planea usar esto mucho, puede crear un @iterabledecorador de clase.

def iterable(cls):
    def iterfn(self):
        iters = dict((x,y) for x,y in cls.__dict__.items() if x[:2] != '__')
        iters.update(self.__dict__)

        for x,y in iters.items():
            yield x,y

    cls.__iter__ = iterfn
    return cls

@iterable
class B(object):
    d = 'd'
    e = 'e'
    f = 'f'

    def __init__(self):
        self.a = 'a'
        self.b = 'b'
        self.c = 'c'

b = B()
print(dict(b))

Para construir un diccionario a partir de un objeto arbitrario , es suficiente usarlo __dict__.

Esto pierde atributos que el objeto hereda de su clase. Por ejemplo,

class c(object):
    x = 3
a = c()

hasattr (a, 'x') es verdadero, pero 'x' no aparece en un .__ dict__

Respuesta tardía pero siempre completa y en beneficio de los googlers:

def props(x):
    return dict((key, getattr(x, key)) for key in dir(x) if key not in dir(x.__class__))

Esto no mostrará los métodos definidos en la clase, pero aún mostrará campos que incluyen los asignados a lambdas o aquellos que comienzan con un doble guión bajo.

Creo que la forma más fácil es crear un atributo getitem para la clase. Si necesita escribir en el objeto, puede crear una costumbre setattr . Aquí hay un ejemplo para getitem :

class A(object):
    def __init__(self):
        self.b = 1
        self.c = 2
    def __getitem__(self, item):
        return self.__dict__[item]

# Usage: 
a = A()
a.__getitem__('b')  # Outputs 1
a.__dict__  # Outputs {'c': 2, 'b': 1}
vars(a)  # Outputs {'c': 2, 'b': 1}

dict genera los atributos de los objetos en un diccionario y el objeto del diccionario se puede usar para obtener el elemento que necesita.

Una desventaja de usar __dict__es que es poco profunda; no convertirá ninguna subclase a diccionarios.

Si está utilizando Python3.5 o superior, puede usar jsons:

>>> import jsons
>>> jsons.dump(f)
{'bar': 'hello', 'baz': 'world'}

Si desea enumerar parte de sus atributos, anule __dict__:

def __dict__(self):
    d = {
    'attr_1' : self.attr_1,
    ...
    }
    return d

# Call __dict__
d = instance.__dict__()

Esto ayuda mucho si instanceobtiene algunos datos de bloque grandes y desea enviar da Redis como cola de mensajes.

PITÓN 3:

class DateTimeDecoder(json.JSONDecoder):

   def __init__(self, *args, **kargs):
        JSONDecoder.__init__(self, object_hook=self.dict_to_object,
                         *args, **kargs)

   def dict_to_object(self, d):
       if '__type__' not in d:
          return d

       type = d.pop('__type__')
       try:
          dateobj = datetime(**d)
          return dateobj
       except:
          d['__type__'] = type
          return d

def json_default_format(value):
    try:
        if isinstance(value, datetime):
            return {
                '__type__': 'datetime',
                'year': value.year,
                'month': value.month,
                'day': value.day,
                'hour': value.hour,
                'minute': value.minute,
                'second': value.second,
                'microsecond': value.microsecond,
            }
        if isinstance(value, decimal.Decimal):
            return float(value)
        if isinstance(value, Enum):
            return value.name
        else:
            return vars(value)
    except Exception as e:
        raise ValueError

Ahora puede usar el código anterior dentro de su propia clase:

class Foo():
  def toJSON(self):
        return json.loads(
            json.dumps(self, sort_keys=True, indent=4, separators=(',', ': '), default=json_default_format), cls=DateTimeDecoder)


Foo().toJSON() 

vars() es genial, pero no funciona para objetos anidados de objetos

Convierte objetos anidados de objetos a dict:

def to_dict(self):
    return json.loads(json.dumps(self, default=lambda o: o.__dict__))