Python-Wörterbuch aus den Feldern eines Objekts

Wissen Sie, ob es eine integrierte Funktion zum Erstellen eines Wörterbuchs aus einem beliebigen Objekt gibt? Ich möchte so etwas machen:

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

HINWEIS: Es sollten keine Methoden enthalten sein. Nur Felder.

Beachten Sie, dass die beste Vorgehensweise in Python 2.7 darin besteht, Klassen neuen Stils zu verwenden (die in Python 3 nicht benötigt werden), d. H.

class Foo(object):
   ...

Es gibt auch einen Unterschied zwischen einem 'Objekt' und einer 'Klasse'. Um ein Wörterbuch aus einem beliebigen Objekt zu erstellen , ist es ausreichend, es zu verwenden __dict__. Normalerweise deklarieren Sie Ihre Methoden auf Klassenebene und Ihre Attribute auf Instanzebene. Dies __dict__sollte in Ordnung sein. Zum Beispiel:

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

Ein besserer Ansatz (von Robert in Kommentaren vorgeschlagen) ist die eingebaute varsFunktion:

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

Je nachdem, was Sie tun möchten, kann es auch hilfreich sein, von zu erben dict. Dann ist Ihre Klasse bereits ein Wörterbuch, und wenn Sie möchten, können Sie das Diktat überschreiben getattrund / oder setattrdurchrufen und festlegen. Zum Beispiel:

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

    # etc...

Stattdessen x.__dict__ist es tatsächlich pythonischer zu verwenden vars(x).

Die direingebaute gibt Ihnen alle Objektattribute, einschließlich speziellen Methoden wie __str__, __dict__und eine ganze Reihe von anderen , die Sie wahrscheinlich nicht wollen. Aber Sie können so etwas tun wie:

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

Sie können dies also erweitern, um nur Datenattribute und keine Methoden zurückzugeben, indem Sie Ihre propsFunktion folgendermaßen definieren :

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

Ich habe mich mit einer Kombination aus beiden Antworten zufrieden gegeben:

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

Ich dachte, ich würde einige Zeit brauchen, um Ihnen zu zeigen, wie Sie ein Objekt übersetzen können, über das Sie diktieren möchten 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'}"

Der Schlüsselabschnitt dieses Codes ist die __iter__Funktion.

Wie die Kommentare erklären, greifen wir zuerst die Klassenelemente zu und verhindern alles, was mit '__' beginnt.

Sobald Sie das erstellt haben, dictkönnen Sie die updateDiktierfunktion verwenden und die Instanz übergeben __dict__.

Diese geben Ihnen ein vollständiges Klassen- + Instanzwörterbuch der Mitglieder. Jetzt müssen sie nur noch durchlaufen und die Renditen erzielen.

Wenn Sie dies häufig verwenden möchten, können Sie auch einen @iterableKlassendekorateur erstellen .

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

Um ein Wörterbuch aus einem beliebigen Objekt zu erstellen , ist es ausreichend, es zu verwenden __dict__.

Dabei fehlen Attribute, die das Objekt von seiner Klasse erbt. Zum Beispiel,

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

hasattr (a, 'x') ist wahr, aber 'x' erscheint nicht in einem .__ dict__

Späte Antwort, aber zur Vollständigkeit und zum Nutzen der Googler vorgesehen:

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

Hier werden keine in der Klasse definierten Methoden angezeigt, aber es werden weiterhin Felder angezeigt, einschließlich der Lambdas zugewiesenen oder derjenigen, die mit einem doppelten Unterstrich beginnen.

Ich denke, der einfachste Weg ist, ein getitem- Attribut für die Klasse zu erstellen . Wenn Sie in das Objekt schreiben müssen, können Sie ein benutzerdefiniertes Setattr erstellen . Hier ist ein Beispiel für 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 generiert die Objektattribute in einem Wörterbuch und das Wörterbuchobjekt kann verwendet werden, um das gewünschte Element abzurufen.

Ein Nachteil der Verwendung __dict__ ist, dass es flach ist; Es werden keine Unterklassen in Wörterbücher konvertiert.

Wenn Sie Python3.5 oder höher verwenden, können Sie Folgendes verwenden jsons:

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

Wenn Sie einen Teil Ihrer Attribute auflisten möchten, überschreiben Sie __dict__:

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

# Call __dict__
d = instance.__dict__()

Dies ist sehr hilfreich, wenn Sie instancegroße dBlockdaten erhalten und wie eine Nachrichtenwarteschlange an Redis senden möchten .

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

Jetzt können Sie den obigen Code in Ihrer eigenen Klasse verwenden:

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() ist großartig, funktioniert aber nicht für verschachtelte Objekte von Objekten

Konvertieren Sie verschachtelte Objekte von Objekten in Diktate:

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