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

Question

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

我找到了this question about creating a dictionary from an object's fields，但它并没有递归。

对 python 来说相对较新，我担心我的解决方案可能很丑陋，或者 unpythonic，或者以某种模糊的方式损坏，或者只是普通的旧 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

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

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

tod​​ict 只会在 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

对 Shabbyrobe 的回答稍作更新，使其适用于 namedtuples：

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 8

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 9

查看了所有解决方案，@hbristow 的答案与我所寻找的最接近。 添加了enum.Enum 处理，因为这会导致RecursionError: maximum recursion depth exceeded 错误，并且使用__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 10

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

import jsons

object_dict = jsons.dump(object_instance)

Answer 11

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

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

Answer 12

嗯。添加了将深度限制为@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