Dictionnaire Python à partir des champs d'un objet

Savez-vous s'il existe une fonction intégrée pour créer un dictionnaire à partir d'un objet arbitraire? Je voudrais faire quelque chose comme ça:

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

REMARQUE: il ne doit pas inclure de méthodes. Seuls les champs.

Notez que la meilleure pratique dans Python 2.7 est d'utiliser des classes de nouveau style (non nécessaires avec Python 3), c'est-à-dire

class Foo(object):
   ...

En outre, il existe une différence entre un «objet» et une «classe». Pour construire un dictionnaire à partir d'un objet arbitraire , il suffit d'utiliser __dict__. Habituellement, vous déclarerez vos méthodes au niveau de la classe et vos attributs au niveau de l'instance, donc ça __dict__devrait aller. Par exemple:

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

Une meilleure approche (suggérée par robert dans les commentaires) est la varsfonction intégrée :

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

Alternativement, selon ce que vous voulez faire, il peut être intéressant d'hériter dict. Ensuite, votre classe est déjà un dictionnaire, et si vous le souhaitez, vous pouvez remplacer getattret / ou setattrappeler et définir le dict. Par exemple:

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

    # etc...

Au lieu de cela x.__dict__, c'est en fait plus pythonique à utiliser vars(x).

La fonction dirintégrée vous donnera tous les attributs de l'objet, y compris des méthodes spéciales comme __str__, __dict__et tout un tas d'autres que vous ne voulez probablement pas. Mais vous pouvez faire quelque chose comme:

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

Vous pouvez donc étendre cela pour ne renvoyer que des attributs de données et non des méthodes, en définissant votre propsfonction comme ceci:

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

Je me suis installé avec une combinaison des deux réponses:

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

J'ai pensé prendre un peu de temps pour vous montrer comment traduire un objet à dicter via 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 section clé de ce code est la __iter__fonction.

Comme les commentaires l'expliquent, la première chose que nous faisons est de récupérer les éléments de classe et d'empêcher tout ce qui commence par «__».

Une fois que vous avez créé cela dict, vous pouvez utiliser la updatefonction dict et passer l'instance __dict__.

Ceux-ci vous donneront un dictionnaire complet de classe + instance de membres. Maintenant, il ne reste plus qu'à les parcourir et à générer des rendements.

De plus, si vous prévoyez de l'utiliser beaucoup, vous pouvez créer un @iterabledécorateur de classe.

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

Pour construire un dictionnaire à partir d'un objet arbitraire , il suffit d'utiliser __dict__.

Cela manque les attributs que l'objet hérite de sa classe. Par exemple,

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

hasattr (a, 'x') est vrai, mais 'x' n'apparaît pas dans un .__ dict__

Réponse tardive mais prévue pour l'exhaustivité et l'avantage des googleurs:

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

Cela n'affichera pas les méthodes définies dans la classe, mais il affichera toujours les champs incluant ceux assignés aux lambdas ou ceux qui commencent par un double soulignement.

Je pense que la façon la plus simple est de créer un attribut getitem pour la classe. Si vous devez écrire sur l'objet, vous pouvez créer un setattr personnalisé . Voici un exemple pour 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 génère les attributs des objets dans un dictionnaire et l'objet dictionnaire peut être utilisé pour obtenir l'élément dont vous avez besoin.

Un inconvénient de l'utilisation __dict__est qu'elle est peu profonde; il ne convertira aucune sous-classe en dictionnaires.

Si vous utilisez Python3.5 ou supérieur, vous pouvez utiliser jsons:

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

Si vous souhaitez répertorier une partie de vos attributs, remplacez __dict__:

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

# Call __dict__
d = instance.__dict__()

Cela aide beaucoup si vous instanceobtenez des données de bloc volumineuses et que vous souhaitez pousser dvers Redis comme la file d'attente de messages.

PYTHON 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

Vous pouvez maintenant utiliser le code ci-dessus dans votre propre classe:

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() est génial, mais ne fonctionne pas pour les objets imbriqués d'objets

Convertir un objet imbriqué d'objets en dict:

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