使用Python中的键的有序列表在带有列表的嵌套字典中行走

Question

I have a nested dict as follow:

d = {'A': [{'B': [{'C': [{'D1':[]}, {'D2': []}]}]}]} # just an example

And I am given a list/path like this:

l = ['A','B','C','D1']

I'd like to walk down the path in the dict to retrieve the corresponding value of D1 . I have written the following program to do that:

def find_dict(ld, key):
    # we can assume that 'ld' has dicts each of which has unique key
    for d in ld:
        if key not in d:
            continue
        return d

def walk_dict(d,path):
    temp = None
    for i,n in enumerate(path):
        if i == 0:
            temp = d.get(n)
        elif i < (len(path)-1):
            temp = find_dict(temp, n)
            temp = temp.get(n)
        else: # last item
            temp = find_dict(temp, n)
            print('Found it!')
            print(i,n)
            print(temp.get(n))
            return temp.get(n)

d = {'A': [{'B': [{'C': [{'D1':[]}, {'D2': []}]}]}]}
l = ['A','B','C','D1'] # successfully retrieved the value of 'D1'
walk_dict(d,l)
l = ['A','B','C','D2'] # successfully retrieved the value of 'D2'
walk_dict(d,l)
l = ['A','B','C','D3'] # get NoneType error as expected because 'D3' does not exist
walk_dict(d,l)

I'd like to know if there's a better way to accomplish this. I feel like this approach has a bit too verbose, and maybe even have bug(s) lurking.

Thank you in advance for your answers/suggestions!

Answer 1

I have used a recursive approach.

d = {'A': [{'B': [{'C': [{'D1':'xyz'}, {'D2': []}]}]}]}
l = ['A','B','C','D1']
output = []
def find_path(dict_obj,key=0):
    for k,v in dict_obj.items():
        if k == l[key]:
            if key == len(l)-1:
                output.append(v)
                return
            if isinstance(v,dict):
                find_path(v, key+1)
            elif isinstance(v,list):
                for i,item in enumerate(v):
                    if isinstance(item,dict):
                        find_path(item,key+1)

find_path(d)
print(output[0] if output else None)

Outputs:

l = ['A','B','C','D1']
# xyz
l = ['A','B','C']
# [{'D1': 'xyz'}, {'D2': []}]
l = ['A','B','C','D3']
# None
l = ['A','B','C','D2']
# []

Answer 2

How about walk the dict like this:

from copy import deepcopy

def walk_dict(ld, path):
    if isinstance(path, str):
        path = path.split()
    t = deepcopy(ld)
    for key in path:
        if isinstance(t, list):
            try:
                t = [d for d in t if key in d][0]
            except IndexError:
                return
        try:
            t = t[key]
        except KeyError:
            return
    else:
        return t

def main():
    d = {'A': [{'B': [{'C': [{'D1':['values of D1']}, {'D2': "I'm D2"}]}]}]}
    a = 'A B C D1'
    print(walk_dict(d, a))
    a = 'A B C D2'
    print(walk_dict(d, a))
    a = 'A B C D3'
    print(walk_dict(d, a))
    a = 'A B1 C D3'
    print(walk_dict(d, a))


if __name__ == '__main__':
    main()

Output:

['values of D1']
I'm D2
None
None

Answer 3

You can use this recursive function:

d = {'A': [{'B': [{'C': [{'D1':[]}, {'D2': []}]}]}]} # just an example
def walk(_d, path):
   a, *b = path
   if isinstance(_d, list):
     _d = [i for i in _d if a in i]
     if not _d:
       return None
     _d = _d[0]
   return _d[a] if not b else walk(_d[a], b)

tests = [[['A','B','C','D1'], []], [['A','B','C','D2'], []], [['A','B','C','D3'], None]]
for a, b in tests:
  assert walk(d, a) == b

print('all cases passed')

Output:

all cases passed

Below are the timings for the current answers. The source code for the timings and input setup can be found as a gist here .