python - 在嵌套字典中移动字典

Question

我有以下嵌套字典和列表列表。我想创建一个名为 'food' 的新父 (L0) 类别，并移动 fruit 和 vegs 中的所有值 字典下一级(这样 'L0': 'fruit' 变成 'L1': 'fruit', 'L1': 'banana ' 变成 'L2': 'banana' 等)。

D = [{
        "L0": "fruit",
        "L1_list": [
            {
                "L1": "banana"
            },
            {
                "L1": "apple", 
                "L2_list": [
                    {
                        "L2": "Green apple"
                    }, 
                    {
                        "L2": "Red apple"
                    }
                ]
            }, 
            {
                "L1": "kiwi"
            }
        ]
    },
    {
        "L0": "vegs", 
        "L1_list": [
            {
                "L1": "potato"
            }, 
            {
                "L1": "carrot"
            }
        ]
    }]

异常(exception)的输出应该是这样的:

Expected_output = [
    {
        "L0": "food",
        "L1_list": [
            {
                "L1": "fruit",
                "L2_list": [
                    {
                        "L2": "banana"
                    },
                    {
                        "L2": "apple",
                        "L3_list": [
                            {
                                "L3": "Green apple"
                            },
                            {
                                "L3": "Redapple"
                            }
                        ]
                    },
                    {
                        "L2": "kiwi"
                    }
                ]
            },
            {
                "L1": "vegs",
                "L2_list": [
                    {
                        "L2": "potato"
                    },
                    {
                        "L2": "carrot"
                    }
                ]
            }
        ]
    }
]

现在，由于我的字典的大小和深度各不相同，因此我需要一个程序化的解决方案。所以我想我会创建一个递归函数来迭代它到达树的末尾。当函数到达特定分支的末尾时，它会将键加 1 (L0 --> L1, L1_list --> L2_列表)。虽然这个过程确实将所有东西都向下移动了一层，但我不知道如何重建初始结构。特别是，我无法将 children 带回到他们各自的名单中。

Final_list = []
def digger(list_to_dig):
    import re
    for x in list_to_dig:
        for k,v in x.items():
            if isinstance(v, list):
                print("keep digging")
                digger(v)
            elif isinstance(x, dict):
                new_D = {}
                new_k = "L" + str(int(re.sub("L", "", k)) + 1)
                new_D[new_k] = v
                temp = re.sub("L", "", k)
                new_child_list = "L" + str(int(re.sub("_list", "", temp)) + 2) + "_list"
                new_D[new_child_list] = ""
                Final_list.append(new_D)
            else:
                print("no dictionary avail")
                pass
    print("_________")
    print(Final_list)
    print("_________")

    test = digger(D)

关于我应该如何解决这个问题有什么建议吗？非常感谢

按照@running.t 的建议，我尝试使用dict.pop 方法。然而，因为它发生在一次迭代中，它弹出旧 key ，创建并插入新 key ，但在下一次迭代中将获取刚刚创建的新 key ，弹出它，然后创建并插入一个新的新 key ，等等打开(尽管它也不会进入无限循环)。

这里有一个简单的例子来说明这个问题:

第 1 步创建新的顶级字典

new_top_level = {"L0": "Food"}
new_dict = {}
for k, v in new_top_level.items():
    lst_k = "L" + str(int(re.sub("L", "", ka)) + 1) + "_list"
    new_dict[k] = v
    new_dict[lst_k] = []

第2步在新列表中添加旧树

old_d = {'L0': 'Fruit', 'L1_list': [{'L1': 'Green apple'}, {'L1': 'Red apple'}]}
new_dict[lst_k].append(old_d)

Step 3 老树的所有keys加1

def digger(list_to_update):
    import re
    pattern1 = r"L.$"
    pattern2 = r"L._list"
    for x in list_to_update:
        for k1, v1 in x.items():
            if re.match(pattern1, k1):
                new_k1 = "L" + str(int(re.sub("L", "", k1)) + 1)
                x[new_k1] = x.pop(k1)
            elif re.match(pattern2, k1):
                temp = re.sub("L", "", k1)
                new_k1 = "L" + str(int(re.sub("_list", "", temp)) + 1) + "_list"
                x[new_k1] = x.pop(k1)
                digger(v1)

test = digger(new_dict[lst_k])

Answer 1

您不应该创建新列表并将所有内容放入其中。实际上这就是你在做的事情:

Final_list.append(new_D)

您应该做的是递归地迭代您拥有的所有字典和列表(与您当前执行的方式相同)，如果对象是字典，则相应地重命名该字典中的所有键。

Here you can find how to rename keys i dict .我认为 best answer there建议使用以下内容:

new_k = "L"+str(int(re.sub("L","",k))+1) 
x[new_key] = x.pop(k)

最后，在挖掘完所有 D 之后，您应该将修改后的 D 放入新的 Expected_output 列表中。