將嵌套字典複雜轉換爲python中的對象

Question

自從我開始學習python以來，這種情況並不長，但我真的很想深入其中。並努力挖掘它。所以這裏是我已經研究了一段時間但尚未破解的任務：
我給出了嵌套字典和列表的混合組合（我們稱之爲「組合」），並且我需要實現函數，它允許訪問嵌套元素作爲對象屬性，也可以以某種方式將組合元素視爲可迭代的。這應該是這個樣子：

combination = { 
'item1': 3.14, 
'item2': 42, 
'items': [ 
     'text text text', 
     { 
      'field1': 'a', 
      'field2': 'b', 
     }, 
     { 
      'field1': 'c', 
      'field2': 'd', 
     }, 
     ] 
} 

def function(combination): 
    ... 

使
list(function(combination).items.field1) 會給：['a', 'c']和
list(function(combination).item1)會給：[3.14]。
編輯正如@FM提到的，我錯過了處理非字典元素的描述： list(function(combination).items[0]) >>>['text text text']

---

我試圖實現一個類（榮譽給Marc）幫我：

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

然後在功能使用它像return Struct(**combination)
雖然是版本呃漂亮，它只是達到預期結果的第一步。
但隨着下一步需要更深入，它壓倒了我，我無法自己做到。
因此，我懇請您的幫助。

Michael。

Answer 1

如何：

class ComboParser(object): 
    def __init__(self,data): 
     self.data=data 
    def __getattr__(self,key): 
     try: 
      return ComboParser(self.data[key]) 
     except TypeError: 
      result=[] 
      for item in self.data: 
       if key in item: 
        try: 
         result.append(item[key]) 
        except TypeError: pass 
      return ComboParser(result) 
    def __getitem__(self,key): 
     return ComboParser(self.data[key]) 
    def __iter__(self): 
     if isinstance(self.data,basestring): 
      # self.data might be a str or unicode object 
      yield self.data 
     else: 
      # self.data might be a list or tuple 
      try: 
       for item in self.data: 
        yield item 
      except TypeError: 
       # self.data might be an int or float 
       yield self.data 
    def __length_hint__(self): 
     return len(self.data) 

這將產生：

combination = { 
    'item1': 3.14, 
    'item2': 42, 
    'items': [ 
     'text text text', 
     { 
      'field1': 'a', 
      'field2': 'b', 
      }, 
     { 
      'field1': 'c', 
      'field2': 'd', 
      }, 
     { 
      'field1': 'e', 
      'field3': 'f', 
      },   
     ] 
    } 
print(list(ComboParser(combination).item1)) 
# [3.1400000000000001] 
print(list(ComboParser(combination).items)) 
# ['text text text', {'field2': 'b', 'field1': 'a'}, {'field2': 'd', 'field1': 'c'}, {'field3': 'f', 'field1': 'e'}] 
print(list(ComboParser(combination).items[0])) 
# ['text text text'] 
print(list(ComboParser(combination).items.field1)) 
# ['a', 'c', 'e'] 

Answer 2

我認爲基本上有兩種選擇，你可以追求在這裏：

1. 讓function轉換嵌套數據結構爲一系列鏈接在一​​起實現的協議支持list()和dict()對象（對象必須實施多種功能，包括至少__iter__，__len__,__getitem__等）。要創建對象，您需要定義實現這些行爲的類並遞歸地組裝它們，或者使用type()即時創建類。

2. 使function返回代理訪問底層數據結構的類。要實現允許非實際成員訪問成員屬性的類（即，執行function(combination).items），您可以覆蓋__getattr__。您將無法訪問「完整虛線路徑」，以便在此函數的任何單個調用中進行說話，因此它將不得不遞歸操作並在虛線路徑的每個級別返回其他實例。我相信這種方法比第一種方法更簡單。

Answer 3

什麼，你可能需要做的就是看你分配給每件商品的對象__dict__，看它本身是一個字典或迭代。

import types 
class Struct: 
    def __init__(self, **entries): 
     self.__dict__.update(entries) 
     for k,v in self.__dict__.items(): 
      if type(v) == types.DictType: 
       setattr(self, k, Struct(**v)) 

以便您使用遞歸排列。看起來是這樣的：

>>> b = Struct(a=1, b={'a':1}) 
>>> b.b.a 
1 

Answer 4

例如：

class Struct: 
    def __init__(self, **entries): 
     for key, value in entries.items(): 
      value2 = (Struct(**value) if isinstance(value, dict) else value) 
      self.__dict__[key] = value2 

entries = { 
    "a": 1, 
    "b": { 
     "c": { 
      "d": 2 
     } 
    } 
} 

obj = Struct(**entries) 
print(obj.a) #1 
print(obj.b.c.d) #2