Darius's questions

编写一个程序将数据转换为所需的形式。但如果嵌套增加，程序就需要补充一个关卡。递归本身就存在，但我不知道如何优化程序。

有一个字典列表（见下文）

data = [
        {"id": "000", "name": "name_1", "status": "pass", "parent_id": None},
        {"id": "000_0", "name": "name_2", "status": "pass", "parent_id": None},
        {"id": "111", "name": "child_1", "status": "pass", "parent_id": "000"},
        {"id": "111_1", "name": "child_1_1", "status": "pass", "parent_id": "111"},
        {"id": "111_2", "name": "child_1_2", "status": "pass", "parent_id": "111"}
    ]

由于需要转换为以下形式

[
    {
        'key': '0',
        'data': {
            'name': 'name_1',
            'id': '000',
            "status": "pass"
        },
        'children': [
            {
                "key": '0-0',
                "data": {
                    'name': 'child_1',
                    'id': '111',
                    "status": "pass"
                },
                'children': [
                        {
                            'key': '0-0-0',
                            'data': {
                                'name': 'child_1_1',
                                'id': '111_1',
                                "status": "pass"
                            },
                            'children': [ ]
                        },
                        {
                            'key': '0-0-1',
                            'data': {
                                'name': 'child_1_2',
                                'id': '111_2',
                                "status": "pass"
                            },
                            'children': [ ]
                        }
                    ]
                }
            ]
        },
    {
        'key': '1',
        'data': {
            'name': 'name_2',
            'id': '000_0',
            "status": "pass"
        },
        'children': [ ]
   }
]

我编写了以下代码进行转换。

def _tree(tests):
    arr_tree = []

    ind_key = 0
    for i in tests:
        if i[2] == None:
            ind_key += 1
            list_tree = {
                'key':  f"{ind_key}",
                'data': {
                    'id': i[0],
                    'name': i[1],
                    'parent_id': i[2]
                },
                "children": []
            }
            arr_tree.append(list_tree)

    ind_key2 = 0
    for  i in tests:
        for level_2 in arr_tree:
            if i[2] == level_2['data']['id']:
                ind_key2 += 1
                list_tree = {
                    'key':  f"{level_2['key']}-{ind_key2}",
                    'data': {
                        'id': i[0],
                        'name': i[1],
                        'parent_id': i[2]
                    },
                    "children": []
                }
                level_2["children"].append(list_tree)

    ind_key3 = 0
    for  i in tests:
        for level_2 in arr_tree:
            for level_3 in level_2["children"]:
                if i[2] == level_3['data']['id']:
                    ind_key3 += 1
                    list_tree = {
                        'key':  f"{level_3['key']}-{ind_key3}",
                        'data': {
                            'id': i[0],
                            'name': i[1],
                            'parent_id': i[2]
                        },
                        "children": []
                    }
                    level_3["children"].append(list_tree)

    return arr_tree

有一个对象数组

status_data = [
    {
        "id": "id_1",
        "like": [
            {
                "status": "xx",
                "sum": 70
            }
        ],
    },
    {
        "id": "id_2",
        "like": [
            {
                "status": "xx",
                "sum": 8
            },
            {
                "status": "zz",
                "sum": 4
            }
        ]
    }
]

第二个对象数组

status_static = [
            {
                "status": "xx",
                "sum": 0
            },
            {
                "status": "zz",
                "sum": 0
            },
            {
                "status": "yy",
                "sum": 0
            }
]

所需结果

result = [
   {
        "id": "id_1",
        "like": [
            {
                "status": "xx",
                "sum": 70
            },
            {
                "status": "zz",
                "sum": 0
            },
            {
                "status": "yy",
                "sum": 0
            }
        ],
    },
    {
        "id": "id_2",
        "like": [
            {
                "status": "xx",
                "sum": 0
            },
            {
                "status": "yy",
                "sum": 8
            },
            {
                "status": "zz",
                "sum": 4
            }
        ]
    }
]

需要将对象添加到类似数组而不添加重复项（python）

将 status_static 添加到 status_data

for index, i in enumerate(status_data):  
  for m in status_static: 
    status_data[index]['like'].append(m)

我删除了重复项，但填充的项被覆盖（其中总和不等于 0）

for index, m in enumerate(status_data):  
   status_data[index]['like'] = list({v['status']: v for v in m['like']}.values())

结果不正确

result = [
   {
        "id": "id_1",
        "like": [
            {
                "status": "xx",
                "sum": 0
            },
            {
                "status": "zz",
                "sum": 0
            },
            {
                "status": "yy",
                "sum": 0
            }
        ],
    },
    {
        "id": "id_2",
        "like": [
            {
                "status": "xx",
                "sum": 0
            },
            {
                "status": "yy",
                "sum": 0
            },
            {
                "status": "zz",
                "sum": 0
            }
        ]
    }
]