Słownik Python z pól obiektu

Czy wiesz, czy istnieje wbudowana funkcja do budowania słownika z dowolnego obiektu? Chciałbym zrobić coś takiego:

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

UWAGA: Nie powinno zawierać metod. Tylko pola.

Zauważ, że najlepszą praktyką w Pythonie 2.7 jest używanie klas w nowym stylu (niepotrzebnych w Pythonie 3), tj

class Foo(object):
   ...

Ponadto istnieje różnica między „przedmiotem” a „klasą”. Aby zbudować słownik z dowolnego obiektu , wystarczy użyć __dict__. Zazwyczaj deklarujesz swoje metody na poziomie klasy, a atrybuty na poziomie instancji, więc __dict__powinno być dobrze. Na przykład:

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

Lepszym podejściem (sugerowanym przez Roberta w komentarzach) jest wbudowana varsfunkcja:

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

Alternatywnie, w zależności od tego, co chcesz zrobić, warto odziedziczyć po nim dict. Zatem twoja klasa jest już słownikiem i jeśli chcesz, możesz zastąpić getattri / lub setattrzadzwonić i ustawić dyktando. Na przykład:

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

    # etc...

Zamiast tego x.__dict__jest w rzeczywistości bardziej pythonowy w użyciu vars(x).

dirWbudowane daje wszystkie atrybuty obiektu, w tym specjalnych metod, takich jak __str__, __dict__i cała masa innych, które prawdopodobnie nie chcą. Ale możesz zrobić coś takiego:

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

Można więc rozszerzyć tę propsfunkcję, aby zwracała tylko atrybuty danych, a nie metody, definiując swoją funkcję w następujący sposób:

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

Rozwiązałem kombinację obu odpowiedzi:

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

Pomyślałem, że poświęcę trochę czasu, aby pokazać, jak można przetłumaczyć obiekt, za pomocą którego można dyktować 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'}"

Kluczową sekcją tego kodu jest __iter__funkcja.

Jak wyjaśniają komentarze, pierwszą rzeczą, którą robimy, jest chwytanie przedmiotów klasy i zapobieganie czegokolwiek, co zaczyna się od „__”.

Po utworzeniu dictmożesz użyć updatefunkcji dict i przekazać instancję __dict__.

To da ci pełny słownik klasy + instancji członków. Teraz pozostaje tylko iterować nad nimi i przynosić zyski.

Ponadto, jeśli planujesz dużo tego używać, możesz stworzyć @iterabledekorator zajęć.

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

Aby zbudować słownik z dowolnego obiektu , wystarczy użyć __dict__.

Pomija to atrybuty, które obiekt dziedziczy po swojej klasie. Na przykład,

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

hasattr (a, „x”) jest prawdą, ale „x” nie pojawia się w .__ dict__

Późna odpowiedź, ale pod warunkiem kompletności i korzyści pracowników Google:

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

Nie wyświetli to metod zdefiniowanych w klasie, ale nadal pokaże pola, w tym te przypisane do lambdas lub te, które zaczynają się od podwójnego podkreślenia.

Myślę, że najprostszym sposobem jest utworzenie atrybutu getitem dla klasy. Jeśli chcesz pisać do obiektu, możesz utworzyć niestandardowy setattr . Oto przykład 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 generuje atrybuty obiektów do słownika, a obiektu słownika można użyć do uzyskania potrzebnego elementu.

Minusem używania __dict__jest to, że jest płytka; nie przekształci żadnych podklas w słowniki.

Jeśli używasz języka Python 3.5 lub nowszego, możesz użyć jsons:

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

Jeśli chcesz wyświetlić część swoich atrybutów, zastąp __dict__:

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

# Call __dict__
d = instance.__dict__()

To bardzo pomaga, jeśli instancedostajesz duże dane bloków i chcesz dprzesłać do Redis jak kolejka wiadomości.

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

Teraz możesz użyć powyższego kodu we własnej klasie:

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() jest świetny, ale nie działa dla zagnieżdżonych obiektów obiektów

Konwertuj zagnieżdżony obiekt obiektów na dyktowanie:

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