如何遍历和搜索python字典？_Python_Parsing_Dictionary_Struct_Nested

如何遍历和搜索python字典？

python parsing dictionary struct

如何遍历和搜索python字典？,python,parsing,dictionary,struct,nested,Python,Parsing,Dictionary,Struct,Nested,我有嵌套字典： {'key0': {'attrs': {'entity': 'p', 'hash': '34nj3h43b4n3', 'id': '4130'}, u'key1': {'attrs': {'entity': 'r', 'hash': '34njasd3h43b4n3', 'id': '4130-1'},

我有嵌套字典：

{'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

——所有

id

中的一个，如

到

4130-2-2

导航到正确词典的最简单方法是什么

例如，如果给定的

id

是

4130-2-1

，那么它应该使用

key=key5

非xml方法

编辑（1）：嵌套在

到

级别之间，但在解析之前我知道嵌套

编辑（2）：修复了代码

**编辑（3）：**再次修复了

ids

字符串值的代码。请原谅造成的混乱。我希望这是最后的结果：）

好吧，如果您只需要做几次，您可以使用嵌套的dict.iteritems（）来查找您要查找的内容

如果您计划多次这样做，性能将很快成为一个问题。在这种情况下，您可以：

将数据返回给您的方式更改为更合适的方式
如果不能，请将数据转换为id和键之间的dict（使用iteritems）。然后使用它

如果您想以一般方式解决问题，无论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}

你的结构不规则，令人不快。这是一个带有Visitor函数的版本，该函数遍历

attrs

子字典

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

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

你会像这样使用它

walkDict( myDict, filterFor )

可以将其转换为生成器，而不是访问者；它将
产生路径，aDict[k]
而不是调用visitor函数
你可以在for循环中使用它

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

这类问题通常通过正确的类定义而不是泛型字典来更好地解决

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

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'] )

这是一个老问题，但仍然是google的一个顶级结果，因此我将更新：
我和一位朋友出版了一本图书馆来解决（几乎）这个确切的问题。dpath-python（与做类似事情的perl-dpath模块无关）

您需要做的就是这样：

$ 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*）的所有对象。父位有点僵硬，但它可以工作。
因为递归在python中是有限的（参见 ) 对于这个问题，我希望有一个基于循环的答案，这样答案就可以根据字典中的任何深度进行调整。为此，函数

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,)) )

我相信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

您可以在这里找到详细文档：
我们创建此结构时的想法是通过键（如-key1、key2等）访问它。现在我偶然发现了通过ID访问的要求。第二个要点是一个很好的建议，我会尝试一下。我有大量的建议，如果你能建议一个更好的结构，具有任意级别的支持，易于插入和检索，那就太好了。当你想出这个结构时，我会尝试你的解决方案。谢谢。@JV：内部的“attrs”字典是不明智的。那些是某个已定义类的对象，而不仅仅是匿名词典的候选对象。我已经投票支持你，不知道如何选择2个答案，否则我也会选择这个答案。：）如果进行大量查找，则转换为对象然后转换为“id”上的索引的成本将分摊到查找中。构建对象是O（n）。构建索引是O（n），可以在构建对象时进行。id的查找是O（1）。对于“4130-2-1”，您想要的是“键4”，而不是“键5”，对吗“键5”似乎包含“4130-2-2”。另请参见：这是一个很棒的库。这值得更多的关注。