Список диктовок для багаторівневого дикту на основі інформації про глибину

У мене є деякі дані, більш-менш такі:

[
{"tag": "A", "level":0},
{"tag": "B", "level":1},
{"tag": "D", "level":2},
{"tag": "F", "level":3},
{"tag": "G", "level":4},
{"tag": "E", "level":2},
{"tag": "H", "level":3},
{"tag": "I", "level":3},
{"tag": "C", "level":1},
{"tag": "J", "level":2},
]

Я хочу перетворити його в багаторівневий дикт на основі рівня глибини (ключ "рівень"):

{
    "A": {"level": 0, "children": {
            "B": {"level": 1, "children": {
                    "D": {"level": 2, "children": {
                            "F": {"level": 3, "children": {
                                    "G": {"level": 4, "children": {}}}}}},
                    "E": {"level": 2, "children": {
                            "H": {"level": 3, "children": {}},
                            "I": {"level": 3, "children": {}}}}}},
            "C": {"level": 1, "children": {
                    "J": {"level": 2, "children": {}}}}}}
}

Все, що я можу придумати зараз, - це цей невеликий фрагмент коду ... який, очевидно, порушується після кількох предметів:

def list2multilevel(list):
    children = {}
    parent = list.pop(0)
    tag = parent.get("Tag")
    level = parent.get("Level")
    for child in list:
        ctag = child.get("Tag")
        clevel = child.get("Level")
        if clevel == level + 1:
            children.update(list2multilevel(list))
        elif clevel <= level:
            print(clevel, level)
            break
    return {tag: children}

Спочатку сіла до нього у п’ятницю, і це мало бути лише невеликою вправою….

data = [
    {"tag": "A", "level": 0},
    {"tag": "B", "level": 1},
    {"tag": "D", "level": 2},
    {"tag": "F", "level": 3},
    {"tag": "G", "level": 4},
    {"tag": "E", "level": 2},
    {"tag": "H", "level": 3},
    {"tag": "I", "level": 3},
    {"tag": "C", "level": 1},
    {"tag": "J", "level": 2},
]

root = {'level': -1, 'children': {}}
parents = {-1: root}
for datum in data:
    level = datum['level']
    parents[level] = parents[level - 1]['children'][datum['tag']] = {
        'level': datum['level'],
        'children': {},
    }
result = root['children']
print(result)

вихід:

{'A': {'level': 0, 'children': {'B': {'level': 1, 'children': {'D': {'level': 2, 'children': {'F': {'level': 3, 'children': {'G': {'level': 4, 'children': {}}}}}}, 'E': {'level': 2, 'children': {'H': {'level': 3, 'children': {}}, 'I': {'level': 3, 'children': {}}}}}}, 'C': {'level': 1, 'children': {'J': {'level': 2, 'children': {}}}}}}}

обмеження:

• level >= 0
• Будь-який levelне може бути більшим, ніж +1максимальний рівень, який з’являвся раніше.

пояснення:

• parents це словник для запам'ятовування останнього елемента для кожного рівня.
• root є відправною точкою (фіктивний елемент).
• логіка:
  • Почніть з -1рівня, який вказує на root.
  • Створіть елемент і зареєструйте його у батьківських children.
  • Оновіть той самий елемент у parentsсловнику.
  • Повторіть.
  • Витяг root['children'].

Інше рішення з використанням рекурсії (ті ж самі обмеження, що і у відповіді Босенга Чоя):

data = [
    {"tag": "A", "level": 0},
    {"tag": "B", "level": 1},
    {"tag": "D", "level": 2},
    {"tag": "F", "level": 3},
    {"tag": "G", "level": 4},
    {"tag": "E", "level": 2},
    {"tag": "H", "level": 3},
    {"tag": "I", "level": 3},
    {"tag": "C", "level": 1},
    {"tag": "J", "level": 2},
]

def make_node(dic):
    node = dic.copy()
    node["children"] = {}
    tag = node.pop("tag")
    return tag, node

def add_child(parent, child, tag):
    assert child["level"] > parent["level"]
    if child["level"] == parent["level"] + 1:
        parent["children"][tag] = child
        return True
    for node in parent["children"].values():
        if add_child(node, child, tag):
            return True
    return False

def parse(lst):
    assert lst[0]["level"] == 0
    root_tag, root = make_node(lst[0])
    for item in lst[1:]:
        tag, node = make_node(item)
        add_child(root, node, tag)


print(parse(data))

Ви можете використовувати рекурсію:

from itertools import groupby as gb
data = [{'tag': 'A', 'level': 0}, {'tag': 'B', 'level': 1}, {'tag': 'D', 'level': 2}, {'tag': 'F', 'level': 3}, {'tag': 'G', 'level': 4}, {'tag': 'E', 'level': 2}, {'tag': 'H', 'level': 3}, {'tag': 'I', 'level': 3}, {'tag': 'C', 'level': 1}, {'tag': 'J', 'level': 2}]
def to_tree(d, s = 0):
  v = [list(b) for _, b in gb(d, key=lambda x:x['level'] == s)]
  if len(v) == 1:
     return {i['tag']:{'level':s, 'children':{}} for i in v[0]}
  return {v[i][0]['tag']:{'level':s, 'children':to_tree(v[i+1], s+1)} for i in range(0, len(v), 2)}

import json
print(json.dumps(to_tree(data), indent=4))

Вихід:

{
  "A": {
    "level": 0,
    "children": {
        "B": {
            "level": 1,
            "children": {
                "D": {
                    "level": 2,
                    "children": {
                        "F": {
                            "level": 3,
                            "children": {
                                "G": {
                                    "level": 4,
                                    "children": {}
                                }
                            }
                        }
                    }
                },
                "E": {
                    "level": 2,
                    "children": {
                        "H": {
                            "level": 3,
                            "children": {}
                        },
                        "I": {
                            "level": 3,
                            "children": {}
                        }
                    }
                }
            }
        },
        "C": {
            "level": 1,
            "children": {
                "J": {
                    "level": 2,
                    "children": {}
                }
            }
         }
      }
   }
}