递归地将Python对象图转换为字典

Question

我正在尝试将数据从简单的对象图转换为字典。 我不需要类型信息或方法，也不需要能够再次将其转换回对象。

我发现这个关于从对象的字段创建字典的问题，但它没有不要递归地进行。

作为对Python相对较新的人，我担心我的解决方案可能很丑陋，或者不符合Python风格，或者以某种晦涩的方式被破坏，或者只是普通的旧NIH。

我的第一次尝试似乎有效，直到我尝试使用列表和字典，并且检查传递的对象是否有内部字典似乎更容易，如果没有，则将其视为一个值（而不是执行所有实例检查） ）。 我之前的尝试也没有递归到对象列表中：

def todict(obj):
    if hasattr(obj, "__iter__"):
        return [todict(v) for v in obj]
    elif hasattr(obj, "__dict__"):
        return dict([(key, todict(value)) 
            for key, value in obj.__dict__.iteritems() 
            if not callable(value) and not key.startswith('_')])
    else:
        return obj

这似乎工作得更好并且不需要例外，但我仍然不确定这里是否存在我不知道它在哪里失败的情况。

任何建议将不胜感激。

Answer 1

我自己的尝试和来自 Anurag Uniyal 和 Lennart Regebro 答案的线索的结合最适合我：

def todict(obj, classkey=None):
    if isinstance(obj, dict):
        data = {}
        for (k, v) in obj.items():
            data[k] = todict(v, classkey)
        return data
    elif hasattr(obj, "_ast"):
        return todict(obj._ast())
    elif hasattr(obj, "__iter__") and not isinstance(obj, str):
        return [todict(v, classkey) for v in obj]
    elif hasattr(obj, "__dict__"):
        data = dict([(key, todict(value, classkey)) 
            for key, value in obj.__dict__.items() 
            if not callable(value) and not key.startswith('_')])
        if classkey is not None and hasattr(obj, "__class__"):
            data[classkey] = obj.__class__.__name__
        return data
    else:
        return obj

Answer 2

一行代码将对象递归转换为 JSON。

import json

def get_json(obj):
  return json.loads(
    json.dumps(obj, default=lambda o: getattr(o, '__dict__', str(o)))
  )

obj = SomeClass()
print("Json = ", get_json(obj))

Answer 3

我不知道检查基字符串或对象的目的是什么？ 另外 dict 不会包含任何可调用对象，除非您有指向此类可调用对象的属性，但在这种情况下，这不是对象的一部分吗？

因此，不要检查各种类型和值，而是让 todict 转换对象，如果引发异常，则使用原始值。

todict 仅当 obj 没有 dict 时才会引发异常
例如，

class A(object):
    def __init__(self):
        self.a1 = 1

class B(object):
    def __init__(self):
        self.b1 = 1
        self.b2 = 2
        self.o1 = A()

    def func1(self):
        pass

def todict(obj):
    data = {}
    for key, value in obj.__dict__.iteritems():
        try:
            data[key] = todict(value)
        except AttributeError:
            data[key] = value
    return data

b = B()
print todict(b)

它打印 {'b1': 1, 'b2': 2, 'o1': {'a1': 1}}
可能还有一些其他情况需要考虑，但这可能是一个好的开始

特殊情况
如果对象使用插槽，那么您将无法获取 dict 例如，

class A(object):
    __slots__ = ["a1"]
    def __init__(self):
        self.a1 = 1

插槽情况的修复可以是使用 dir() 而不是直接使用 dict

Answer 4

一种缓慢但简单的方法是使用 jsonpickle 将对象转换为 JSON 字符串，然后使用 json.loads 将其转换回 Python 字典

： >dict = json.loads(jsonpickle.encode( obj, unpicklable=False ))

Answer 5

我意识到这个答案已经晚了几年，但我认为它可能值得分享，因为它是 @Shabbyrobe 对原始解决方案的 Python 3.3+ 兼容修改，通常对我来说效果很好：

import collections
try:
  # Python 2.7+
  basestring
except NameError:
  # Python 3.3+
  basestring = str 

def todict(obj):
  """ 
  Recursively convert a Python object graph to sequences (lists)
  and mappings (dicts) of primitives (bool, int, float, string, ...)
  """
  if isinstance(obj, basestring):
    return obj 
  elif isinstance(obj, dict):
    return dict((key, todict(val)) for key, val in obj.items())
  elif isinstance(obj, collections.Iterable):
    return [todict(val) for val in obj]
  elif hasattr(obj, '__dict__'):
    return todict(vars(obj))
  elif hasattr(obj, '__slots__'):
    return todict(dict((name, getattr(obj, name)) for name in getattr(obj, '__slots__')))
  return obj

如果你对可调用属性，例如，它们可以在字典理解中被剥离：

elif isinstance(obj, dict):
  return dict((key, todict(val)) for key, val in obj.items() if not callable(val))

Answer 6

在 Python 中，有很多方法可以使对象的行为略有不同，例如元类等，并且它可以覆盖 getattr ，从而具有您无法通过 dict 查看的“神奇”属性> 等。简而言之，无论您使用什么方法，您都不太可能在一般情况下获得 100% 的完整情况。

因此，答案是：如果它在您现在的用例中适用，那么代码是正确的。 ;-)

要制作更通用的代码，您可以这样做：

import types
def todict(obj):
    # Functions, methods and None have no further info of interest.
    if obj is None or isinstance(subobj, (types.FunctionType, types.MethodType))
        return obj

    try: # If it's an iterable, return all the contents
        return [todict(x) for x in iter(obj)]
    except TypeError:
        pass

    try: # If it's a dictionary, recurse over it:
        result = {}
        for key in obj:
            result[key] = todict(obj)
        return result
    except TypeError:
        pass

    # It's neither a list nor a dict, so it's a normal object.
    # Get everything from dir and __dict__. That should be most things we can get hold of.
    attrs = set(dir(obj))
    try:
        attrs.update(obj.__dict__.keys())
    except AttributeError:
        pass

    result = {}
    for attr in attrs:
        result[attr] = todict(getattr(obj, attr, None))
    return result            

类似的事情。 不过，该代码未经测试。 这仍然没有涵盖当您覆盖 getattr 时的情况，而且我确信还有更多的情况它没有涵盖并且可能无法涵盖。 :)

Answer 7

不需要自定义实现。 可以使用 jsons 库。

import jsons

object_dict = jsons.dump(object_instance)

Answer 8

谢谢@AnuragUniyal！
你让我今天一整天都感觉很好！
这是我的代码变体，对我有用：

# noinspection PyProtectedMember
def object_to_dict(obj):
    data = {}
    if getattr(obj, '__dict__', None):
        for key, value in obj.__dict__.items():
            try:
                data[key] = object_to_dict(value)
            except AttributeError:
                data[key] = value
        return data
    else:
        return obj

Answer 9

对 Shabbyrobe 的答案进行一点更新，使其适用于 namedtuple ：

def obj2dict(obj, classkey=None):
    if isinstance(obj, dict):
        data = {}
        for (k, v) in obj.items():
            data[k] = obj2dict(v, classkey)
        return data
    elif hasattr(obj, "_asdict"):
        return obj2dict(obj._asdict())
    elif hasattr(obj, "_ast"):
        return obj2dict(obj._ast())
    elif hasattr(obj, "__iter__"):
        return [obj2dict(v, classkey) for v in obj]
    elif hasattr(obj, "__dict__"):
        data = dict([(key, obj2dict(value, classkey))
                     for key, value in obj.__dict__.iteritems()
                     if not callable(value) and not key.startswith('_')])
        if classkey is not None and hasattr(obj, "__class__"):
            data[classkey] = obj.__class__.__name__
        return data
    else:
        return obj

Answer 10

def list_object_to_dict(lst):
    return_list = []
    for l in lst:
        return_list.append(object_to_dict(l))
    return return_list

def object_to_dict(object):
    dict = vars(object)
    for k,v in dict.items():
        if type(v).__name__ not in ['list', 'dict', 'str', 'int', 'float']:
                dict[k] = object_to_dict(v)
        if type(v) is list:
            dict[k] = list_object_to_dict(v)
    return dict

Answer 11

查看了所有解决方案，@hbristow 的答案最接近我正在寻找的答案。
添加了 enum.Enum 处理，因为这会导致 RecursionError：超出最大递归深度 错误，并使用 __slots__ 重新排序对象，使其优先于定义 <代码>__dict__。

def todict(obj):
  """
  Recursively convert a Python object graph to sequences (lists)
  and mappings (dicts) of primitives (bool, int, float, string, ...)
  """
  if isinstance(obj, str):
    return obj
  elif isinstance(obj, enum.Enum):
    return str(obj)
  elif isinstance(obj, dict):
    return dict((key, todict(val)) for key, val in obj.items())
  elif isinstance(obj, collections.Iterable):
    return [todict(val) for val in obj]
  elif hasattr(obj, '__slots__'):
    return todict(dict((name, getattr(obj, name)) for name in getattr(obj, '__slots__')))
  elif hasattr(obj, '__dict__'):
    return todict(vars(obj))
  return obj

Answer 12

我会对已接受的答案发表评论，但我的代表不够高......
接受的答案很好，但在 if 之后添加另一个 elif 来支持 NamedTuples 序列化以正确地进行听写：

    elif hasattr(obj, "_asdict"):
        return todict(obj._asdict())

Answer 13

出色地。 添加了限制 @Shabbyrobe 答案深度的功能。 认为对于回环的对象来说可能是值得的。

def todict(obj, limit=sys.getrecursionlimit(), classkey=None):
        if isinstance(obj, dict):
            if limit>=1:
                data = {}
                for (k, v) in obj.items():
                    data[k] = todict(v, limit-1,classkey)
                return data
            else:
                return 'class:'+obj.__class__.__name__
        elif hasattr(obj, "_ast"):
            return todict(obj._ast(), limit-1) if limit>=1 else {'class:'+obj.__class__.__name__}
        elif hasattr(obj, "__iter__") and not isinstance(obj, str):
            return [todict(v, limit-1, classkey) for v in obj] if limit>=1 else {'class:'+obj.__class__.__name__}
        elif hasattr(obj, "__dict__"):
            if limit>=1:
                data = dict([(key, todict(value, limit-1, classkey)) 
                    for key, value in obj.__dict__.items() 
                    if not callable(value) and not key.startswith('_')])
                if classkey is not None and hasattr(obj, "__class__"):
                    data[classkey] = obj.__class__.__name__
                return data
            else:
                return 'class:'+obj.__class__.__name__
        else:
            return obj

Answer 14

当类字段是类实例时，前面的答案不起作用。 用这个：

from dataclasses import dataclass, field

@dataclass
class BaseNumber:
    number:str = ''
    probability:float = 0.

@dataclass
class ContainerInfo:
    type:str = ''
    height:int = ''
    width:str = ''
    length:str = ''

@dataclass
class AdditionalNumber:
    number:str = ''
    prob:float = 0.
    info:ContainerInfo = ContainerInfo()

@dataclass  
class ContainerData:
    container_number = BaseNumber()
    container_type = AdditionalNumber()
    errors:list = field(default_factory=list)

    def todict(self, obj='sadasdas'):
        if obj == 'sadasdas':
            obj = self
            
        if isinstance(obj, dict):
            data = {}
            for (k, v) in obj.items():
                data[k] = self.todict(v)
            return data
        elif hasattr(obj, "_ast"):
            return self.todict(obj._ast())
        elif hasattr(obj, "__iter__") and not isinstance(obj, str):
            return [self.todict(v) for v in obj]
        elif hasattr(obj, "__dict__"):
            aaa = dir(obj)
            data = dict([(key, self.todict(value)) 
                for key, value in {field: getattr(obj, field) for field in dir(obj)}.items()
                if not callable(value) and not key.startswith('_')
            ])
            return data
        else:
            return obj