blocks|key|2483289|text|正如Niklas所说，你需要递归，即你想定义一个函数来打印你的dict，如果值是dict，你想使用这个新dict调用你的print函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2483290|类似于：|2483291|def+myprint(d):
++++for+k,+v+in+d.items():
++++++++if+isinstance(v,+dict):
++++++++++++myprint(v)
++++++++else:
++++++++++++print("{0}+:+{1}".format(k,+v))|code-block|syntax|javascript|2483292|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

As said by Niklas, you need recursion, i.e. you want to define a function to print your dict, and if the value is a dict, you want to call your print function using this new dict.

Something like :

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

blocks|key|2483330|text|因为dict是可迭代的，所以只需做几处小改动，就可以将经典的nested+container+iterable+formula应用于此问题。这是一个Python+2版本(参见下面的3)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2483331|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|code-block|syntax|javascript|2483332|测试：|2483333|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)]|2483334|在Python2中，可以创建一个符合Mapping条件但不包含iteritems的自定义Mapping，在这种情况下，这将失败。文档并没有指出Mapping需要iteritems；另一方面，source为Mapping类型提供了一个iteritems方法。因此，对于自定义Mappings，仅在大小写情况下显式继承collections.Mapping。|2483335|在Python3中，有许多需要改进的地方。在Python3.3中，抽象基类存在于collections.abc中。它们保留在collections中也是为了向后兼容，但将我们的抽象基类放在一个名称空间中更好。因此，这将从collections导入abc。Python3.3还添加了yield+from，它就是为这些情况而设计的。这不是空洞的语法糖；它可能会导致faster+code以及与coroutines更合理的交互。|2483336|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|2483337|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/2158532/577088|1|http://hg.python.org/cpython/file/2.7/Lib/_abcoll.py#l334|2|https://www.python.org/dev/peps/pep-0380/#optimisations|3|https://www.python.org/dev/peps/pep-0380/#the-refactoring-principle^0|2|4|U|X|0|0|0|0|0|I|7|V|9|18|7|1Z|7|28|9|2U|7|38|9|3S|8|4D|J|2N|6|1|0|14|F|1Q|B|32|B|3F|3|3W|A|50|B|2|5E|A|3|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|F|3|G|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1F|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]]|D|@$9|20|A|21|1|22]]|E|$]]|$1|Q|3|R|5|6|7|23|8|@$9|24|A|25|B|C]|$9|26|A|27|B|C]|$9|28|A|29|B|C]|$9|2A|A|2B|B|C]|$9|2C|A|2D|B|C]]|D|@$9|2E|A|2F|1|2G]|$9|2H|A|2I|1|2J]]|E|$]]|$1|S|3|T|5|H|7|2K|8|@]|D|@]|E|$I|J]]|$1|U|3|-4|5|6|7|2L|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]|12|$5|X|Y|Z|E|$10|13]]|14|$5|X|Y|Z|E|$10|15]]|16|$5|X|Y|Z|E|$10|17]]]]

Since a <code>dict</code> is iterable, you can apply the classic <a href="https://stackoverflow.com/a/2158532/577088">nested container iterable formula</a> to this problem with only a couple of minor changes. Here's a Python 2 version (see below for 3):

<pre><code>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
</code></pre>

Test:

<pre><code>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)]
</code></pre>

In Python 2, It might be possible to create a custom <code>Mapping</code> that qualifies as a <code>Mapping</code> but doesn't contain <code>iteritems</code>, in which case this will fail. The docs don't indicate that <code>iteritems</code> is required for a <code>Mapping</code>; on the other hand, the <a href="http://hg.python.org/cpython/file/2.7/Lib/_abcoll.py#l334" rel="noreferrer">source</a> gives <code>Mapping</code> types an <code>iteritems</code> method. So for custom <code>Mappings</code>, inherit from <code>collections.Mapping</code> explicitly just in case.

In Python 3, there are a number of improvements to be made. As of Python 3.3, abstract base classes live in <code>collections.abc</code>. They remain in <code>collections</code> too for backwards compatibility, but it's nicer having our abstract base classes together in one namespace. So this imports <code>abc</code> from <code>collections</code>. Python 3.3 also adds <code>yield from</code>, which is designed for just these sorts of situations. This is not empty syntactic sugar; it may lead to <a href="https://www.python.org/dev/peps/pep-0380/#optimisations" rel="noreferrer">faster code</a> and more sensible interactions with <a href="https://www.python.org/dev/peps/pep-0380/#the-refactoring-principle" rel="noreferrer">coroutines</a>.

<pre><code>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
</code></pre>

blocks|key|1475172|text|作为替代方案的迭代解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475173|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|code-block|syntax|javascript|1475174|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Iterative solution as an alternative:

<pre><code>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
</code></pre>

blocks|key|2483395|text|另一种迭代解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2483396|def+myprint(d):
++++stack+=+d.items()
++++while+stack:
++++++++k,+v+=+stack.pop()
++++++++if+isinstance(v,+dict):
++++++++++++stack.extend(v.iteritems())
++++++++else:
++++++++++++print("%25s:+%25s"+%25+(k,+v))|code-block|syntax|javascript|2483397|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Alternative iterative solution:

<pre><code>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))
</code></pre>

blocks|key|844959|text|基于Scharron解决方案的处理列表的替代解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|844960|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)|code-block|syntax|javascript|844961|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A alternative solution to work with lists based on Scharron's solution

<pre><code>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)
</code></pre>

blocks|key|845006|text|我写的版本略有不同，它跟踪了到达那里的过程中的关键字|type|unstyled|depth|inlineStyleRanges|entityRanges|data|845007|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)))|code-block|syntax|javascript|845008|在你的数据上，它会打印出来|845009|data['xml']['config']['portstatus']['status']+=+u'good'
data['xml']['config']['target']+=+u'1'
data['xml']['port']+=+u'11'|845010|如果您需要它，也可以很容易地修改它来跟踪前缀作为键的元组，而不是字符串。|845011|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Slightly different version I wrote that keeps track of the keys along the way to get there

<pre><code>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)))
</code></pre>

On your data, it'll print

<pre><code>data['xml']['config']['portstatus']['status'] = u'good'
data['xml']['config']['target'] = u'1'
data['xml']['port'] = u'11'
</code></pre>

It's also easy to modify it to track the prefix as a tuple of keys rather than a string if you need it that way.

blocks|key|1475242|text|如果你使用堆栈编写自己的递归实现或迭代等效项，就会出现潜在问题。请参阅此示例：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1475243|++++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|code-block|syntax|javascript|1475244|在正常意义上，嵌套字典将是一个类似n元树的数据结构。但是的定义并不排除交叉边缘甚至是后边缘的可能性(因此不再是一棵树)。例如，这里的key2.2保存来自key1的字典，key2.3指向整个字典(后边缘/周期)。当存在后沿(循环)时，堆栈/递归将无限运行。|1475245|++++++++++++++++++++++++++root<-------back+edge
++++++++++++++++++++++++/++++++\+++++++++++%7C
+++++++++++++++++++++_key1+++__key2__++++++%7C
++++++++++++++++++++/+++++++/+++\++++\+++++%7C
+++++++++++++++%7C->key1.1+key2.1+key2.2+key2.3
+++++++++++++++%7C+++/+++++++%7C++++++%7C
+++++++++++++++%7C+value1++value2+++%7C
+++++++++++++++%7C++++++++++++++++++%7C+
++++++++++++++cross+edge----------%7C|1475246|如果您从Scharron打印此实现的字典|1475247|++++def+myprint(d):
++++++for+k,+v+in+d.items():
++++++++if+isinstance(v,+dict):
++++++++++myprint(v)
++++++++else:
++++++++++print+"{0}+:+{1}".format(k,+v)|1475248|您将看到以下错误：|1475249|++++RuntimeError:+maximum+recursion+depth+exceeded+while+calling+a+Python+object|1475250|senderle的实现也是如此。|1475251|类似地，您可以从Fred+Foo获得此实现的无限循环。|1475252|++++def+myprint(d):
++++++++stack+=+list(d.items())
++++++++while+stack:
++++++++++++k,+v+=+stack.pop()
++++++++++++if+isinstance(v,+dict):
++++++++++++++++stack.extend(v.items())
++++++++++++else:
++++++++++++++++print("%25s:+%25s"+%25+(k,+v))|1475253|然而，Python实际上会检测嵌套字典中的循环：|1475254|++++print+dic
++++{'key2':+{'key2.1':+'value2',+'key2.3':+{...},+
+++++++'key2.2':+{'key1.1':+'value1'}},+'key1':+{'key1.1':+'value1'}}|1475255|"{...}“是检测到循环的位置。|1475256|根据Moondra的要求，这是一种避免循环(DFS)的方法：|1475257|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("%25s:+%25s"+%25+(k,+v))+
++++++++visited.add(k)|1475258|entityMap^0|R|4|0|0|S|7|0|0|4|8|0|0|0|0|0|8|0|8|8|0|0|0|0|0|2|7|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1L|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1P|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1R|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1V|8|@$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|10|3|11|5|H|7|1Y|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|14|3|15|5|H|7|20|8|@]|D|@]|E|$I|J]]|$1|16|3|17|5|6|7|21|8|@]|D|@]|E|$]]|$1|18|3|19|5|6|7|22|8|@$9|23|A|24|B|C]]|D|@]|E|$]]|$1|1A|3|1B|5|H|7|25|8|@]|D|@]|E|$I|J]]|$1|1C|3|-4|5|6|7|26|8|@]|D|@]|E|$]]]|1D|$]]

There are potential problems if you write your own recursive implementation or the iterative equivalent with stack. See this example:
<pre><code> dic = {}
 dic[&quot;key1&quot;] = {}
 dic[&quot;key1&quot;][&quot;key1.1&quot;] = &quot;value1&quot;
 dic[&quot;key2&quot;] = {}
 dic[&quot;key2&quot;][&quot;key2.1&quot;] = &quot;value2&quot;
 dic[&quot;key2&quot;][&quot;key2.2&quot;] = dic[&quot;key1&quot;]
 dic[&quot;key2&quot;][&quot;key2.3&quot;] = dic
</code></pre>
In the normal sense, nested dictionary will be a n-nary tree like data structure. But the definition doesn't exclude the possibility of a cross edge or even a back edge (thus no longer a tree). For instance, here key2.2 holds to the dictionary from key1, key2.3 points to the entire dictionary(back edge/cycle). When there is a back edge(cycle), the stack/recursion will run infinitely.
<pre><code> root&lt;-------back edge
 / \ |
 _key1 __key2__ |
 / / \ \ |
 |-&gt;key1.1 key2.1 key2.2 key2.3
 | / | |
 | value1 value2 |
 | | 
 cross edge----------|
</code></pre>
If you print this dictionary with this implementation from Scharron
<pre><code> def myprint(d):
 for k, v in d.items():
 if isinstance(v, dict):
 myprint(v)
 else:
 print &quot;{0} : {1}&quot;.format(k, v)
</code></pre>
You would see this error:
<pre><code> RuntimeError: maximum recursion depth exceeded while calling a Python object
</code></pre>
The same goes with the implementation from senderle.
Similarly, you get an infinite loop with this implementation from Fred Foo:
<pre><code> def myprint(d):
 stack = list(d.items())
 while stack:
 k, v = stack.pop()
 if isinstance(v, dict):
 stack.extend(v.items())
 else:
 print(&quot;%s: %s&quot; % (k, v))
</code></pre>
However, Python actually detects cycles in nested dictionary:
<pre><code> print dic
 {'key2': {'key2.1': 'value2', 'key2.3': {...}, 
 'key2.2': {'key1.1': 'value1'}}, 'key1': {'key1.1': 'value1'}}
</code></pre>
&quot;{...}&quot; is where a cycle is detected.
As requested by Moondra this is a way to avoid cycles (DFS):
<pre><code>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(&quot;%s: %s&quot; % (k, v)) 
 visited.add(k)
</code></pre>

blocks|key|1475641|text|以下是Fred+Foo对Python+2的答案的修改版本。在原始响应中，只输出最深层次的嵌套。如果将键作为列表输出，则可以保留所有级别的键，尽管要引用它们需要引用列表列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475642|下面是函数：|1475643|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|code-block|syntax|javascript|1475644|要引用密钥，请执行以下操作：|1475645|for+keys,+vals+in+mynested:+
++++print(mynested[keys[0]][keys[1][0]][keys[1][1][0]])|1475646|对于一个三级字典。|1475647|在访问多个键之前，您需要知道层数，并且层数应该是恒定的(在迭代值时，可以添加一些脚本来检查嵌套层数，但我还没有考虑到这一点)。|1475648|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Here's a modified version of Fred Foo's answer for Python 2. In the original response, only the deepest level of nesting is output. If you output the keys as lists, you can keep the keys for all levels, although to reference them you need to reference a list of lists. 

Here's the function: 

<pre><code>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
</code></pre>

To reference the keys: 

<pre><code>for keys, vals in mynested: 
 print(mynested[keys[0]][keys[1][0]][keys[1][1][0]])
</code></pre>

for a three-level dictionary. 

You need to know the number of levels before to access multiple keys and the number of levels should be constant (it may be possible to add a small bit of script to check the number of nesting levels when iterating through values, but I haven't yet looked at this).

blocks|key|1475298|text|这是一种pythonic式的方法。此函数将允许您循环遍历所有级别的键值对。它不会将整个事件保存到内存中，而是在您循环时遍历字典|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475299|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)|code-block|syntax|javascript|1475300|打印|1475301|a+{1:+{1:+2,+3:+4},+2:+{5:+6}}
1+{1:+2,+3:+4}
1+2
3+4
2+{5:+6}
5+6|1475302|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is pythonic way to do it. This function will allow you to loop through key-value pair in all the levels. It does not save the whole thing to the memory but rather walks through the dict as you loop through it

<pre><code>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)
</code></pre>

Prints

<pre><code>a {1: {1: 2, 3: 4}, 2: {5: 6}}
1 {1: 2, 3: 4}
1 2
3 4
2 {5: 6}
5 6
</code></pre>

blocks|key|845184|text|我发现这种方法更灵活一些，在这里你只需要提供生成器函数，它可以发出键，值对，并且可以很容易地扩展到遍历列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|845185|def+traverse(value,+key=None):
++++if+isinstance(value,+dict):
++++++++for+k,+v+in+value.items():
++++++++++++yield+from+traverse(v,+k)
++++else:
++++++++yield+key,+value|code-block|syntax|javascript|845186|然后，您可以编写自己的myprint函数，然后打印这些键值对。|offset|length|style|CODE|845187|def+myprint(d):
++++for+k,+v+in+traverse(d):
++++++++print(f"{k}+:+{v}")|845188|一个测试：|845189|myprint({
++++'xml':+{
++++++++'config':+{
++++++++++++'portstatus':+{
++++++++++++++++'status':+'good',
++++++++++++},
++++++++++++'target':+'1',
++++++++},
++++++++'port':+'11',
++++},
})|845190|输出：|845191|status+:+good
target+:+1
port+:+11|845192|我在Python+3.6上对此进行了测试。|845193|entityMap^0|0|0|B|7|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

I find this approach a bit more flexible, here you just providing generator function that emits key, value pairs and can be easily extended to also iterate over lists.

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

Then you can write your own <code>myprint</code> function, then would print those key value pairs.

<pre><code>def myprint(d):
 for k, v in traverse(d):
 print(f"{k} : {v}")
</code></pre>

A test:

<pre><code>myprint({
 'xml': {
 'config': {
 'portstatus': {
 'status': 'good',
 },
 'target': '1',
 },
 'port': '11',
 },
})
</code></pre>

Output:

<pre><code>status : good
target : 1
port : 11
</code></pre>

I tested this on Python 3.6.

blocks|key|2483758|text|我使用以下代码打印嵌套字典的所有值，并考虑到其中的值可能是包含字典的列表。在将JSON文件解析为字典并需要快速检查其值是否为None时，这对我很有用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2483759|++++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)|code-block|syntax|javascript|2483760|输出：|2483761|++++10
++++2017-03-15T14:02:49.301000
++++bar
++++some_string|2483762|entityMap^0|1Q|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

I am using the following code to print all the values of a nested dictionary, taking into account where the value could be a list containing dictionaries. This was useful to me when parsing a JSON file into a dictionary and needing to quickly check whether any of its values are <code>None</code>.

<pre><code> 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)
</code></pre>

Output:

<pre><code> 10
 2017-03-15T14:02:49.301000
 bar
 some_string
</code></pre>

blocks|key|2483790|text|这些答案只适用于两个级别的子词典。有关更多信息，请尝试以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2483791|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)|code-block|syntax|javascript|2483792|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

These answers work for only 2 levels of sub-dictionaries. For more try this:

<pre><code>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)
</code></pre>

blocks|key|1475402|text|您的问题已经得到了很好的回答，但我建议使用isinstance(d,+collections.Mapping)而不是isinstance(d,+dict)。它适用于dict()、collections.OrderedDict()和collections.UserDict()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1475403|通常正确的版本是：|1475404|def+myprint(d):
++++for+k,+v+in+d.items():
++++++++if+isinstance(v,+collections.Mapping):
++++++++++++myprint(v)
++++++++else:
++++++++++++print("{0}+:+{1}".format(k,+v))|code-block|syntax|javascript|1475405|entityMap^0|L|Y|1M|J|2A|6|2H|P|37|M|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

Your question already has been answered well, but I recommend using <code>isinstance(d, collections.Mapping)</code> instead of <code>isinstance(d, dict)</code>. It works for <code>dict()</code>, <code>collections.OrderedDict()</code>, and <code>collections.UserDict()</code>.
The generally correct version is:
<pre><code>def myprint(d):
 for k, v in d.items():
 if isinstance(v, collections.Mapping):
 myprint(v)
 else:
 print(&quot;{0} : {1}&quot;.format(k, v))
</code></pre>

blocks|key|845342|text|嵌套字典使用isinstance()和yield函数进行循环。**isinstance是一个函数，它返回给定的输入，并且reference为true或false，如下所示，dict为true，因此它进行迭代。**Yield用于在不破坏函数局部变量状态的情况下从函数返回，当函数被调用时，执行从最后一条yield语句开始。任何包含yield关键字的函数都称为生成器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|845343|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)|code-block|syntax|javascript|845344|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Nested dictionaries looping using isinstance() and yield function.
**isinstance is afunction that returns the given input and reference is true or false as in below case dict is true so it go for iteration.
**Yield is used to return from a function without destroying the states of its local variable and when the function is called, the execution starts from the last yield statement. Any function that contains a yield keyword is termed a generator.
<pre><code>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)
</code></pre>

blocks|key|2567647|text|您可以使用字典理解递归打印：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2567648|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()}|code-block|syntax|javascript|2567649|对于您的测试用例，这是输出：|2567650|>>>+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|2567651|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can print recursively with a dictionary comprehension:
<pre><code>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()}
</code></pre>
For your test case this is the output:
<pre><code>&gt;&gt;&gt; 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
</code></pre>

<pre><code>for k, v in d.iteritems():
 if type(v) is dict:
 for t, c in v.iteritems():
 print "{0} : {1}".format(t, c)
</code></pre>

I'm trying to loop through a dictionary and print out all key value pairs where the value is not a nested dictionary. If the value is a dictionary I want to go into it and print out its key value pairs...etc. Any help?

EDIT

How about this? It still only prints one thing.

<pre><code>def printDict(d):
 for k, v in d.iteritems():
 if type(v) is dict:
 printDict(v)
 else:
 print "{0} : {1}".format(k, v)
</code></pre>

Full Test Case

Dictionary:

<pre><code>{u'xml': {u'config': {u'portstatus': {u'status': u'good'}, u'target': u'1'},
 u'port': u'11'}}
</code></pre>

Result:

<pre><code>xml : {u'config': {u'portstatus': {u'status': u'good'}, u'target': u'1'}, u'port': u'11'}
</code></pre>

Loop through all nested dictionary values?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

for k, v in d.iteritems():    if type(v) is dict:        for t, c in v.iteritems():            print "{0} : {1}".format(t, c)我尝试遍历字典并打印出值不是嵌套字典的所有键值对。如果值是一个字典，我...

问循环遍历所有嵌套的字典值？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问循环遍历所有嵌套的字典值？EN