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

这是我关于Stackflow的第一个问题,所以如果我没有很好地格式化,我会事先道歉.我的问题如下:
我有以下嵌套字典/列表列表,我想要做的是创建一个名为“food”的新父类(L0)类别,并将水果和蔬菜词典中的所有值一步调低(以便L0:水果成为L1:水果,L1:香蕉变成L2:香蕉)……

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"
            }
        ]
    }]

例外输出应如下所示:

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_list).虽然这个过程确实将所有内容都降低了一级,但我无法弄清楚如何重建初始结构.特别是,我不能把孩子们带回各自的名单.

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的建议,我试图使用pop函数.但是,因为它发生在迭代中,它会弹出旧键,创建并插入新键,但是在下一次迭代中,将获取刚刚创建的新键,弹出它,并创建并插入新的新键,等等on(虽然它也没有进入无限循环).
这是一个简化的例子来说明问题:

第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)

步骤3将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]) 
最佳答案
您不应该创建新列表并将所有内容放入其中.实际上这就是你正在做的事情:

Final_list.append(new_D)

您应该做的是递归迭代您拥有的所有词典和列表(与当前执行的相同),如果object是dict,则相应地重命名该dict中的所有键.

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列表中.

转载注明原文:python – 在嵌套字典中移动字典 - 代码日志