从缩进文本fi中创建具有列表的树/深度嵌套dict

Question

我希望遍历一个文件，并将每一行的内容放入一个深度嵌套的dict中，dict的结构由前导空格定义。这个愿望很像文档中的here。我已经解决了这个问题，但现在有一个问题，即重复键被覆盖而不是被强制转换到列表中。在

基本上：

a:
    b:      c
    d:      e
a:
    b:      c2
    d:      e2
    d:      wrench

当它应该被转换成

^{pr2}$

一个独立的例子：

import json

def jsonify_indented_tree(tree):
    #convert indentet text into json
    parsedJson= {}
    parentStack = [parsedJson]
    for i, line in enumerate(tree):
        data = get_key_value(line)
        if data['key'] in parsedJson.keys(): #if parent key is repeated, then cast value as list entry
            # stuff that doesn't work
#            if isinstance(parsedJson[data['key']],list):
#                parsedJson[data['key']].append(parsedJson[data['key']])
#            else:
#                parsedJson[data['key']]=[parsedJson[data['key']]]
            print('Hey - Make a list now!')
        if data['value']: #process child by adding it to its current parent
            currentParent = parentStack[-1] #.getLastElement()
            currentParent[data['key']] = data['value']
            if i is not len(tree)-1:
                #determine when to switch to next branch
                level_dif = data['level']-get_key_value(tree[i+1])['level'] #peek next line level
                if (level_dif > 0):
                    del parentStack[-level_dif:] #reached leaf, process next branch
        else:
        #group node, push it as the new parent and keep on processing.
            currentParent = parentStack[-1] #.getLastElement()
            currentParent[data['key']] = {}
            newParent = currentParent[data['key']]
            parentStack.append(newParent)
    return parsedJson

def get_key_value(line):
    key = line.split(":")[0].strip()
    value = line.split(":")[1].strip()
    level = len(line) - len(line.lstrip())
    return {'key':key,'value':value,'level':level}

def pp_json(json_thing, sort=True, indents=4):
    if type(json_thing) is str:
        print(json.dumps(json.loads(json_thing), sort_keys=sort, indent=indents))
    else:
        print(json.dumps(json_thing, sort_keys=sort, indent=indents))
    return None

#nested_string=['a:', '\tb:\t\tc', '\td:\t\te', 'a:', '\tb:\t\tc2', '\td:\t\te2']
#nested_string=['w:','\tgeneral:\t\tcase','a:','\tb:\t\tc','\td:\t\te','a:','\tb:\t\tc2','\td:\t\te2']
nested_string=['a:',
 '\tb:\t\tc',
 '\td:\t\te',
 'a:',
 '\tb:\t\tc2',
 '\td:\t\te2',
  '\td:\t\twrench']

pp_json(jsonify_indented_tree(nested_string))

Answer 1

这种方法（逻辑上）更直接（虽然更长）：

1. 跟踪多行字符串中每行的level和key-value对
2. 将此数据存储在level键控的列表dict中： {{}:[dict1，dict2]}
3. 只追加一个字符串，该字符串表示只在key-only行中：{level1:[dict1，dict2，"nestKeyA"]}
4. 因为一个键的行意味着下一行更深一层，所以在下一层处理它：{{}:[dict1，dict2，"nestKeyA"]，level2:[…]}。一些更深层次的内容{}的内容本身可能只是另一条只对钥匙的线路（下一个循环将增加一个新的水平{{}}，这样它将成为{{{}:[^{{}，^{{}，"nestKeyA"]，^{>}，^{}:[{{}]，level3:[……]}）或一个新的口述{{{{{{{}，{{{{}，{{{{{{{{{{{level1:[dict1，dict2，"nestKeyA"]，level2:[dict3]

5. 继续执行步骤1-4，直到当前行的缩进量小于上一行的缩进量（表示返回到以前的某个范围）。这就是我的示例中每行迭代的数据结构。在

   0, {0: []}
   1, {0: [{'k': 'sds'}]}
   2, {0: [{'k': 'sds'}, 'a']}
   3, {0: [{'k': 'sds'}, 'a'], 1: [{'b': 'c'}]}
   4, {0: [{'k': 'sds'}, 'a'], 1: [{'b': 'c'}, {'d': 'e'}]}
   5, {0: [{'k': 'sds'}, {'a': {'d': 'e', 'b': 'c'}}, 'a'], 1: []}
   6, {0: [{'k': 'sds'}, {'a': {'d': 'e', 'b': 'c'}}, 'a'], 1: [{'b': 'c2'}]}
   7, {0: [{'k': 'sds'}, {'a': {'d': 'e', 'b': 'c'}}, 'a'], 1: [{'b': 'c2'}, {'d': 'e2'}]}
   

   那么有两件事需要发生。1：需要检查dict列表是否包含重复的键以及组合在列表中的任何重复dict值-这将在稍后演示。2：正如在迭代4和迭代5之间可以看到的，来自最深层的dict列表（这里1）被组合成一个dict。。。最后，为了演示重复操作，请观察：

   ^{pr2}$

   其中wrench和e2被放在一个列表中，这个列表本身进入一个由它们的原始密钥键控制的dict中。

6. 重复步骤1-5，将作用域更深的dict提升到其父键上，直到到达当前行的scope（level）。

7. 处理终止条件，将第零级的dict列表合并为dict

代码如下：

import json

def get_kvl(line):
    key = line.split(":")[0].strip()
    value = line.split(":")[1].strip()
    level = len(line) - len(line.lstrip())
    return {'key':key,'value':value,'level':level}

def pp_json(json_thing, sort=True, indents=4):
    if type(json_thing) is str:
        print(json.dumps(json.loads(json_thing), sort_keys=sort, indent=indents))
    else:
        print(json.dumps(json_thing, sort_keys=sort, indent=indents))
    return None

def jsonify_indented_tree(tree): #convert shitty sgml header into json
    level_map= {0:[]}
    tree_length=len(tree)-1
    for i, line in enumerate(tree):
        data = get_kvl(line)
        if data['level'] not in level_map.keys():
            level_map[data['level']]=[] # initialize
        prior_level=get_kvl(tree[i-1])['level']
        level_dif = data['level']-prior_level # +: line is deeper, -: shallower, 0:same
        if data['value']:
            level_map[data['level']].append({data['key']:data['value']})
        if not data['value'] or i==tree_length:
            if i==tree_length: #end condition
                level_dif = -len(list(level_map.keys()))        
            if level_dif < 0:
                for level in reversed(range(prior_level+level_dif+1,prior_level+1)): # (end, start)
                    #check for duplicate keys in current deepest (child) sibling group,
                    # merge them into a list, put that list in a dict 
                    key_freq={} #track repeated keys
                    for n, dictionary in enumerate(level_map[level]):
                        current_key=list(dictionary.keys())[0]
                        if current_key in list(key_freq.keys()):
                            key_freq[current_key][0]+=1
                            key_freq[current_key][1].append(n)
                        else:
                            key_freq[current_key]=[1,[n]]
                    for k,v in key_freq.items():
                        if v[0]>1: #key is repeated
                            duplicates_list=[]
                            for index in reversed(v[1]): #merge value of key-repeated dicts into list
                                duplicates_list.append(list(level_map[level].pop(index).values())[0])
                            level_map[level].append({k:duplicates_list}) #push that list into a dict on the same stack it came from
                    if i==tree_length and level==0: #end condition
                        #convert list-of-dict into dict
                        parsed_nest={k:v for d in level_map[level] for k,v in d.items()}
                    else:
                        #push current deepest (child) sibling group onto parent key
                        key=level_map[level-1].pop() #string
                        #convert child list-of-dict into dict
                        level_map[level-1].append({key:{k:v for d in level_map[level] for k,v in d.items()}})
                        level_map[level]=[] #reset deeper level
            level_map[data['level']].append(data['key'])
    return parsed_nest

nested_string=['k:\t\tsds', #need a starter key,value pair otherwise this won't work... fortunately I always have one
 'a:',
 '\tb:\t\tc',
 '\td:\t\te',
 'a:',
 '\tb:\t\tc2',
 '\td:\t\te2',
 '\td:\t\twrench']

pp_json(jsonify_indented_tree(nested_string))