由 pandas DataFrame 的嵌套列表字典表示的任意深度树

Question

我正在尝试从包含子节点列表的嵌套字典中获取 pandas 数据框。节点的深度和数量完全不均匀。这里我放了一个我试图转换为 Pandas Dataframe 的字典的例子。我的字典更长，有超过 600 个节点，但格式与本例相同。

example_dict = {"id": 0, "children":[{"id":4},
                                 {"id": 1, "children":[{"id":2}, {"id":6}, {"id":7}, {"id":8}]},
                                 {"id": 3, "children":[{"id":5}]},
                                {"id": 9, "children":[{"id":10},
                                                      {"id": 11, "children":[{"id":12},
                                                                             {"id":13},
                                                                             {"id":14},
                                                                             {"id":15}]}]},
                                {"id": 16, "children":[{"id":17},
                                                       {"id":18},
                                                       {"id":19},
                                                       {"id":20},
                                                       {"id": 21, "children":[{"id":22},
                                                                              {"id": 23, "children":[{"id":24}]}]}]}]}

我想将其转换为如下所示的数据框：

|    |   Level 1 |   Level 2 | Level 3   | Level 4   | Level 5   |
|---:|----------:|----------:|:----------|:----------|:----------|
|  0 |         0 |         4 | <NA>      | <NA>      | <NA>      |
|  1 |         0 |         1 | 2         | <NA>      | <NA>      |
|  2 |         0 |         1 | 6         | <NA>      | <NA>      |
|  3 |         0 |         1 | 7         | <NA>      | <NA>      |
|  4 |         0 |         1 | 8         | <NA>      | <NA>      |
|  5 |         0 |         3 | 5         | <NA>      | <NA>      |
|  6 |         0 |         9 | 10        | <NA>      | <NA>      |
|  7 |         0 |         9 | 11        | 12        | <NA>      |
|  8 |         0 |         9 | 11        | 13        | <NA>      |
|  9 |         0 |         9 | 11        | 14        | <NA>      |
| 10 |         0 |         9 | 11        | 15        | <NA>      |
| 11 |         0 |        16 | 17        | <NA>      | <NA>      |
| 12 |         0 |        16 | 18        | <NA>      | <NA>      |
| 13 |         0 |        16 | 19        | <NA>      | <NA>      |
| 14 |         0 |        16 | 20        | <NA>      | <NA>      |
| 15 |         0 |        16 | 21        | 22        | <NA>      |
| 16 |         0 |        16 | 21        | 23        | 24        |

目标表

列数取决于字典，因此解决方案需要根据需要添加尽可能多的列。

我尝试了这里的解决方案，但找不到解决方案。

任何深度嵌套字典到 pandas 数据框

Answer 1

这是一个递归函数，可以将字典转换为子列表列表。请注意，子列表的长度不同，因此在从列表中创建数据帧之前，您可能需要进行一些后处理。

def dict_to_lists(my_dict):
    my_list = []
    children = my_dict.get('children')
    if children is None:
        return [[my_dict['id']]]
    for child_dict in children:
        my_list.extend([[my_dict['id']] + child_list for child_list in dic_to_lists(child_dict)])
    return my_list

在您的示例字典中，它返回：

[
    [0, 4], 
    [0, 1, 2], 
    [0, 1, 6], 
    [0, 1, 7], 
    [0, 1, 8], 
    [0, 3, 5], 
    [0, 9, 10], 
    [0, 9, 11, 12], 
    [0, 9, 11, 13], 
    [0, 9, 11, 14], 
    [0, 9, 11, 15], 
    [0, 16, 17], 
    [0, 16, 18], 
    [0, 16, 19], 
    [0, 16, 20], 
    [0, 16, 21, 22], 
    [0, 16, 21, 23, 24]
]