blocks|key|374324|text|当您递归时，需要对_finditem的结果执行return|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|374325|def+_finditem(obj,+key):
++++if+key+in+obj:+return+obj[key]
++++for+k,+v+in+obj.items():
++++++++if+isinstance(v,dict):
++++++++++++return+_finditem(v,+key)++#added+return+statement|code-block|syntax|javascript|374326|要修复实际的算法，您需要认识到，如果没有找到任何内容，_finditem将返回None，因此您需要显式检查以防止提前返回：|374327|def+_finditem(obj,+key):
++++if+key+in+obj:+return+obj[key]
++++for+k,+v+in+obj.items():
++++++++if+isinstance(v,dict):
++++++++++++item+=+_finditem(v,+key)
++++++++++++if+item+is+not+None:
++++++++++++++++return+item|374328|当然，如果您的任何字典中都有None值，那么这将失败。在这种情况下，您可以为这个函数设置一个标记object()，并在没有找到任何东西的情况下返回它--然后可以检查sentinel，以了解您是否找到了什么东西。|374329|entityMap^0|9|9|N|6|0|0|R|9|13|4|0|0|E|4|1C|8|2A|8|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|R|$]]

when you recurse, you need to <code>return</code> the result of <code>_finditem</code>

<pre><code>def _finditem(obj, key):
 if key in obj: return obj[key]
 for k, v in obj.items():
 if isinstance(v,dict):
 return _finditem(v, key) #added return statement
</code></pre>

To fix the actual algorithm, you need to realize that <code>_finditem</code> returns <code>None</code> if it didn't find anything, so you need to check that explicitly to prevent an early return:

<pre><code>def _finditem(obj, key):
 if key in obj: return obj[key]
 for k, v in obj.items():
 if isinstance(v,dict):
 item = _finditem(v, key)
 if item is not None:
 return item
</code></pre>

Of course, that will fail if you have <code>None</code> values in any of your dictionaries. In that case, you could set up a sentinel <code>object()</code> for this function and return that in the case that you don't find anything -- Then you can check against the <code>sentinel</code> to know if you found something or not.

blocks|key|156485|text|这是一个搜索包含嵌套字典和列表的字典的函数。它会创建一个结果值列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|156486|def+get_recursively(search_dict,+field):
++++"""
++++Takes+a+dict+with+nested+lists+and+dicts,
++++and+searches+all+dicts+for+a+key+of+the+field
++++provided.
++++"""
++++fields_found+=+[]

++++for+key,+value+in+search_dict.iteritems():

++++++++if+key+==+field:
++++++++++++fields_found.append(value)

++++++++elif+isinstance(value,+dict):
++++++++++++results+=+get_recursively(value,+field)
++++++++++++for+result+in+results:
++++++++++++++++fields_found.append(result)

++++++++elif+isinstance(value,+list):
++++++++++++for+item+in+value:
++++++++++++++++if+isinstance(item,+dict):
++++++++++++++++++++more_results+=+get_recursively(item,+field)
++++++++++++++++++++for+another_result+in+more_results:
++++++++++++++++++++++++fields_found.append(another_result)

++++return+fields_found|code-block|syntax|javascript|156487|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|$]]

Here's a function that searches a dictionary that contains both nested dictionaries and lists. It creates a list of the values of the results.

<pre><code>def get_recursively(search_dict, field):
 """
 Takes a dict with nested lists and dicts,
 and searches all dicts for a key of the field
 provided.
 """
 fields_found = []

 for key, value in search_dict.iteritems():

 if key == field:
 fields_found.append(value)

 elif isinstance(value, dict):
 results = get_recursively(value, field)
 for result in results:
 fields_found.append(result)

 elif isinstance(value, list):
 for item in value:
 if isinstance(item, dict):
 more_results = get_recursively(item, field)
 for another_result in more_results:
 fields_found.append(another_result)

 return fields_found
</code></pre>

blocks|key|156547|text|下面是一个使用“堆栈”和"stack+of+iterators"+pattern+(归功于Gareth+Rees)的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|156548|def+search(d,+key,+default=None):
++++"""Return+a+value+corresponding+to+the+specified+key+in+the+(possibly
++++nested)+dictionary+d.+If+there+is+no+item+with+that+key,+return
++++default.
++++"""
++++stack+=+[iter(d.items())]
++++while+stack:
++++++++for+k,+v+in+stack[-1]:
++++++++++++if+isinstance(v,+dict):
++++++++++++++++stack.append(iter(v.items()))
++++++++++++++++break
++++++++++++elif+k+==+key:
++++++++++++++++return+v
++++++++else:
++++++++++++stack.pop()
++++return+default|code-block|syntax|javascript|156549|print(search({"B":+{"A":+2}},+"A"))将打印2。|style|CODE|156550|entityMap|0|LINK|mutability|MUTABLE|url|http://garethrees.org/2016/09/28/pattern/^0|C|S|0|0|0|0|Z|12|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]|$A|12|B|13|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Here is a way to do this using a "stack" and the <a href="http://garethrees.org/2016/09/28/pattern/" rel="noreferrer">"stack of iterators" pattern</a> (credits to Gareth Rees):

<pre><code>def search(d, key, default=None):
 """Return a value corresponding to the specified key in the (possibly
 nested) dictionary d. If there is no item with that key, return
 default.
 """
 stack = [iter(d.items())]
 while stack:
 for k, v in stack[-1]:
 if isinstance(v, dict):
 stack.append(iter(v.items()))
 break
 elif k == key:
 return v
 else:
 stack.pop()
 return default
</code></pre>

The <code>print(search({"B": {"A": 2}}, "A"))</code> would print <code>2</code>.

blocks|key|374456|text|我不能对@mgilston提出的被接受的解决方案添加评论，因为缺乏声誉。如果要搜索的键在列表中，则解决方案不起作用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|374457|循环遍历列表的元素并调用递归函数应该会扩展查找嵌套列表中的元素的功能：|374458|def+_finditem(obj,+key):
++++if+key+in+obj:+return+obj[key]
++++for+k,+v+in+obj.items():
++++++++if+isinstance(v,dict):
++++++++++++item+=+_finditem(v,+key)
++++++++++++if+item+is+not+None:
++++++++++++++++return+item
++++++++elif+isinstance(v,list):
++++++++++++for+list_item+in+v:
++++++++++++++++item+=+_finditem(list_item,+key)
++++++++++++++++if+item+is+not+None:
++++++++++++++++++++return+item

print(_finditem({"C":+{"B":+[{"A":2}]}},+"A"))|code-block|syntax|javascript|374459|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|$]]

I couldn't add a comment to the accepted solution proposed by @mgilston because of lack of reputation. The solution doesn't work if the key being searched for is inside a list. 

Looping through the elements of the lists and calling the recursive function should extend the functionality to find elements inside nested lists:

<pre class="lang-python prettyprint-override"><code>def _finditem(obj, key):
 if key in obj: return obj[key]
 for k, v in obj.items():
 if isinstance(v,dict):
 item = _finditem(v, key)
 if item is not None:
 return item
 elif isinstance(v,list):
 for list_item in v:
 item = _finditem(list_item, key)
 if item is not None:
 return item

print(_finditem({"C": {"B": [{"A":2}]}}, "A"))

</code></pre>

blocks|key|374506|text|我必须创建一个通用版本，它在包含多个嵌套字典和列表的字典中查找唯一指定的键(指定通向所需值的路径的最小字典)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|374507|在下面的示例中，创建了一个目标字典来进行搜索，并使用通配符“？”创建了键。运行时，它返回值"D“|374508|def+lfind(query_list:List,+target_list:List,+targ_str:str+=+"???"):
++++for+tval+in+target_list:
++++++++#print("lfind:+tval+=+{},+query_list[0]+=+{}".format(tval,+query_list[0]))
++++++++if+isinstance(tval,+dict):
++++++++++++val+=+dfind(query_list[0],+tval,+targ_str)
++++++++++++if+val:
++++++++++++++++return+val
++++++++elif+tval+==+query_list[0]:
++++++++++++return+tval

def+dfind(query_dict:Dict,+target_dict:Dict,+targ_str:str+=+"???"):
++++for+key,+qval+in+query_dict.items():
++++++++tval+=+target_dict[key]
++++++++#print("dfind:+key+=+{},+qval+=+{},+tval+=+{}".format(key,+qval,+tval))
++++++++if+isinstance(qval,+dict):
++++++++++++val+=++dfind(qval,+tval,+targ_str)
++++++++++++if+val:
++++++++++++++++return+val
++++++++elif+isinstance(qval,+list):
++++++++++++return+lfind(qval,+tval,+targ_str)
++++++++else:
++++++++++++if+qval+==+targ_str:
++++++++++++++++return+tval
++++++++++++if+qval+!=+tval:
++++++++++++++++break

def+find(target_dict:Dict,+query_dict:Dict):
++++result+=+dfind(query_dict,+target_dict)
++++return+result



target_dict+=+{"A":[
++++{"key1":"A",+"key2":{"key3":+"B"}},
++++{"key1":"C",+"key2":{"key3":+"D"}}]
}
query_dict+=+{"A":[{"key1":"C",+"key2":{"key3":+"???"}}]}

result+=+find(target_dict,+query_dict)
print("result+=+{}".format(result))|code-block|syntax|javascript|374509|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|$]]

I had to create a general-case version that finds a uniquely-specified key (a minimal dictionary that specifies the path to the desired value) in a dictionary that contains multiple nested dictionaries and lists. 

For the example below, a target dictionary is created to search, and the key is created with the wildcard "???". When run, it returns the value "D"

<pre><code>def lfind(query_list:List, target_list:List, targ_str:str = "???"):
 for tval in target_list:
 #print("lfind: tval = {}, query_list[0] = {}".format(tval, query_list[0]))
 if isinstance(tval, dict):
 val = dfind(query_list[0], tval, targ_str)
 if val:
 return val
 elif tval == query_list[0]:
 return tval

def dfind(query_dict:Dict, target_dict:Dict, targ_str:str = "???"):
 for key, qval in query_dict.items():
 tval = target_dict[key]
 #print("dfind: key = {}, qval = {}, tval = {}".format(key, qval, tval))
 if isinstance(qval, dict):
 val = dfind(qval, tval, targ_str)
 if val:
 return val
 elif isinstance(qval, list):
 return lfind(qval, tval, targ_str)
 else:
 if qval == targ_str:
 return tval
 if qval != tval:
 break

def find(target_dict:Dict, query_dict:Dict):
 result = dfind(query_dict, target_dict)
 return result



target_dict = {"A":[
 {"key1":"A", "key2":{"key3": "B"}},
 {"key1":"C", "key2":{"key3": "D"}}]
}
query_dict = {"A":[{"key1":"C", "key2":{"key3": "???"}}]}

result = find(target_dict, query_dict)
print("result = {}".format(result))
</code></pre>

blocks|key|156645|text|只是想让它变得更简短：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|156646|def+get_recursively(search_dict,+field):
++++if+isinstance(search_dict,+dict):
++++++++if+field+in+search_dict:
++++++++++++return+search_dict[field]
++++++++for+key+in+search_dict:
++++++++++++item+=+get_recursively(search_dict[key],+field)
++++++++++++if+item+is+not+None:
++++++++++++++++return+item
++++elif+isinstance(search_dict,+list):
++++++++for+element+in+search_dict:
++++++++++++item+=+get_recursively(element,+field)
++++++++++++if+item+is+not+None:
++++++++++++++++return+item
++++return+None|code-block|syntax|javascript|156647|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|$]]

Just trying to make it shorter:

<pre class="lang-py prettyprint-override"><code>def get_recursively(search_dict, field):
 if isinstance(search_dict, dict):
 if field in search_dict:
 return search_dict[field]
 for key in search_dict:
 item = get_recursively(search_dict[key], field)
 if item is not None:
 return item
 elif isinstance(search_dict, list):
 for element in search_dict:
 item = get_recursively(element, field)
 if item is not None:
 return item
 return None
</code></pre>

blocks|key|156664|text|我想我得赌一把，这将允许对实现__getitem__方法的任何东西进行递归请求。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|156665|def+_get_recursive(obj,+args,+default=None):
++++"""Apply+successive+requests+to+an+obj+that+implements+__getitem__+and
++++return+result+if+something+is+found,+else+return+default"""
++++if+not+args:
++++++++return+obj
++++try:
++++++++key,+*args+=+args
++++++++_obj+=+object.__getitem__(obj,+key)
++++++++return+_get_recursive(_obj,+args,+default=default)
++++except+(KeyError,+IndexError,+AttributeError):
++++++++return+default|code-block|syntax|javascript|156666|entityMap^0|F|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Thought I'd throw my hat in the ring, this will allow for recursive requests on anything that implements a <code>__getitem__</code> method.
<pre class="lang-py prettyprint-override"><code>def _get_recursive(obj, args, default=None):
 &quot;&quot;&quot;Apply successive requests to an obj that implements __getitem__ and
 return result if something is found, else return default&quot;&quot;&quot;
 if not args:
 return obj
 try:
 key, *args = args
 _obj = object.__getitem__(obj, key)
 return _get_recursive(_obj, args, default=default)
 except (KeyError, IndexError, AttributeError):
 return default
</code></pre>

I'm trying to write a very simple function to recursively search through a possibly nested (in the most extreme cases ten levels deep) Python dictionary and return the first value it finds from the given key.

I cannot understand why my code doesn't work for nested dictionaries.

<pre><code>def _finditem(obj, key):
 if key in obj: return obj[key]
 for k, v in obj.items():
 if isinstance(v,dict):
 _finditem(v, key)

print _finditem({"B":{"A":2}},"A")
</code></pre>

It returns <code>None</code>.

It does work, however, for <code>_finditem({"B":1,"A":2},"A")</code>, returning <code>2</code>.

I'm sure it's a simple mistake but I cannot find it. I feel like there already might be something for this in the standard library or <code>collections</code>, but I can't find that either.

Finding a key recursively in a dictionary

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在尝试编写一个非常简单的函数来递归地搜索可能嵌套的(在最极端的情况下是十层深) Python字典，并返回它从给定键中找到的第一个值。我不明白为什么我的代码不适用于嵌套字典。def _finditem(obj, key):    if key in obj: return obj[key]    for k, v i...

问在字典中递归查找键
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在字典中递归查找键EN