Question

我有以下由嵌套字典构成的树状结构。每个字典都有一个元组作为键，并包含一个字典列表。该列表可以为空。

 {(0, 26): [{(2, 9): [{(4, 7): []},
                {(6, 9): []},
                 {(2, 5): []},
                 {(5, 8): []},
                 {(3, 6): []},
                 {(2, 7): [{(4, 7): []}, {(2, 5): []}, {(3, 6): []}]},
                 {(3, 8): [{(4, 7): []}, {(5, 8): []}, {(3, 6): []}]}]},
            {(14, 27): [{(14, 17): []},
                  {(17, 20): []},
                  {(18, 21): []},
                  {(20, 23): []},
                  {(22, 25): []},
                   {(17, 21): [{(17, 20): []}, {(18, 21): []}]}]},
            {(8, 16): [{(12, 16): []},
                  {(8, 11): []},
                  {(10, 16): [{(12, 16): []}]},
                  {(9, 12): []}]},
            {(7, 14): [{(7, 12): [{(7, 10): []},
                             {(8, 11): []},
                             {(9, 12): []}]},
                  {(7, 10): []},
                  {(8, 11): []},
                  {(9, 12): []}]},
            {(1, 4): []}]}

我正在尝试删除可能包含在其他词典中的词典。如果“深度d”处的字典具有带有字典的列表，该字典具有在“深度d-1”处找到的密钥，则我希望例程在“深度d-1”处删除字典。例如，带密钥（2,9）的字典包含带密钥（4,7）的字典。这个字典实际上包含在同一个字典中的两个其他字典中，其中包含键（2,7）和（3,8）。我想编写一个例程来获得以下结果...这里我只是用键（2,9）显示字典的结果：

{(2, 9): [{(6, 9): []},
    {(2, 7): [{(4, 7): []}, {(2, 5): []}, {(3, 6): []}]},
    {(3, 8): [{(4, 7): []}, {(5, 8): []}, {(3, 6): []}]}]},

我在想我应该能够使用递归来做到这一点，但我没有成功。可以通过递归来解决这个问题吗？如果没有，那么解决它的更好方法是什么？

Answer 1

# Build a dict key:list of index
for i, d in enumerate(list_of_dict):
    key = d.keys()[0]
    if not key in dict_idx:
        dict_idx[key] = []
    dict_idx[key]. append(i)

# Delete from all multiple key the first 
for key in dict_idx:
    if len(dict_idx[key]) > 1:
        del list_of_dict[dict_idx[key][0]]

使用递归删除

1 个答案: