Python字典从对象的字段

您知道是否有一个内置函数可以从任意对象构建字典吗?我想这样做:

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

注意:不应该包含方法。只有字段。

642414 次浏览
小开

内置的dir将为您提供对象的所有属性，包括特殊方法，如__str__， __dict__和其他一大堆您可能不想要的方法。但是你可以这样做:

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

因此，可以将其扩展为只返回数据属性而不返回方法，方法是这样定义props函数:

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
小开

我给出了两个答案的组合:

dict((key, value) for key, value in f.__dict__.iteritems()
if not callable(value) and not key.startswith('__'))
小开
最佳答案

注意，Python 2.7中的最佳实践是使用new-style类(Python 3中不需要)，即。

class Foo(object):
...

另外，“对象”和“类”之间也有区别。要从任意对象构建字典，使用__dict__就足够了。通常，你会在类级声明你的方法，在实例级声明你的属性，所以__dict__应该没问题。例如:

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

一个更好的方法(由罗伯特。在注释中建议)是内置的vars函数:

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

或者，根据你想做的事情，从dict继承可能会很好。然后你的类已经是一个字典，如果你愿意，你可以重写getattr和/或setattr来调用和设置字典。例如:

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


# etc...
小开

要从任意对象构建字典，使用__dict__就足够了。

这将遗漏对象从其类继承的属性。例如,

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

Hasattr (a， 'x')为真，但'x'没有出现在a.__dict__中

小开

回答晚了，但为了完整性和谷歌人的利益:

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

这将不会显示类中定义的方法，但仍然会显示字段，包括那些分配给lambdas的字段或那些以双下划线开头的字段。

小开

我认为最简单的方法是为类创建getitem属性。如果需要写入对象，可以创建自定义setattr。下面是一个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将对象属性生成到字典中，字典对象可用于获取所需的项。

小开

我想我应该花点时间向你展示如何通过dict(obj)将对象转换为dict。

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

这段代码的关键部分是__iter__函数。

正如注释所解释的，我们要做的第一件事是抓取Class项，并防止任何以'__'开头的内容。

一旦创建了dict，就可以使用update dict函数并传入实例__dict__。

这将为您提供一个完整的类+实例成员字典。现在剩下的就是遍历它们并产生返回值。

另外，如果你计划经常使用它，你可以创建一个@iterable类装饰器。

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.__dict__，使用vars(x)实际上更python化。

小开

如果你想列出部分属性，重写__dict__:

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


# Call __dict__
d = instance.__dict__()

如果你的instance得到一些大块数据，你想把d推到Redis消息队列，这很有帮助。

小开

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

现在你可以在你自己的类中使用上面的代码:

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()
小开

使用__dict__的一个缺点是它很浅;它不会将任何子类转换为字典。

如果你使用的是Python3.5或更高版本，你可以使用jsons:

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

vars()很好，但不适用于对象的嵌套对象

将对象的嵌套对象转换为dict:

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

正如在上面的评论之一中提到的，vars目前不是通用的，因为它不适用于具有__slots__而不是普通__dict__的对象。此外，一些对象(例如，像str或int这样的内置对象)具有既不、__dict__、__slots__0、__slots__。

目前，一个更通用的解决方案可能是:

def instance_attributes(obj: Any) -> Dict[str, Any]:
"""Get a name-to-value dictionary of instance attributes of an arbitrary object."""
try:
return vars(obj)
except TypeError:
pass


# object doesn't have __dict__, try with __slots__
try:
slots = obj.__slots__
except AttributeError:
# doesn't have __dict__ nor __slots__, probably a builtin like str or int
return {}
# collect all slots attributes (some might not be present)
attrs = {}
for name in slots:
try:
attrs[name] = getattr(obj, name)
except AttributeError:
continue
return attrs

例子:

class Foo:
class_var = "spam"




class Bar:
class_var = "eggs"
    

__slots__ = ["a", "b"]

>>> foo = Foo()
>>> foo.a = 1
>>> foo.b = 2
>>> instance_attributes(foo)
{'a': 1, 'b': 2}


>>> bar = Bar()
>>> bar.a = 3
>>> instance_attributes(bar)
{'a': 3}


>>> instance_attributes("baz")
{}

咆哮:

遗憾的是，vars还没有内置这个函数。Python中的许多内置程序都承诺是“the”;解决了一个问题，但总有一些特殊情况没有处理……在任何情况下，最终都必须手动编写代码。

小开

在2021年，对于嵌套对象/dicts/json使用pydantic BaseModel -将嵌套dicts和嵌套json对象转换为python对象和json，反之亦然:

< a href = " https://pydantic-docs.helpmanual。io /使用/模型/ noreferrer“rel = > https://pydantic-docs.helpmanual.io/usage/models/ < / >

>>> class Foo(BaseModel):
...     count: int
...     size: float = None
...
>>>
>>> class Bar(BaseModel):
...     apple = 'x'
...     banana = 'y'
...
>>>
>>> class Spam(BaseModel):
...     foo: Foo
...     bars: List[Bar]
...
>>>
>>> m = Spam(foo={'count': 4}, bars=[{'apple': 'x1'}, {'apple': 'x2'}])

对象to dict

>>> print(m.dict())
{'foo': {'count': 4, 'size': None}, 'bars': [{'apple': 'x1', 'banana': 'y'}, {'apple': 'x2', 'banana': 'y'}]}

对象转换为JSON

>>> print(m.json())
{"foo": {"count": 4, "size": null}, "bars": [{"apple": "x1", "banana": "y"}, {"apple": "x2", "banana": "y"}]}

反对的词典

>>> spam = Spam.parse_obj({'foo': {'count': 4, 'size': None}, 'bars': [{'apple': 'x1', 'banana': 'y'}, {'apple': 'x2', 'banana': 'y2'}]})
>>> spam
Spam(foo=Foo(count=4, size=None), bars=[Bar(apple='x1', banana='y'), Bar(apple='x2', banana='y2')])

JSON到对象

>>> spam = Spam.parse_raw('{"foo": {"count": 4, "size": null}, "bars": [{"apple": "x1", "banana": "y"}, {"apple": "x2", "banana": "y"}]}')
>>> spam
Spam(foo=Foo(count=4, size=None), bars=[Bar(apple='x1', banana='y'), Bar(apple='x2', banana='y')])
小开

试一试:

from pprint import pformat
a_dict = eval(pformat(an_obj))
小开

Python3.x

return dict((key, value) for key, value in f.__dict__.items() if not callable(value) and not key.startswith('__'))
小开

Dataclass(来自Python 3.7)是另一个可用于将类属性转换为dict的选项。asdict可以与数据类对象一起使用

例子:

@dataclass
class Point:
x: int
y: int


p = Point(10, 20)
asdict(p) # it returns {'x': 10, 'y': 20}

提交答案