如何在Python中的嵌套字典中检查值？

Question

Suppose we have a list of dictionaries listD where each dictionary is quite deeply nested with more dictionaries. egsuppose that the first element of listD is:

listD[0] = {"bar1":{"bar2":{"bar3":1234}}}

Now I want to check if listD[i]["bar1"]["bar2"]["bar3"] == 1234 for all i. For the first element where i = 0, this is easy as we can just use the expression:

listD[0]["bar1"]["bar2"]["bar3"] == 1234 

But I cannot simply write a loop like:

for dictelem in listD:
  if dictelem["bar1"]["bar2"]["bar3"] == 1234:
    print "equals 1234"

This is because some of the dictionary elements of listD might be of the form

listD[i] = {"bar1":{"bar2":"abcd"}} or
listD[i] = {"bar1":{"bar2":None}} 

and if I try to access "bar3" when it doesn't exists, an error will be raised.

Right now I am manually specifying in the code to check for the existence of the bar1, bar2 and bar3 keys and whether that are in fact dictionaries or not. But this is really verbose and I'm quite sure there's a simpler way to do it but I can't figure out how.

Answer 1

def dictcheck(d, p, v):
    if len(p):
        if isinstance(d,dict) and p[0] in d:
            return dictcheck(d[p[0]], p[1:], v)
    else:
        return d == v

You pass one dict d , one path of keys p , and the final value to check v . It will recursively go in the dicts and finally check if the last value is equal to v .

>>> dictcheck({"bar1":{"bar2":{"bar3":1234}}}, ('bar1','bar2','bar3'), 1234)
True

>>> dictcheck({"bar1":1234}, ('bar1','bar2','bar3'), 1234)
False

So, to answer your question ( I want to check if listD[i]["bar1"]["bar2"]["bar3"] == 1234 for all i ):

all(dictcheck(x, ('bar1','bar2','bar3'), 1234) for x in listD)

Answer 2

just use a try/except block this way:

for dictelem in listD:
    try:
        if dictelem["bar1"]["bar2"]["bar3"] == 1234:
            print "equals 1234"
    except TypeError:
        pass

Answer 3

When dealing with nested dictionaries, I think of them as a tree where the keys make up the path to the value. With that in mind, I created a non-recursive function, dict_path with takes in a nested dictionary, the key path, and a value in case not found:

def dict_path(dic, path, value_if_not_found=None):
    path = path.split('.')
    try:
        for key in path:
            dic = dic[key]
        return dic
    except (KeyError, TypeError):
        return value_if_not_found

listD = [
    {"bar1": {"bar2": 'abcd'}},
    {"bar1": {"bar2": None}},
    {"bar1": {"bar2": {"bar3": 1234}}},
]

for dic in listD:
    value = dict_path(dic, 'bar1.bar2.bar3')
    if value == 1234:
        print 'Equals 1234:', dic

The function keeps traversing the nested dictionary until one of these three conditions occur:

1. It found the value in question. In this case, return that value
2. Along the way, the object is a dictionary, but does not have the requested key. In this case, a KeyError is raised
3. The object is not a dictionary, the TypeError is raised

For case 2 and 3, we simply return value_if_not_found

Answer 4

you can try this

for item in listD:
    if item.get("bar1",{}).get("bar2",{}).get("bar3","") == 1234:
        print "yeah, gotcha"