Question

我有嵌套词典：

{'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接近请。

编辑（1）：嵌套在1到4级别之间，但在解析之前我知道嵌套。

编辑（2）：修正了代码。

**编辑（3）：**再次修复ids字符串值的代码。请原谅造成的混乱。这是最后的我希望：）

Answer 1

你的结构令人不快不规律。这是一个带有访问者功能的版本，可以遍历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

你会这样使用它。

walkDict( myDict, filterFor )

这可以转换为生成器，而不是访问者;它会yield path, aDict[k]而不是调用访问者功能。

你可以在for循环中使用它。

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

Answer 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}

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

Answer 4

这是一个老问题，但仍然是google的最高结果，所以我会更新：

一位朋友和我自己发布了一个库来解决（非常接近）这个确切的问题。 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 *）的所有对象。父位有点笨拙，但它会起作用。

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

Answer 6

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

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

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

Answer 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

怎么做 - python字典遍历和搜索

7 个答案: