Từ điển Python từ các trường của đối tượng

Bạn có biết nếu có một hàm dựng sẵn để xây dựng một từ điển từ một đối tượng tùy ý không? Tôi muốn làm một cái gì đó như thế này:

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

LƯU Ý: Không nên bao gồm các phương pháp. Chỉ các lĩnh vực.

Lưu ý rằng cách thực hành tốt nhất trong Python 2.7 là sử dụng các lớp kiểu mới (không cần thiết với Python 3), tức là

class Foo(object):
   ...

Ngoài ra, có một sự khác biệt giữa một 'đối tượng' và 'lớp'. Để xây dựng một từ điển từ một đối tượng tùy ý , nó đủ để sử dụng __dict__. Thông thường, bạn sẽ khai báo các phương thức của mình ở cấp độ lớp và các thuộc tính của bạn ở cấp độ cá thể, vì vậy __dict__sẽ ổn thôi. Ví dụ:

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

Một cách tiếp cận tốt hơn (được đề xuất bởi robert trong các bình luận) là varshàm dựng sẵn :

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

Ngoài ra, tùy thuộc vào những gì bạn muốn làm, nó có thể là tốt để kế thừa từ dict. Sau đó, lớp của bạn đã là một từ điển và nếu bạn muốn, bạn có thể ghi đè getattrvà / hoặc setattrgọi qua và đặt lệnh. Ví dụ:

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

    # etc...

Thay vì x.__dict__, nó thực sự nhiều pythonic để sử dụng vars(x).

Các dirBUILTIN sẽ cung cấp cho bạn tất cả các thuộc tính của đối tượng, trong đó có phương pháp đặc biệt như __str__, __dict__và một bó toàn bộ những người khác mà có thể bạn không muốn. Nhưng bạn có thể làm một cái gì đó như:

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

Vì vậy, có thể mở rộng điều này để chỉ trả về các thuộc tính dữ liệu chứ không phải các phương thức, bằng cách xác định propshàm của bạn như thế này:

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

Tôi đã giải quyết với sự kết hợp của cả hai câu trả lời:

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

Tôi nghĩ rằng tôi sẽ dành chút thời gian để chỉ cho bạn cách bạn có thể dịch một đối tượng để đọc chính tả 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'}"

Phần quan trọng của mã này là __iter__ chức năng.

Như các ý kiến ​​giải thích, điều đầu tiên chúng tôi làm là lấy các mục Class và ngăn chặn mọi thứ bắt đầu bằng '__'.

Khi bạn đã tạo điều đó dict, sau đó bạn có thể sử dụng updatehàm dict và truyền vào ví dụ__dict__ .

Chúng sẽ cung cấp cho bạn một lớp hoàn chỉnh + từ điển ví dụ của các thành viên. Bây giờ tất cả những gì còn lại là lặp đi lặp lại chúng và mang lại lợi nhuận.

Ngoài ra, nếu bạn có kế hoạch sử dụng nó rất nhiều, bạn có thể tạo một trình @iterabletrang trí lớp.

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

Để xây dựng một từ điển từ một đối tượng tùy ý , nó đủ để sử dụng __dict__.

Điều này bỏ lỡ các thuộc tính mà đối tượng kế thừa từ lớp của nó. Ví dụ,

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

hasattr (a, 'x') là đúng, nhưng 'x' không xuất hiện trong .__ dict__

Câu trả lời muộn nhưng được cung cấp cho sự đầy đủ và lợi ích của nhân viên Google:

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

Điều này sẽ không hiển thị các phương thức được xác định trong lớp, nhưng nó vẫn sẽ hiển thị các trường bao gồm các trường được gán cho lambdas hoặc các phương thức bắt đầu bằng dấu gạch dưới kép.

Tôi nghĩ cách dễ nhất là tạo một thuộc tính getitem cho lớp. Nếu bạn cần ghi vào đối tượng, bạn có thể tạo một setattr tùy chỉnh . Đây là một ví dụ cho 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 tạo các thuộc tính đối tượng vào một từ điển và đối tượng từ điển có thể được sử dụng để lấy mục bạn cần.

Một nhược điểm của việc sử dụng __dict__ là nó nông; nó sẽ không chuyển đổi bất kỳ lớp con nào thành từ điển.

Nếu bạn đang sử dụng Python3.5 trở lên, bạn có thể sử dụng jsons:

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

Nếu bạn muốn liệt kê một phần thuộc tính của mình, hãy ghi đè __dict__:

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

# Call __dict__
d = instance.__dict__()

Điều này giúp ích rất nhiều nếu bạn instancenhận được một số dữ liệu khối lớn và bạn muốn đẩy dsang Redis như hàng đợi tin nhắn.

THỨ 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

Bây giờ bạn có thể sử dụng mã ở trên trong lớp của riêng bạn:

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() là tuyệt vời, nhưng không hoạt động cho các đối tượng lồng nhau của các đối tượng

Chuyển đổi đối tượng lồng nhau của các đối tượng thành dict:

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