通过数据循环嵌套字典

Question

我有一个相当难的问题，我只是无法修复.. 这个想法是循环浏览部分数据并找到任何缩进。 （总是空格） 每一行的缩进比前一个更大，例如4个空格，第一行应该是字典的关键字，并且应该附加下一个值。

如果还有另一个缩进，这意味着应该创建一个带有键和值的新字典。这应该发生递归，直到通过数据。 为了让事情更容易理解我做了一个例子：

Chassis 1: 
    Servers: 
     Server 1/1: 
      Equipped Product Name: EEE UCS B200 M3 
      Equiped PID: e63-samp-33 
      Equipped VID: V01 
      Acknowledged Cores: 16 
      Acknowledged Adapters: 1 
    PSU 1: 
     Presence: Equipped 
     VID: V00 
     HW Revision: 0 

的想法是能够得到在字典的形式返回数据的任何部分。 dictionary.get（“Chassis 1：”）应该返回所有数据，dictionary.get（“Servers”）应该返回比“Servers”行更深地缩进的所有内容。字典.get（“PSU 1：”）应该给出{“PSU 1：”：“Presence：Equipped”，“VID：100”，“HW Revision：0”}等等。 我已经绘制了一个小计划来证明这一点，每种颜色是另一个字典。

当缩进再次变得较小时，例如从8到4个空格时，应将数据附加到数据较少缩进的字典中。

我已经把它在代码试图，但它不来接近我想要的任何地方..

for item in Array: 
    regexpatt = re.search(":$", item) 
    if regexpatt: 
     keyFound = True 
     break 

if not keyFound: 
    return Array 

#Verify if we still have lines with spaces 
spaceFound = False 
for item in Array: 
    if item != item.lstrip(): 
     spaceFound = True 
     break 

if not spaceFound: 
    return Array 

keyFound = False 
key="" 
counter = -1 
for item in Array: 
    counter += 1 
    valueTrim = item.lstrip() 
    valueL = len(item) 
    valueTrimL = len(valueTrim) 
    diff = (valueL - valueTrimL) 
    nextSame = False 
    if item in Array: 
     nextValue = Array[counter] 
     nextDiff = (len(nextValue) - len(nextValue.lstrip())) 
     if diff == nextDiff: 
      nextSame = True 


    if diff == 0 and valueTrim != "" and nextSame is True: 
     match = re.search(":$", item) 
     if match: 
      key = item 
      newArray[key] = [] 
      deptDetermine = True 
      keyFound = True 
    elif diff == 0 and valueTrim != "" and keyFound is False: 
     newArray["0"].append(item) 
    elif valueTrim != "": 
     if depthDetermine: 
      depth = diff 
      deptDetermine = False 
     #newValue = item[-valueL +depth] 
     item = item.lstrip().rstrip() 
     newArray[key].append(item) 

for item in newArray: 
    if item != "0": 
     newArray[key] = newArray[key] 

return newArray 

结果应该是这样的，例如：

{ 
    "Chassis 1": { 
     "PSU 1": { 
      "HW Revision: 0", 
      "Presence: Equipped", 
      "VID: V00" 
     }, 
     "Servers": { 
      "Server 1/1": { 
       "Acknowledged Adapters: 1", 
       "Acknowledged Cores: 16", 
       "Equiped PID: e63-samp-33", 
       "Equipped Product Name: EEE UCS B200 M3", 
       "Equipped VID: V01" 
      } 
     } 
    } 
} 

我希望这解释了足够的概念

Answer 1

这应该给你你想要的嵌套结构。

如果你想每个嵌套dictonary，也可以从根。取消对if .. is not root部分

def parse(data): 

    root = {} 
    currentDict = root 
    prevLevel = -1 
    parents = [] 
    for line in data: 
     if line.strip() == '': continue 
     level = len(line) - len(line.lstrip(" ")) 
     key, value = [val.strip() for val in line.split(':', 1)] 

     if level > prevLevel and not len(value): 
      currentDict[key] = {} 
      # if currentDict is not root: 
      #  root[key] = currentDict[key] 
      parents.append((currentDict, level)) 
      currentDict = currentDict[key] 
      prevLevel = level 
     elif level < prevLevel and not len(value): 
      parentDict, parentLevel = parents.pop() 
      while parentLevel != level: 
       if not parents: return root 
       parentDict, parentLevel = parents.pop() 
      parentDict[key] = {} 
      parents.append((parentDict, level)) 
      # if parentDict is not root: 
      #  root[key] = parentDict[key] 
      currentDict = parentDict[key] 
      prevLevel = level 
     else: 
      currentDict[key] = value 
    return root 




with open('data.txt', 'r') as f: 
    data = parse(f) 
    #for pretty print of nested dict 
    import json 
    print json.dumps(data,sort_keys=True, indent=4) 

输出：

{ 
    "Chassis 1": { 
     "PSU 1": { 
      "HW Revision": "0", 
      "Presence": "Equipped", 
      "VID": "V00" 
     }, 
     "Servers": { 
      "Server 1/1": { 
       "Acknowledged Adapters": "1", 
       "Acknowledged Cores": "16", 
       "Equiped PID": "e63-samp-33", 
       "Equipped Product Name": "EEE UCS B200 M3", 
       "Equipped VID": "V01" 
      } 
     } 
    } 
} 

Answer 2

这些数据格式确实看起来像YAML。万一有人绊倒这是细带库解决方案：

import yaml 
import pprint 

s = """ 
Chassis 1: 
    Servers: 
     Server 1/1: 
      Equipped Product Name: EEE UCS B200 M3 
      Equiped PID: e63-samp-33 
      Equipped VID: V01 
      Acknowledged Cores: 16 
      Acknowledged Adapters: 1 
    PSU 1: 
     Presence: Equipped 
     VID: V00 
     HW Revision: 0 
""" 

d = yaml.load(s) 
pprint.pprint(d) 

输出是：

{'Chassis 1': {'PSU 1': {'HW Revision': 0, 
         'Presence': 'Equipped', 
         'VID': 'V00'}, 
       'Servers': {'Server 1/1': {'Acknowledged Adapters': 1, 
              'Acknowledged Cores': 16, 
              'Equiped PID': 'e63-samp-33', 
              'Equipped Product Name': 'EEE UCS B200 M3', 
              'Equipped VID': 'V01'}}}} 

参考：

• http://en.wikipedia.org/wiki/YAML
• https://pypi.python.org/pypi/PyYAML
• http://pyyaml.org/wiki/PyYAMLDocumentation
• https://docs.python.org/2/library/pprint.html#pprint.pprint