主页 / 问题 / 1606731
Accepted
Иван Максимович
Asked:2025-02-12 04:13:34 +0000 UTC2025-02-12 04:13:34 +0000 UTC

根据条件将字典键收集到单独的列表中

  • 772

有一本字典。这些键与示例中的不同。字典中的含义要么是字典，要么是文本。

有必要在单独的列表中收集从根到具有文本值的键的键分支。带有键的列表也需要收集到最终列表中。

我看到了一个使用递归的实现。我理解，使用班级检查功能是必要的。但我不明白具体怎么做。

以下是我想做的事情：

dict1 = {'1':{'2':{'3':'text'},'4':{'5':{'6':'text'},'7':'text'}},'8':{'9':{'10':'text'}}}
    
general_list = []
def search_keys(dict1, list_key=[]):
    for key, value in dict1.items():
        list_key.append(key)
        if isinstance(value, dict):
            search_keys(value, list_key)
        elif isinstance(value, str):
            general_list.append(list_key.copy())
            list_key.clear()
    return general_list
    
print(search_keys(dict1))

第一遍收集钥匙。从第二个开始，一切都出错了：

[['1','2','3'],['4','5','6'],['7'],['8','9','10']]

您应该获得以下内容：

[['1','2','3'],['1','4','5','6'],['1','4','7'],['8','9','10']]
python

1 个回答

  1. Best Answer

    你清理得太快了list_key，一下子就把所有东西都洗干净了。在这个函数调用中你只需要删除你添加到其中的数据：list_key.append(key)/ list_key.pop()：

    general_list = []
def search_keys(dict1, list_key=[]):
    for key, value in dict1.items():
        list_key.append(key)
        if isinstance(value, dict):
            search_keys(value, list_key)
        elif isinstance(value, str):
            general_list.append(list_key.copy())
            # list_key.clear()                       # убрано
        list_key.pop()                               # добавлено
    return general_list
    
print(search_keys(dict1))

    但一切都可以做得更简单。我们递归地浏览字典，形成列表。性能不是最好的，但是除非您的字典有数千个嵌套的深度，否则您不会知道有些事情很慢：

    def search(d):
    if isinstance(d, dict):
        for k, v in d.items():
            for lst in search(v):
                yield [k] + lst
    else:
        yield []


dict1 = {
    '1': {'2': {'3': 'text'},'4': {'5': {'6': 'text'},'7': 'text'}},
    '8': {'9': {'10': 'text'}}
}
for lst in search(dict1):
    print(lst)

    $ python search.py
['1', '2', '3']
['1', '4', '5', '6']
['1', '4', '7']
['8', '9', '10']

    如果您担心非常深的词典的性能，那么有一个更复杂的选项可以获得最佳性能。唯一的区别在于键列表的构建方式：以前它们是通过顺序连接（字典深度的每个平方）构建的，现在它们是在向下递归下降的过程中累积的（每行）。这个选项和你的很接近，相同的构建块以不同的方式连接：

    def search(d):

    def search(d, path):
        if isinstance(d, dict):
            for k, v in d.items():
                path.append(k)
                yield from search(v, path)
                path.pop()
        else:
            yield path[:]

    return search(d, [])

    到目前为止，所有的解决方案都是递归的，也就是说，它们不会处理超过一千个字典嵌套。迭代解决方案将消除这一限制。stack存储嵌套字典上的迭代器。答案是path：

    def search(d):
    stack = [iter(d.items())]
    path = [None]
    while stack:
        for k, v in stack[-1]:
            path[-1] = k
            if isinstance(v, dict):
                stack.append(iter(v.items()))
                path.append(None)
            else:
                yield path[:]
            break
        else:
            stack.pop()
            path.pop()
    • 2

相关问题