如何通过键中的字符串递归地对字典进行分组

Question

我有一本像这样的字典：

d = {
'simulation__config__name': '0',
'simulation__config__ver': '1',
'simulation__config__rev': '2',
'simulation__model__name': '3',
'simulation__name': '4',
'site__name': '5',
'site__placement': '6',
'name': '7'}

我想按'__' 拆分键并将它们分组，然后按'__' 拆分这些键并将它们分组等，直到无法再分组。

最后，我会得到这样的结果：

out = {
 'simulation': {'simulation__config': {'simulation__config_name': 0,
                                       'simulation__config_ver': 1,
                                       'simulation__config_rev': 2},
                'simulation__model': {'simulation__model_name': 3},
                'simulation__name': 4},
 'site': {'site__name': 5, 'site__placement': 6},
 'name': 7}

我真的很难将递归函数组合在一起。我想我或多或少已经弄清楚了，从某种意义上说，如果我手动单步执行它，它就可以工作......但我无法弄清楚如何在没有手动干预的情况下让它正确调用。

这是我当前的代码：

from itertools import groupby

d = {
'simulation__config__name': '0',
'simulation__config__ver': '1',
'simulation__config__rev': '2',
'simulation__model__name': '3',
'simulation__name': '4',
'site__name': '5',
'site__placement': '6',
'name': '7'}

def get_key(string, i):
    return '__'.join(string.split('__')[0:i+1])

def recursive_group(iterable, i):
    if not isinstance(iterable, dict):
        return
    out = {}
    for k,g in groupby(iterable.keys(), lambda x: get_key(x,i)):
        inner = {key:iterable[key] for key in g}
        if k in iterable.keys():
            out.update(inner)
        else:
            out.update({k:inner})
    return out

out = recursive_group(d, 0)
#{'simulation': {'simulation__config__name': '0', 'simulation__config__ver': '1', 'simulation__config__rev': '2', 'simulation__model__name': '3', 'simulation__name': '4'}, 'site': {'site__name': '5', 'site__placement': '6'}, 'name': '7'}

out1 = recursive_group(out['simulation'], 1)
#{'simulation__config': {'simulation__config__name': '0', 'simulation__config__ver': '1', 'simulation__config__rev': '2'}, 'simulation__model': {'simulation__model__name': '3'}, 'simulation__name': '4'}

out2 = recursive_group(out1['simulation__config'], 2)
#{'simulation__config__name': '0', 'simulation__config__ver': '1', 'simulation__config__rev': '2'}

out3 = recursive_group(out2['simulation__config__name'], 3)
#None

out4 = recursive_group(out['site'], 1)
#{'site__name': '5', 'site__placement': '6'}

out5 = recursive_group(out4['site__name'], 2)
#None

out6 = recursive_group(out['name'], 1)
#None

在每个级别的分组中，我似乎都得到了想要的结果。当它到达不再发生分组的最终级别时，它返回一个无。我觉得我只是错过了最后几个步骤来将它们拼凑在一起。

请帮助编码专家！！

Answer 1

您可以通过首先创建一个包含所有键的链接字典，然后在一个循环中将每个子项连接到其父项来构建字典而无需递归：

d = {
'simulation__config__name': '0',
'simulation__config__ver': '1',
'simulation__config__rev': '2',
'simulation__model__name': '3',
'simulation__name': '4',
'site__name': '5',
'site__placement': '6',
'name': '7'}

from itertools import accumulate
keys  = {"__".join(pk) for k in d for pk in accumulate([s] for s in k.split("__"))}
links = { key:{} for key in keys }
out   = links[""] = dict()
for key in keys:
    parentKey = "__".join(key.split("__")[:-1])
    links[parentKey].update({key:d.get(key,links[key])}) # value from d for leaf nodes

输出：

print(out)

{'site': {'site__placement': '6', 'site__name': '5'},
 'name': '7',
 'simulation':
     {'simulation__model':
         {'simulation__model__name': '3'},
      'simulation__name': '4',
      'simulation__config':
         {'simulation__config__ver': '1',
          'simulation__config__rev': '2',
          'simulation__config__name': '0'
         }
     }
}

您还可以在链接完成后使用相同的链接字典从输出树结构中的键中删除冗余前缀：

for key,value in links.items():
    if isinstance(value,dict):
        for sk in list(value):
            value[sk.split("__")[-1]] = value.pop(sk)

print(out)

{'name': '7',
 'simulation':
     {'config': {'ver': '1', 'rev': '2', 'name': '0'},
      'name': '4',
      'model': {'name': '3'}
     },
 'site': {'placement': '6', 'name': '5'}
 }

Answer 2

如果您首先测试一个键是否已经在目标字典中，则不需要groupby。如果不是，则创建，否则，追加。

以下代码

import pprint

d = {
'simulation__config__name': '0',
'simulation__config__ver': '1',
'simulation__config__rev': '2',
'simulation__model__name': '3',
'simulation__name': '4',
'site__name': '5',
'site__placement': '6',
'name': '7'}

def recursive_group (iterable):
    out = {}
    for key in iterable:
        if '__' in key:
            left,right = key.split('__',1)
            if left not in out:
                out[left] = {}
            out[left][right] = iterable[key]
            if '__' in right:
                out[left] = recursive_group(out[left])
        else:
            out[key] = iterable[key]

    return out


out = recursive_group (d)
pprint.pprint (out, sort_dicts=False)

产生一个整洁、紧凑的嵌套字典：

{'simulation': {'config': {'name': '0', 'ver': '1', 'rev': '2'},
                'model': {'name': '3'},
                'name': '4'},
 'site': {'name': '5', 'placement': '6'},
 'name': '7'}

您可以使用另一个递归函数使用原始完整字符串表示法检索此结果中的值：

def get_value (iterable, full_name):
    if '__' in full_name:
        left,right = full_name.split('__',1)
        return get_value(iterable[left], right)
    return iterable[full_name]

print (get_value (out, 'simulation__config__ver'))