如何遍历和搜索 python 字典？

Posted 2023-02-23

【中文标题】如何遍历和搜索 python 字典？

【英文标题】：How do I traverse and search a python dictionary?

【发布时间】：2010-09-27 16:49:11

【问题描述】：

我有嵌套字典：

'key0': 'attrs': 'entity': 'p', 'hash': '34nj3h43b4n3', 'id': '4130',
          u'key1': 'attrs': 'entity': 'r',
                              'hash': '34njasd3h43b4n3',
                              'id': '4130-1',
                    u'key2': 'attrs': 'entity': 'c',
                                        'hash': '34njasd3h43bdsfsd4n3',
                                        'id': '4130-1-1',
          u'key3': 'attrs': 'entity': 'r',
                              'hash': '34njasasasd3h43b4n3',
                              'id': '4130-2',
                    u'key4': 'attrs': 'entity': 'c',
                                        'hash': '34njawersd3h43bdsfsd4n3',
                                        'id': '4130-2-1',
                    u'key5': 'attrs': 'entity': 'c',
                                        'hash': '34njawersd3h43bdsfsd4n3',
                                        'id': '4130-2-2',
 'someohterthing': 'someothervalue',
 'something': 'somevalue'
                                                            
      

给定一个id - 所有ids 之一，例如4130 到4130-2-2。 导航到正确字典的最简单方法是什么？

如果给定的id 是4130-2-1，那么它应该通过key=key5 到达字典。

请不要使用 XML 方法。

Edit(1)：嵌套在1到4级别之间，但我在解析之前就知道嵌套了。

编辑(2)：修正了代码。

Edit(3)：再次修复了ids 字符串值的代码。请原谅造成的混乱。我希望这是最终的:)

【问题讨论】：

对于'4130-2-1'，你想要'key4'，而不是'key5'，对吗？ “key5”似乎包含“4130-2-2”。

另见： ***.com/questions/7681301/… ***.com/a/16508328/42223

【参考方案1】：

您的结构非常不规则。这是一个带有遍历attrs 子字典的Visitor 函数的版本。

def walkDict( aDict, visitor, path=() ):
    for  k in aDict:
        if k == 'attrs':
            visitor( path, aDict[k] )
        elif type(aDict[k]) != dict:
            pass
        else:
            walkDict( aDict[k], visitor, path+(k,) )

def printMe( path, element ):
    print path, element

def filterFor( path, element ):
    if element['id'] == '4130-2-2':
        print path, element

你会这样使用它。

walkDict( myDict, filterFor )

这可以变成一个生成器而不是一个访客；它会 yield path, aDict[k] 而不是调用访问者函数。

你会在 for 循环中使用它。

for path, attrDict in walkDictIter( aDict ):
    # process attrDict...

【讨论】：

我收集了大量这些，如果你能提出一个更好的结构，支持任意级别，易于插入和检索，那就太好了。当你想出那个结构时，我会尝试你的解决方案。谢谢。

@JV：内部“attrs”字典是不明智的。那些是某个已定义类的对象的候选对象，而不仅仅是匿名字典。

【参考方案2】：

如果您想以一般方式解决问题，无论您的 dict 中有多少级嵌套，都可以创建一个遍历树的递归函数：

def traverse_tree(dictionary, id=None):
    for key, value in dictionary.items():
        if key == 'id':
            if value == id:
                print dictionary
        else:
             traverse_tree(value, id)
    return

>>> traverse_tree(1: 'id': 2, 2: 'id': 3, id=2)
'id': 2

【讨论】：

我投票给你了，不知道如何选择 2 个答案，否则我也会选择这个。 :)

【参考方案3】：

这类问题通常通过适当的类定义而不是通用字典更好地解决。

class ProperObject( object ):
    """A proper class definition for each "attr" dictionary."""
    def __init__( self, path, attrDict ):
        self.path= path
        self.__dict__.update( attrDict )
    def __str__( self ):
        return "path %r, entity %r, hash %r, id %r" % (
            self.path, self.entity, self.hash, self.id )

masterDict=  
def builder( path, element ):
    masterDict[path]= ProperObject( path, element )

# Use the Visitor to build ProperObjects for each "attr"
walkDict( myDict, builder )

# Now that we have a simple dictionary of Proper Objects, things are simple
for k,v in masterDict.items():
    if v.id == '4130-2-2':
        print v

此外，现在您已经有了正确的对象定义，您可以执行以下操作

# Create an "index" of your ProperObjects
import collections
byId= collections.defaultdict(list)
for k in masterDict:
    byId[masterDict[k].id].append( masterDict[k] )

# Look up a particular item in the index
print map( str, byId['4130-2-2'] )

【讨论】：

如果您进行大量查找，则转换为对象然后转换为“id”上的索引的成本将在查找中分摊。构建对象是 O(n)。构建索引是 O(n) 并且可以在构建对象时完成。查找 id 是 O(1)。

【参考方案4】：

这是一个老问题，但仍然是谷歌搜索结果，所以我会更新：

我和一个朋友发布了一个库来解决（非常接近）这个确切的问题。 dpath-python（与执行类似操作的 perl dpath 模块无关）。

http://github.com/akesterson/dpath-python

您需要做的就是这样：

$ easy_install dpath
>>> import dpath.util
>>> results = []
>>> for (path, value) in dpath.util.search(my_dictionary, "*/attrs/entity/4130*", yielded=True):
>>> ... parent = dpath.util.search("/".join(path.split("/")[:-2])
>>> ... results.append(parent)

... 这将为您提供与您的搜索匹配的所有字典对象的列表，即所有具有 (key = 4130*) 的对象。父位有点笨拙，但它会起作用。

【讨论】：

这是一个很棒的图书馆。这值得更多关注。

【参考方案5】：

由于已知递归在 python 中是有限的（参见 What is the maximum recursion depth in Python, and how to increase it?) 我宁愿对这个问题有一个基于循环的答案，所以答案可以适应字典中的任何深度级别。为此，函数

def walkDict( aDict, visitor, path=() ):
    for  k in aDict:
        if k == 'attrs':
            visitor( path, aDict[k] )
        elif type(aDict[k]) != dict:
            pass
        else:
            walkDict( aDict[k], visitor, path+(k,) )

可以替换为：

def walkDictLoop(aDict, visitor, path=()):
    toProcess = [(aDict, path)]
    while toProcess:
        dictNode, pathNode = toProcess.pop(0)
        for k in dictNode:
            if k == 'attrs':
                visitor(pathNode, dictNode[k])
            if isinstance(dictNode[k], dict):
                toProcess.append( (dictNode[k], pathNode+(k,)) )

【参考方案6】：

好吧，如果你只需要做几次，你可以使用嵌套的 dict.iteritems() 来找到你要找的东西。

如果你打算做几次，性能很快就会成为一个问题。在这种情况下，您可以：

将数据返回给您的方式更改为更合适的方式。

如果不能，将数据转换为 id 和键之间的字典（使用 iteritems）。那就用吧。

【讨论】：

我们创建这个结构时的想法是通过键来访问它——比如——key1、key2 等。现在我偶然发现了一个通过 id 访问的要求。第二个要点是一个不错的建议，但会尝试。

【参考方案7】：

我相信 pydash 会给你最有效的方法来实现这一点。

例如：

data = 'a': 'b': 'c': [0, 0, 'd': [0, 1: 2]], 'names': 'first': 'gus', 'second': 'parvez'

pydash.get(data, 'a.b.c.2.d.1.[1]')

# output: 2

您可以在此处找到详细文档：https://pydash.readthedocs.io/en/latest/quickstart.html