De manière récursive convertir python objet graphique à dictionnaire

Une fusion de ma propre tentative et indices dérivés de Anurag Uniyal et Lennart Regebro réponses qui fonctionne le mieux pour moi:

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

Je ne sais pas quel est le but de la vérification de basestring ou d'un objet? aussi dict ne contiennent aucune callables sauf si vous avez attributs pointant vers ces callables, mais dans ce cas, n'est-ce pas partie de l'objet?

donc, au lieu de vérifier les différents types et les valeurs, laissez todict convertir l'objet et s'il lève l'exception, de l'utilisateur à l'origine de la valeur.

todict ne raise exception si obj n'a pas dict
par exemple,

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)

il imprime {'b1': 1, 'b2': 2, 'o1': {'a1': 1}}
il peut y avoir quelques autres cas à considérer, mais il peut être un bon début

cas spéciaux
si un objet utilise des machines à sous alors vous ne serez pas en mesure d'obtenir dict par exemple

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

correctif pour les fentes des cas peut être utiliser dir() au lieu d'utiliser directement la dict

Je me rends compte que cette réponse est un peu trop tard, mais j'ai pensé qu'il pourrait être utile de partager car c'est un Python 3.3,+ compatible modification de la solution d'origine par @Shabbyrobe qui a généralement bien fonctionné pour moi:

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

Si vous n'êtes pas intéressé par appelable attributs, par exemple, ils peuvent être supprimés dans le dictionnaire de la compréhension:

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

Une petite mise à jour pour Shabbyrobe de réponse pour le faire fonctionner pour 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