Loop through all nested dictionary values?

小开

最佳答案

正如 Niklas 所说，你需要递归，也就是说，你需要定义一个函数来打印你的 dict，如果值是一个 dict，你需要使用这个新的 dict 来调用你的 print 函数。

比如:

def myprint(d):
for k, v in d.items():
if isinstance(v, dict):
myprint(v)
else:
print("{0} : {1}".format(k, v))

小开

因为 dict是可迭代的，所以只需要做一些小的修改，就可以将经典的嵌套容器可迭代公式应用到这个问题上。下面是 Python 2的一个版本(见下面的3) :

import collections
def nested_dict_iter(nested):
for key, value in nested.iteritems():
if isinstance(value, collections.Mapping):
for inner_key, inner_value in nested_dict_iter(value):
yield inner_key, inner_value
else:
yield key, value

测试:

list(nested_dict_iter({'a':{'b':{'c':1, 'd':2},
'e':{'f':3, 'g':4}},
'h':{'i':5, 'j':6}}))
# output: [('g', 4), ('f', 3), ('c', 1), ('d', 2), ('i', 5), ('j', 6)]

在 Python 2中，也许吧可以创建一个定制的 Mapping，该 Mapping符合 Mapping的条件，但不包含 iteritems，在这种情况下，这将失败。文档没有指出 Mapping需要 iteritems; 另一方面，Mapping0为 Mapping类型提供了一个 iteritems方法。因此，对于自定义 Mappings，从 collections.Mapping显式继承以防万一。

在 Python3中，有许多需要改进的地方。在 Python 3.3中，抽象基类存在于 collections.abc中。为了向后兼容，它们也保留在 collections中，但是将抽象基类放在一个名称空间中更好。所以它从 collections导入 abc。Python 3.3还增加了 yield from，它是专门为这类情况设计的。这不是空的句法糖，它可能导致更快的代码和更明显的与协同动作的相互作用。

from collections import abc
def nested_dict_iter(nested):
for key, value in nested.items():
if isinstance(value, abc.Mapping):
yield from nested_dict_iter(value)
else:
yield key, value

小开

作为替代的迭代解决方案:

def traverse_nested_dict(d):
iters = [d.iteritems()]


while iters:
it = iters.pop()
try:
k, v = it.next()
except StopIteration:
continue


iters.append(it)


if isinstance(v, dict):
iters.append(v.iteritems())
else:
yield k, v




d = {"a": 1, "b": 2, "c": {"d": 3, "e": {"f": 4}}}
for k, v in traverse_nested_dict(d):
print k, v

小开

替代迭代解决方案:

def myprint(d):
stack = d.items()
while stack:
k, v = stack.pop()
if isinstance(v, dict):
stack.extend(v.iteritems())
else:
print("%s: %s" % (k, v))

小开

使用基于 Scharron 解决方案的列表的替代解决方案

def myprint(d):
my_list = d.iteritems() if isinstance(d, dict) else enumerate(d)


for k, v in my_list:
if isinstance(v, dict) or isinstance(v, list):
myprint(v)
else:
print u"{0} : {1}".format(k, v)

小开

略有不同的版本，我写的，保持沿途的关键到达那里的轨道

def print_dict(v, prefix=''):
if isinstance(v, dict):
for k, v2 in v.items():
p2 = "{}['{}']".format(prefix, k)
print_dict(v2, p2)
elif isinstance(v, list):
for i, v2 in enumerate(v):
p2 = "{}[{}]".format(prefix, i)
print_dict(v2, p2)
else:
print('{} = {}'.format(prefix, repr(v)))

在你的数据上，它会打印出来

data['xml']['config']['portstatus']['status'] = u'good'
data['xml']['config']['target'] = u'1'
data['xml']['port'] = u'11'

如果需要的话，还可以很容易地修改它，将前缀作为一组键而不是一个字符串来跟踪。

小开

如果您编写自己的递归实现或与堆栈等价的迭代，那么就有 潜在的问题:

dic = {}
dic["key1"] = {}
dic["key1"]["key1.1"] = "value1"
dic["key2"]  = {}
dic["key2"]["key2.1"] = "value2"
dic["key2"]["key2.2"] = dic["key1"]
dic["key2"]["key2.3"] = dic

在正常情况下，嵌套字典将是一个类似于 n 进制树的数据结构。但定义 不排除的可能性是一个交叉边甚至一个后边(因此不再是一棵树)。例如，这里 Key2.2从 钥匙1持有字典，Key2.3指向整个字典(后缘/循环)。当存在后沿(循环)时，堆栈/递归将无限运行。

            root<-------back edge
/      \           |
_key1   __key2__      |
/       /   \    \     |
|->key1.1 key2.1 key2.2 key2.3
|   /       |      |
| value1  value2   |
|                  |
cross edge----------|

如果使用沙伦中的此实现打印此字典

def myprint(d):
for k, v in d.items():
if isinstance(v, dict):
myprint(v)
else:
print "{0} : {1}".format(k, v)

你会看到这个错误:

> RuntimeError: maximum recursion depth exceeded while calling a Python object

森德尔的实现也是如此。

类似地，使用 佛瑞德的这个实现可以得到一个无限循环:

def myprint(d):
stack = list(d.items())
while stack:
k, v = stack.pop()
if isinstance(v, dict):
stack.extend(v.items())
else:
print("%s: %s" % (k, v))

然而，Python 实际上在嵌套字典中检测循环:

print dic
{'key2': {'key2.1': 'value2', 'key2.3': {...},
'key2.2': {'key1.1': 'value1'}}, 'key1': {'key1.1': 'value1'}}

“{ ... }” 是检测到循环的地方。

根据 月光女神的要求，这是一种避免周期(DFS)的方法:

def myprint(d):
stack = list(d.items())
visited = set()
while stack:
k, v = stack.pop()
if isinstance(v, dict):
if k not in visited:
stack.extend(v.items())
else:
print("%s: %s" % (k, v))
visited.add(k)

小开

下面是 Fred Foo 针对 Python2的答案的修改版本。在最初的响应中，只输出最深层次的嵌套。如果将键作为列表输出，则可以保留所有级别的键，但要引用它们，则需要引用列表列表。

功能如下:

def NestIter(nested):
for key, value in nested.iteritems():
if isinstance(value, collections.Mapping):
for inner_key, inner_value in NestIter(value):
yield [key, inner_key], inner_value
else:
yield [key],value

参考钥匙:

for keys, vals in mynested:
print(mynested[keys[0]][keys[1][0]][keys[1][1][0]])

一本三级词典。

您需要知道在访问多个键之前的级别数，并且级别数应该是常数(可以添加一小段脚本来检查在遍历值时嵌套级别的数量，但是我还没有看到这一点)。

小开

这里有一个简单的方法。这个函数允许您循环遍历所有级别中的键-值对。它不会将整个事情保存到记忆中，而是在您循环阅读的过程中遍历字典

def recursive_items(dictionary):
for key, value in dictionary.items():
if type(value) is dict:
yield (key, value)
yield from recursive_items(value)
else:
yield (key, value)


a = {'a': {1: {1: 2, 3: 4}, 2: {5: 6}}}


for key, value in recursive_items(a):
print(key, value)

指纹

a {1: {1: 2, 3: 4}, 2: {5: 6}}
1 {1: 2, 3: 4}
1 2
3 4
2 {5: 6}
5 6

小开

我发现这种方法更加灵活，这里只提供发出键、值对的生成器函数，并且可以很容易地扩展到对列表进行迭代。

def traverse(value, key=None):
if isinstance(value, dict):
for k, v in value.items():
yield from traverse(v, k)
else:
yield key, value

然后可以编写自己的 myprint函数，然后打印这些键值对。

def myprint(d):
for k, v in traverse(d):
print(f"{k} : {v}")

一个测试:

myprint({
'xml': {
'config': {
'portstatus': {
'status': 'good',
},
'target': '1',
},
'port': '11',
},
})

产出:

status : good
target : 1
port : 11

我在 Python 3.6上测试过。

小开

我使用以下代码打印嵌套字典的所有值，同时考虑到这些值可能是包含字典的列表。在将 JSON 文件解析为字典并需要快速检查其值是否为 None时，这对我很有用。

    d = {
"user": 10,
"time": "2017-03-15T14:02:49.301000",
"metadata": [
{"foo": "bar"},
"some_string"
]
}




def print_nested(d):
if isinstance(d, dict):
for k, v in d.items():
print_nested(v)
elif hasattr(d, '__iter__') and not isinstance(d, str):
for item in d:
print_nested(item)
elif isinstance(d, str):
print(d)


else:
print(d)


print_nested(d)

产出:

    10
2017-03-15T14:02:49.301000
bar
some_string

小开

这些答案只适用于两个级别的子字典:

nested_dict = {'dictA': {'key_1': 'value_1', 'key_1A': 'value_1A','key_1Asub1': {'Asub1': 'Asub1_val', 'sub_subA1': {'sub_subA1_key':'sub_subA1_val'}}},
'dictB': {'key_2': 'value_2'},
1: {'key_3': 'value_3', 'key_3A': 'value_3A'}}


def print_dict(dictionary):
dictionary_array = [dictionary]
for sub_dictionary in dictionary_array:
if type(sub_dictionary) is dict:
for key, value in sub_dictionary.items():
print("key=", key)
print("value", value)
if type(value) is dict:
dictionary_array.append(value)






print_dict(nested_dict)

小开

你的问题已经得到了很好的回答，但是我建议使用 isinstance(d, collections.Mapping)而不是 isinstance(d, dict)。它适用于 dict()、 collections.OrderedDict()和 collections.UserDict()。

一般来说，正确的说法是:

def myprint(d):
for k, v in d.items():
if isinstance(v, collections.Mapping):
myprint(v)
else:
print("{0} : {1}".format(k, v))

小开

使用 isinstance ()和屈服函数的嵌套字典循环。 * * isinstance 是一个函数，它返回给定的输入，并且引用是 true 或 false，如下例所示，dict 是 true，因此它进行迭代。产量用于从函数返回而不破坏其局部变量的状态，当函数被调用时，执行从最后一个产量语句开始。任何包含屈服关键字的函数都称为生成器。

students= {'emp1': {'name': 'Bob', 'job': 'Mgr'},
'emp2': {'name': 'Kim', 'job': 'Dev','emp3': {'namee': 'Saam', 'j0ob': 'Deev'}},
'emp4': {'name': 'Sam', 'job': 'Dev'}}
def nested_dict_pairs_iterator(dict_obj):
for key, value in dict_obj.items():
# Check if value is of dict type
if isinstance(value, dict):
# If value is dict then iterate over all its values
for pair in  nested_dict_pairs_iterator(value):
yield (key, *pair)
else:
# If value is not dict type then yield the value
yield (key, value)
for pair in nested_dict_pairs_iterator(students):
print(pair)

小开

你可以通过字典理解递归打印:

def print_key_pairs(d):
{k: print_key_pairs(v) if isinstance(v, dict) else print(f'{k}: {v}') for k, v in d.items()}

对于您的测试用例，下面是输出:

>>> print_key_pairs({u'xml': {u'config': {u'portstatus': {u'status': u'good'}, u'target': u'1'}, u'port': u'11'}})
status: good
target: 1
port: 11

小开

对于现成的解决方案，请安装指控

pip install ndicts

在脚本中导入一个 NestedDect

from ndicts.ndicts import NestedDict

初始化

dictionary = {
u'xml': {
u'config': {
u'portstatus': {u'status': u'good'},
u'target': u'1'
},
u'port': u'11'
}
}


nd = NestedDict(dictionary)

重复

for key, value in nd.items():
print(key, value)

小开

虽然@Charron 的原始解决方案漂亮而简单，但它不能很好地处理这个列表:

def myprint(d):
for k, v in d.items():
if isinstance(v, dict):
myprint(v)
else:
print("{0} : {1}".format(k, v))

因此，这段代码可以像下面这样稍微修改一下，以处理元素中的列表:

def myprint(d):
for k, v in d.items():
if isinstance(v, dict):
myprint(v)
elif isinstance(v, list):
for i in v:
myprint(i)
else:
print("{0} : {1}".format(k, v))

小开

返回每个键和值的元组，键包含完整路径

from typing import Mapping, Tuple, Iterator


def traverse_dict(nested: Mapping, parent_key="", keys_to_not_traverse_further=tuple()) -> Iterator[Tuple[str, str]]:
"""Each key is joined with it's parent using dot as a separator.


Once a `parent_key` matches `keys_to_not_traverse_further`
it will no longer find its child dicts.
"""
for key, value in nested.items():
if isinstance(value, abc.Mapping) and key not in keys_to_not_traverse_further:
yield from traverse_dict(value, f"{parent_key}.{key}", keys_to_not_traverse_further)
else:
yield f"{parent_key}.{key}", value

我们来测试一下

my_dict = {
"isbn": "123-456-222",
"author": {"lastname": "Doe", "firstname": "Jane"},
"editor": {"lastname": "Smith", "firstname": "Jane"},
"title": "The Ultimate Database Study Guide",
"category": ["Non-Fiction", "Technology"],
"first": {
"second": {"third": {"fourth": {"blah": "yadda"}}},
"fifth": {"sixth": "seventh"},
},
}
for k, v in traverse_dict(my_dict):
print(k, v)

报税表

.isbn 123-456-222
.author.lastname Doe
.author.firstname Jane
.editor.lastname Smith
.editor.firstname Jane
.title The Ultimate Database Study Guide
.category ['Non-Fiction', 'Technology']
.first.second.third.fourth.blah yadda
.first.fifth.sixth seventh

如果你不关心一些孩子的名字，例如在这种情况下，然后使用 keys_to_not_traverse_further

for k, v in traverse_dict(my_dict, parent_key="", keys_to_not_traverse_further=("author","editor")):
print(k, v)

报税表

.isbn 123-456-222
.author {'lastname': 'Doe', 'firstname': 'Jane'}
.editor {'lastname': 'Smith', 'firstname': 'Jane'}
.title The Ultimate Database Study Guide
.category ['Non-Fiction', 'Technology']
.first.second.third.fourth.blah yadda
.first.fifth.sixth seventh