Преобразовать Python dict в объект?

Обновление: в Python 2.6 и далее рассмотрите, соответствует ли namedtuple данных namedtuple вашим потребностям:

 >>> from collections import namedtuple >>> MyStruct = namedtuple('MyStruct', 'ab d') >>> s = MyStruct(a=1, b={'c': 2}, d=['hi']) >>> s MyStruct(a=1, b={'c': 2}, d=['hi']) >>> sa 1 >>> sb {'c': 2} >>> sc Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'MyStruct' object has no attribute 'c' >>> sd ['hi'] 

Альтернативный (исходное содержание ответа):

 class Struct: def __init__(self, **entries): self.__dict__.update(entries) 

Затем вы можете использовать:

 >>> args = {'a': 1, 'b': 2} >>> s = Struct(**args) >>> s <__main__.Struct instance at 0x01D6A738> >>> sa 1 >>> sb 2 

 class obj(object): def __init__(self, d): for a, b in d.items(): if isinstance(b, (list, tuple)): setattr(self, a, [obj(x) if isinstance(x, dict) else x for x in b]) else: setattr(self, a, obj(b) if isinstance(b, dict) else b) >>> d = {'a': 1, 'b': {'c': 2}, 'd': ["hi", {'foo': "bar"}]} >>> x = obj(d) >>> xbc 2 >>> xd[1].foo 'bar' 

Удивительно, но никто не упомянул Букет . Эта библиотека предназначена исключительно для обеспечения доступа к стилю атрибутов для объектов dict и делает именно то, что хочет OP. Демонстрация:

 >>> from bunch import bunchify >>> d = {'a': 1, 'b': {'c': 2}, 'd': ["hi", {'foo': "bar"}]} >>> x = bunchify(d) >>> xa 1 >>> xbc 2 >>> xd[1].foo 'bar' 

Библиотека Python 3 доступна по адресу https://github.com/Infinidat/munch – Кредит отправляется на codyzu

 x = type('new_dict', (object,), d) 

затем добавьте рекурсию к этому, и все готово.

отредактируйте это, как я его реализую:

 >>> d {'a': 1, 'b': {'c': 2}, 'd': ['hi', {'foo': 'bar'}]} >>> def obj_dic(d): top = type('new', (object,), d) seqs = tuple, list, set, frozenset for i, j in d.items(): if isinstance(j, dict): setattr(top, i, obj_dic(j)) elif isinstance(j, seqs): setattr(top, i, type(j)(obj_dic(sj) if isinstance(sj, dict) else sj for sj in j)) else: setattr(top, i, j) return top >>> x = obj_dic(d) >>> xa 1 >>> xbc 2 >>> xd[1].foo 'bar' 

Для тех, кто сейчас спотыкается об этом вопросе. В Python 2.6+ есть помощник коллекции, называемый namedtuple , который может сделать это для вас:

 from collections import namedtuple d_named = namedtuple('Struct', d.keys())(*d.values()) In [7]: d_named Out[7]: Struct(a=1, b={'c': 2}, d=['hi', {'foo': 'bar'}]) In [8]: d_named.a Out[8]: 1 

Принимая то, что я считаю лучшими аспектами предыдущих примеров, вот что я придумал:

 class Struct: '''The recursive class for building and representing objects with.''' def __init__(self, obj): for k, v in obj.iteritems(): if isinstance(v, dict): setattr(self, k, Struct(v)) else: setattr(self, k, v) def __getitem__(self, val): return self.__dict__[val] def __repr__(self): return '{%s}' % str(', '.join('%s : %s' % (k, repr(v)) for (k, v) in self.__dict__.iteritems())) 

 class Struct(object): """Comment removed""" def __init__(self, data): for name, value in data.iteritems(): setattr(self, name, self._wrap(value)) def _wrap(self, value): if isinstance(value, (tuple, list, set, frozenset)): return type(value)([self._wrap(v) for v in value]) else: return Struct(value) if isinstance(value, dict) else value 

Может использоваться с любой структурой последовательности / dict / value любой глубины.

Если ваш dict исходит из json.loads() , вы можете превратить его в объект вместо (а не dict) в одну строку:

 import json from collections import namedtuple json.loads(data, object_hook=lambda d: namedtuple('X', d.keys())(*d.values())) 

См. Также Как преобразовать данные JSON в объект Python .

Если вы хотите получить доступ к ключам dict в качестве объекта (или как dict для сложных клавиш), сделайте это рекурсивно, а также сможете обновить оригинальный dict, вы могли бы сделать:

 class Dictate(object): """Object view of a dict, updating the passed in dict when values are set or deleted. "Dictate" the contents of a dict...: """ def __init__(self, d): # since __setattr__ is overridden, self.__dict = d doesn't work object.__setattr__(self, '_Dictate__dict', d) # Dictionary-like access / updates def __getitem__(self, name): value = self.__dict[name] if isinstance(value, dict): # recursively view sub-dicts as objects value = Dictate(value) return value def __setitem__(self, name, value): self.__dict[name] = value def __delitem__(self, name): del self.__dict[name] # Object-like access / updates def __getattr__(self, name): return self[name] def __setattr__(self, name, value): self[name] = value def __delattr__(self, name): del self[name] def __repr__(self): return "%s(%r)" % (type(self).__name__, self.__dict) def __str__(self): return str(self.__dict) 

Пример использования:

 d = {'a': 'b', 1: 2} dd = Dictate(d) assert dd.a == 'b' # Access like an object assert dd[1] == 2 # Access like a dict # Updates affect d dd.c = 'd' assert d['c'] == 'd' del dd.a del dd[1] # Inner dicts are mapped dd.e = {} dd.ef = 'g' assert dd['e'].f == 'g' assert d == {'c': 'd', 'e': {'f': 'g'}} 

 >>> def dict2obj(d): if isinstance(d, list): d = [dict2obj(x) for x in d] if not isinstance(d, dict): return d class C(object): pass o = C() for k in d: o.__dict__[k] = dict2obj(d[k]) return o >>> d = {'a': 1, 'b': {'c': 2}, 'd': ["hi", {'foo': "bar"}]} >>> x = dict2obj(d) >>> xa 1 >>> xbc 2 >>> xd[1].foo 'bar' 

x.__dict__.update(d) должен преуспеть.

Это должно начаться:

 class dict2obj(object): def __init__(self, d): self.__dict__['d'] = d def __getattr__(self, key): value = self.__dict__['d'][key] if type(value) == type({}): return dict2obj(value) return value d = {'a': 1, 'b': {'c': 2}, 'd': ["hi", {'foo': "bar"}]} x = dict2obj(d) print xa print xbc print xd[1].foo 

Это пока не работает для списков. Вам придется обернуть списки в UserList и перегрузить __getitem__ для __getitem__ .

Я закончил тем, что попробовал BOTH библиотеки AttrDict и Bunch и нашел, что они слишком медленны для моих целей. После того, как мы с другом познакомились с ним, мы обнаружили, что основной метод написания этих библиотек приводит к тому, что библиотека агрессивно рекурсивно рекурсирует через вложенный объект и создает копии словарного объекта. Имея это в виду, мы сделали два ключевых изменения. 1) Мы создали атрибуты lazy-loaded 2) вместо создания копий словарного объекта, мы создаем копии легкого прокси-объекта. Это окончательная реализация. Увеличение производительности при использовании этого кода невероятно. При использовании AttrDict или Bunch эти две библиотеки сами потребляли 1/2 и 1/3 соответственно моего времени запроса (что !?). Этот код сократил это время почти до нуля (где-то в диапазоне 0,5 мс). Это, конечно, зависит от ваших потребностей, но если вы используете эту функциональность совсем немного в своем коде, определенно переходите к чему-то простому.

 class DictProxy(object): def __init__(self, obj): self.obj = obj def __getitem__(self, key): return wrap(self.obj[key]) def __getattr__(self, key): try: return wrap(getattr(self.obj, key)) except AttributeError: try: return self[key] except KeyError: raise AttributeError(key) # you probably also want to proxy important list properties along like # items(), iteritems() and __len__ class ListProxy(object): def __init__(self, obj): self.obj = obj def __getitem__(self, key): return wrap(self.obj[key]) # you probably also want to proxy important list properties along like # __iter__ and __len__ def wrap(value): if isinstance(value, dict): return DictProxy(value) if isinstance(value, (tuple, list)): return ListProxy(value) return value 

См. Первоначальную реализацию здесь : https://stackoverflow.com/users/704327/michael-merickel .

Другое дело отметить, что эта реализация довольно проста и не реализует все методы, которые могут вам понадобиться. Вам нужно будет написать те, которые требуются для объектов DictProxy или ListProxy.

Старые вопросы и ответы, но мне нужно поговорить больше. Кажется, никто не говорит о рекурсивном диктате. Это мой код:

 #!/usr/bin/env python class Object( dict ): def __init__( self, data = None ): super( Object, self ).__init__() if data: self.__update( data, {} ) def __update( self, data, did ): dataid = id(data) did[ dataid ] = self for k in data: dkid = id(data[k]) if did.has_key(dkid): self[k] = did[dkid] elif isinstance( data[k], Object ): self[k] = data[k] elif isinstance( data[k], dict ): obj = Object() obj.__update( data[k], did ) self[k] = obj obj = None else: self[k] = data[k] def __getattr__( self, key ): return self.get( key, None ) def __setattr__( self, key, value ): if isinstance(value,dict): self[key] = Object( value ) else: self[key] = value def update( self, *args ): for obj in args: for k in obj: if isinstance(obj[k],dict): self[k] = Object( obj[k] ) else: self[k] = obj[k] return self def merge( self, *args ): for obj in args: for k in obj: if self.has_key(k): if isinstance(self[k],list) and isinstance(obj[k],list): self[k] += obj[k] elif isinstance(self[k],list): self[k].append( obj[k] ) elif isinstance(obj[k],list): self[k] = [self[k]] + obj[k] elif isinstance(self[k],Object) and isinstance(obj[k],Object): self[k].merge( obj[k] ) elif isinstance(self[k],Object) and isinstance(obj[k],dict): self[k].merge( obj[k] ) else: self[k] = [ self[k], obj[k] ] else: if isinstance(obj[k],dict): self[k] = Object( obj[k] ) else: self[k] = obj[k] return self def test01(): class UObject( Object ): pass obj = Object({1:2}) d = {} d.update({ "a": 1, "b": { "c": 2, "d": [ 3, 4, 5 ], "e": [ [6,7], (8,9) ], "self": d, }, 1: 10, "1": 11, "obj": obj, }) x = UObject(d) assert xa == x["a"] == 1 assert xbc == x["b"]["c"] == 2 assert xbd[0] == 3 assert xbd[1] == 4 assert xbe[0][0] == 6 assert xbe[1][0] == 8 assert x[1] == 10 assert x["1"] == 11 assert x[1] != x["1"] assert id(x) == id(xbself.b.self) == id(xbself) assert xbself.a == xbself.b.self.a == 1 xx = 12 assert xx == x["x"] == 12 xy = {"a":13,"b":[14,15]} assert xya == 13 assert xyb[0] == 14 def test02(): x = Object({ "a": { "b": 1, "c": [ 2, 3 ] }, 1: 6, 2: [ 8, 9 ], 3: 11, }) y = Object({ "a": { "b": 4, "c": [ 5 ] }, 1: 7, 2: 10, 3: [ 12 , 13 ], }) z = { 3: 14, 2: 15, "a": { "b": 16, "c": 17, } } x.merge( y, z ) assert 2 in xac assert 3 in xac assert 5 in xac assert 1 in xab assert 4 in xab assert 8 in x[2] assert 9 in x[2] assert 10 in x[2] assert 11 in x[3] assert 12 in x[3] assert 13 in x[3] assert 14 in x[3] assert 15 in x[2] assert 16 in xab assert 17 in xac if __name__ == '__main__': test01() test02() 

Я наткнулся на случай, когда мне нужно было рекурсивно преобразовать список диктонов в список объектов, поэтому на основе фрагмента Роберто здесь была сделана работа для меня:

 def dict2obj(d): if isinstance(d, dict): n = {} for item in d: if isinstance(d[item], dict): n[item] = dict2obj(d[item]) elif isinstance(d[item], (list, tuple)): n[item] = [dict2obj(elem) for elem in d[item]] else: n[item] = d[item] return type('obj_from_dict', (object,), n) elif isinstance(d, (list, tuple,)): l = [] for item in d: l.append(dict2obj(item)) return l else: return d 

Обратите внимание, что любой кортеж будет преобразован в его эквивалент списка по очевидным причинам.

Надеюсь, это поможет кому-то так же, как и все ваши ответы для меня, ребята.

Хотел загрузить мою версию этой маленькой парадигмы.

 class Struct(dict): def __init__(self,data): for key, value in data.items(): if isinstance(value, dict): setattr(self, key, Struct(value)) else: setattr(self, key, type(value).__init__(value)) dict.__init__(self,data) 

Он сохраняет атрибуты для типа, импортированного в класс. Мое единственное беспокойство было бы переписывать методы из словаря вашего разбора. Но в противном случае кажется солидным!

Вы можете использовать json модуль стандартной библиотеки с помощью пользовательского объекта hook :

 import json class obj(object): def __init__(self, dict_): self.__dict__.update(dict_) def dict2obj(d): return json.loads(json.dumps(d), object_hook=obj) 

Пример использования:

 >>> d = {'a': 1, 'b': {'c': 2}, 'd': ['hi', {'foo': 'bar'}]} >>> o = dict2obj(d) >>> oa 1 >>> obc 2 >>> od[0] u'hi' >>> od[1].foo u'bar' 

И это не строго для чтения, как и с namedtuple , т.е. вы можете изменять значения – не структуру:

 >>> obc = 3 >>> obc 3 

Как насчет того, чтобы просто назначить ваш dict для __dict__ пустого объекта?

 class Object: """If your dict is "flat", this is a simple way to create an object from a dict >>> obj = Object() >>> obj.__dict__ = d >>> da 1 """ pass 

Конечно, это не сработает на вашем примере вложенного дикта, если вы не будете рекурсивно проходить рекурсивно:

 # For a nested dict, you need to recursively update __dict__ def dict2obj(d): """Convert a dict to an object >>> d = {'a': 1, 'b': {'c': 2}, 'd': ["hi", {'foo': "bar"}]} >>> obj = dict2obj(d) >>> obj.bc 2 >>> obj.d ["hi", {'foo': "bar"}] """ try: d = dict(d) except (TypeError, ValueError): return d obj = Object() for k, v in d.iteritems(): obj.__dict__[k] = dict2obj(v) return obj 

И ваш элемент списка элементов, вероятно, должен был представлять собой Mapping , список пар (ключ, значение), например:

 >>> d = {'a': 1, 'b': {'c': 2}, 'd': [("hi", {'foo': "bar"})]} >>> obj = dict2obj(d) >>> obj.d.hi.foo "bar" 

Вот еще один способ реализовать оригинальное предложение SilentGhost:

 def dict2obj(d): if isinstance(d, dict): n = {} for item in d: if isinstance(d[item], dict): n[item] = dict2obj(d[item]) elif isinstance(d[item], (list, tuple)): n[item] = [dict2obj(elem) for elem in d[item]] else: n[item] = d[item] return type('obj_from_dict', (object,), n) else: return d 

Позвольте мне объяснить решение, которое я почти использовал некоторое время назад. Но во-первых, причина, по которой я этого не сделал, иллюстрируется тем, что следующий код:

 d = {'from': 1} x = dict2obj(d) print x.from 

дает эту ошибку:

  File "test.py", line 20 print x.from == 1 ^ SyntaxError: invalid syntax 

Поскольку «из» является ключевым словом Python, есть определенные словарные ключи, которые вы не можете разрешить.

Теперь мое решение позволяет получить доступ к элементам словаря, используя их имена напрямую. Но это также позволяет использовать «семантику словаря». Вот код с примером использования:

 class dict2obj(dict): def __init__(self, dict_): super(dict2obj, self).__init__(dict_) for key in self: item = self[key] if isinstance(item, list): for idx, it in enumerate(item): if isinstance(it, dict): item[idx] = dict2obj(it) elif isinstance(item, dict): self[key] = dict2obj(item) def __getattr__(self, key): return self[key] d = {'a': 1, 'b': {'c': 2}, 'd': ["hi", {'foo': "bar"}]} x = dict2obj(d) assert xa == x['a'] == 1 assert xbc == x['b']['c'] == 2 assert xd[1].foo == x['d'][1]['foo'] == "bar" 

Вот еще одна реализация:

 class DictObj(object): def __init__(self, d): self.__dict__ = d def dict_to_obj(d): if isinstance(d, (list, tuple)): return map(dict_to_obj, d) elif not isinstance(d, dict): return d return DictObj(dict((k, dict_to_obj(v)) for (k,v) in d.iteritems())) 

[Edit] Пропущенный бит о том, как обрабатывать dicts внутри списков, а не только другие dicts. Добавлено исправление.

Как насчет этого:

 from functools import partial d2o=partial(type, "d2o", ()) 

Затем это можно использовать следующим образом:

 >>> o=d2o({"a" : 5, "b" : 3}) >>> print oa 5 >>> print ob 3 

 from mock import Mock d = {'a': 1, 'b': {'c': 2}, 'd': ["hi", {'foo': "bar"}]} my_data = Mock(**d) # We got # my_data.a == 1 

Я думаю, что dict состоит из числа, строки и dict – достаточно времени. Поэтому я игнорирую ситуацию, когда кортежи, списки и другие типы не появляются в последнем измерении dict.

Учитывая наследование, в сочетании с рекурсией, он решает проблему печати удобно, а также предоставляет два способа запроса данных – один из способов редактирования данных.

См. Пример ниже, dict, который описывает некоторую информацию о студентах:

 group=["class1","class2","class3","class4",] rank=["rank1","rank2","rank3","rank4","rank5",] data=["name","sex","height","weight","score"] #build a dict based on the lists above student_dic=dict([(g,dict([(r,dict([(d,'') for d in data])) for r in rank ]))for g in group]) #this is the solution class dic2class(dict): def __init__(self, dic): for key,val in dic.items(): self.__dict__[key]=self[key]=dic2class(val) if isinstance(val,dict) else val student_class=dic2class(student_dic) #one way to edit: student_class.class1.rank1['sex']='male' student_class.class1.rank1['name']='Nan Xiang' #two ways to query: print student_class.class1.rank1 print student_class.class1['rank1'] print '-'*50 for rank in student_class.class1: print getattr(student_class.class1,rank) 

Результаты:

 {'score': '', 'sex': 'male', 'name': 'Nan Xiang', 'weight': '', 'height': ''} {'score': '', 'sex': 'male', 'name': 'Nan Xiang', 'weight': '', 'height': ''} -------------------------------------------------- {'score': '', 'sex': '', 'name': '', 'weight': '', 'height': ''} {'score': '', 'sex': '', 'name': '', 'weight': '', 'height': ''} {'score': '', 'sex': 'male', 'name': 'Nan Xiang', 'weight': '', 'height': ''} {'score': '', 'sex': '', 'name': '', 'weight': '', 'height': ''} {'score': '', 'sex': '', 'name': '', 'weight': '', 'height': ''} 

 class Struct(dict): def __getattr__(self, name): try: return self[name] except KeyError: raise AttributeError(name) def __setattr__(self, name, value): self[name] = value def copy(self): return Struct(dict.copy(self)) 

Применение:

 points = Struct(x=1, y=2) # Changing points['x'] = 2 points.y = 1 # Accessing points['x'], points.x, points.get('x') # 2 2 2 points['y'], points.y, points.get('y') # 1 1 1 # Accessing inexistent keys/attrs points['z'] # KeyError: z points.z # AttributeError: z # Copying points_copy = points.copy() points.x = 2 points_copy.x # 1 

Исходя из моего ответа на « python: как добавить свойство в класс динамически? »:

 class data(object): def __init__(self,*args,**argd): self.__dict__.update(dict(*args,**argd)) def makedata(d): d2 = {} for n in d: d2[n] = trydata(d[n]) return data(d2) def trydata(o): if isinstance(o,dict): return makedata(o) elif isinstance(o,list): return [trydata(i) for i in o] else: return o 

Вы вызываете makedata в словаре, который хотите преобразовать, или, может быть, trydata зависимости от того, что вы ожидаете от ввода, и выплевываете объект данных.

Заметки:

• Вы можете добавить elifs в trydata если вам нужно больше функциональности.
• Очевидно, что это не сработает, если вы хотите xa = {} или подобное.
• Если вы хотите версию только для чтения, используйте данные класса из исходного ответа .

Это тоже хорошо работает

 class DObj(object): pass dobj = Dobj() dobj.__dict__ = {'a': 'aaa', 'b': 'bbb'} print dobj.a >>> aaa print dobj.b >>> bbb 

У меня были проблемы с __getattr__ не вызывались, поэтому я построил новую версию класса стиля:

 class Struct(object): '''The recursive class for building and representing objects with.''' class NoneStruct(object): def __getattribute__(*args): return Struct.NoneStruct() def __eq__(self, obj): return obj == None def __init__(self, obj): for k, v in obj.iteritems(): if isinstance(v, dict): setattr(self, k, Struct(v)) else: setattr(self, k, v) def __getattribute__(*args): try: return object.__getattribute__(*args) except: return Struct.NoneStruct() def __repr__(self): return '{%s}' % str(', '.join('%s : %s' % (k, repr(v)) for (k, v) in self.__dict__.iteritems())) 

В этой версии также добавлено NoneStruct , которое возвращается при вызове атрибута, который не задан. Это позволяет тестировать None, чтобы увидеть, присутствует ли атрибут. Очень полезно, когда точный ввод dict не известен (настройки и т. Д.).

 bla = Struct({'a':{'b':1}}) print(bla.ab) >> 1 print(bla.ac == None) >> True 

Мой словарь имеет такой формат:

 addr_bk = { 'person': [ {'name': 'Andrew', 'id': 123, 'email': 'andrew@mailserver.com', 'phone': [{'type': 2, 'number': '633311122'}, {'type': 0, 'number': '97788665'}] }, {'name': 'Tom', 'id': 456, 'phone': [{'type': 0, 'number': '91122334'}]}, {'name': 'Jack', 'id': 7788, 'email': 'jack@gmail.com'} ] } 

Как видно, у меня есть вложенные словари и список dicts . Это связано с тем, что addr_bk был декодирован из данных буфера протокола, который преобразован в python dict, используя lwpb.codec. Существует необязательное поле (например, электронная почта =>, где ключ может быть недоступен) и повторное поле (например, phone => преобразованный в список dict).

Я пробовал все вышеперечисленные предлагаемые решения. Некоторые не справляются с вложенными словарями. Другие не могут легко распечатать данные объекта.

Только решение, dict2obj (dict) от Dawie Strauss, работает лучше всего.

Я немного улучшил его, когда ключ не может быть найден:

 # Work the best, with nested dictionaries & lists! :) # Able to print out all items. class dict2obj_new(dict): def __init__(self, dict_): super(dict2obj_new, self).__init__(dict_) for key in self: item = self[key] if isinstance(item, list): for idx, it in enumerate(item): if isinstance(it, dict): item[idx] = dict2obj_new(it) elif isinstance(item, dict): self[key] = dict2obj_new(item) def __getattr__(self, key): # Enhanced to handle key not found. if self.has_key(key): return self[key] else: return None 

Затем я протестировал его с помощью:

 # Testing... ab = dict2obj_new(addr_bk) for person in ab.person: print "Person ID:", person.id print " Name:", person.name # Check if optional field is available before printing. if person.email: print " E-mail address:", person.email # Check if optional field is available before printing. if person.phone: for phone_number in person.phone: if phone_number.type == codec.enums.PhoneType.MOBILE: print " Mobile phone #:", elif phone_number.type == codec.enums.PhoneType.HOME: print " Home phone #:", else: print " Work phone #:", print phone_number.number 

Это другой, альтернативный способ преобразования списка словарей в объект:

 def dict2object(in_dict): class Struct(object): def __init__(self, in_dict): for key, value in in_dict.items(): if isinstance(value, (list, tuple)): setattr( self, key, [Struct(sub_dict) if isinstance(sub_dict, dict) else sub_dict for sub_dict in value]) else: setattr( self, key, Struct(value) if isinstance(value, dict) else value) return [Struct(sub_dict) for sub_dict in in_dict] \ if isinstance(in_dict, list) else Struct(in_dict)