recursively traverse multidimensional dictionary, dimension unknown

Question

I want to create a function to recursively traverse a multidimensional dictionary, where the dimensions are unknown.

Here is what I have come up with so far, but it doesn't seem to be working correctly. This will print out some key / values twice and they are not in order.

def walk_dict(d):
    for k,v in d.items():
        if isinstance(v, dict):
            walk_dict(v)
        else:
            print "%s %s" % (k, v)

Here's a sample array:

d = {
        'plan_code': 'b',
        'quantity': '1',
        'account': {
            'account_code': 'b',
            'username': 'jdoe',
            'email': 'jdoe@domain.com',
            'first_name': 'b',
            'last_name': 'b',
            'company_name': 'Company, LLC.',
            'billing_info': {
                'first_name': 'b',
                'last_name': 'b',
                'address1': '123 Test St',
                'city': 'San Francisco',
                'state': 'CA',
                'country': 'US',
                'zip': '94105',
                'credit_card': {
                    'number': '1',
                    'year': '2018',
                    'month': '12',
                    'verification_value': '123',
                },
            },
        },
    }

score 20 · Accepted Answer · answered Oct 05 '10 at 04:37

I'm not sure what your ultimate goal is, but the code is doing what it is supposed to. You are seeing what you think are repeats of items because there are key/value combos like 'first_name':'b' that are both within 'account' and within 'billing_info' within 'account'. I'm not sure what order you are looking for, but dictionaries are unordered so your function to print them out will have to give them some order, for instance by replacing the following:

for k,v in d.items():

with

for k,v in sorted(d.items(),key=lambda x: x[0]):

or you'll need an ordered dictionary. You can also use the pprint module like so to give a nice print out of a dict:

>>> import pprint
>>> pprint.pprint(d)
{'account': {'account_code': 'b',
             'billing_info': {'address1': '123 Test St',
                              'city': 'San Francisco',
                              'country': 'US',
                              'credit_card': {'month': '12',
                                              'number': '1',
                                              'verification_value': '123',
                                              'year': '2018'},
                              'first_name': 'b',
                              'last_name': 'b',
                              'state': 'CA',
                              'zip': '94105'},
             'company_name': 'Company, LLC.',
             'email': 'jdoe@domain.com',
             'first_name': 'b',
             'last_name': 'b',
             'username': 'jdoe'},
 'plan_code': 'b',
 'quantity': '1'}

However, I'm not fully sure what your end goal is here. Also, you are missing the keys when the values are dictionaries. I modified your code to do a similar thing to what pprint does in the following:

def walk_dict(d,depth=0):
    for k,v in sorted(d.items(),key=lambda x: x[0]):
        if isinstance(v, dict):
            print ("  ")*depth + ("%s" % k)
            walk_dict(v,depth+1)
        else:
            print ("  ")*depth + "%s %s" % (k, v)

which for your example dict yields:

>>> walk_dict(d)
account
  account_code b
  billing_info
    address1 123 Test St
    city San Francisco
    country US
    credit_card
      month 12
      number 1
      verification_value 123
      year 2018
    first_name b
    last_name b
    state CA
    zip 94105
  company_name Company, LLC.
  email jdoe@domain.com
  first_name b
  last_name b
  username jdoe
plan_code b
quantity 1

score 5 · Answer 2 · edited Feb 13 '20 at 02:38

5

import json
print(json.dumps(d, indent=4))

edited Feb 13 '20 at 02:38

Pat Myron

4,437
2
20
39

answered Dec 27 '12 at 10:03

Chris Johnson

20,650
6
81
80

1

In my case I need to do this precisely because `json.dumps` cannot handle some of the objects in the structure. – OrangeDog May 03 '17 at 16:43
The `jsonpickle` library does a surprisingly good job of representing object types `json` chokes on - try that. – Chris Johnson May 03 '17 at 19:47

floer32 · Answer 3 · 2019-02-27T03:04:58.720

2

Here is a variation on the accepted answer by Justin Peel that returns its result as an OrderedDict instead of printing the result.

from collections import OrderedDict

def sort_by_keys(dct,):
    new_dct = OrderedDict({})
    for item in sorted(dct.items(), key=lambda (key, val): key):
        key = item[0]
        val = item[1]
        if isinstance(val, dict):
            new_dct[key] = sort_by_keys(val)
        else:
            new_dct[key] = val
    return new_dct

edited Feb 27 '19 at 03:04

answered Aug 27 '14 at 22:28

floer32

2,190
4
29
50

2

tuple unpacking is not supported in Python 3 – Jenobi Feb 21 '19 at 19:06

score 2 · Answer 4 · edited May 23 '17 at 12:33

2

This does print the key, value pairs correctly. Can you point out which data gets repeated. There can be confusion based on the above data as these keys :

'first_name': 'b',
'last_name': 'b',

are part of two dictionaries - 'account' and 'billing_info'. So they will appear twice in output.

Also if you want some kind of order in which your dictionaries K,V should get printed use Ordered Dictionaries

edited May 23 '17 at 12:33

Community

1
1

answered Oct 05 '10 at 04:31

pyfunc

65,343
15
148
136

I just grabbed that dict and didn't notice the repeat. Thought I was doing something wrong. Thanks for pointing that out. – imns Oct 05 '10 at 04:44

score 1 · Answer 5 · edited May 23 '17 at 12:24

As Justin Peel mentions, pprint.pprint will probably do what you want.

I think the problem with your code is that you should be printing the key first before recursing, i.e. change

    if isinstance(v, dict):
        walk_dict(v)

to

    if isinstance(v, dict):
        print k
        walk_dict(v)

Though in any case it's going to look pretty confusing unless you add indentation and such.

This sort of thing is actually pretty complicated; check out the code for pprint if you want to get some ideas.

score 0 · Answer 6 · answered Oct 05 '10 at 04:46

your code works perfect fine, it does exactly what you told it to.

The only repeats i see in the output are first_name and last_name which are in fact defined twice (in different dictionaries).

As to 'out of order' Its a dictionary, it doesn't have a guaranteed order. well maybe it does, but it would be based on the internal representation, which you shouldn't rely on.

What you need to do is sort the data in the way that you want it to come out. You also may want to print out the sub dictionary's key value to make the output easier to understand.

score 0 · Answer 7 · answered Oct 05 '10 at 05:15

In Python, dictionaries are indexed by keys. Keys can be any immutable type like a string or number. Unless the keys are sorted, they will always be returned in an arbitrary order. Because of this fact, your walk_dict is printing seemingly random results.

Here is an example of walk_dict which prints all keys and values. I've sorted they keys at each level of the dictionary. Also, I printed each key. Your code didn't print a key before it recursed. Finally, I've added string padding to emphasize each level of the dictionary. The doctests are all passing. I hope this helps you build your final function.

import doctest


def walk_dict(seq, level=0):
    """Recursively traverse a multidimensional dictionary and print all
    keys and values.

    >>> d = {'dog': 'dusty', 'cat': 'fluffy', 'bird': 'chirpy'}
    >>> walk_dict(d)
    bird chirpy
    cat fluffy
    dog dusty
    >>> d = {'location': 'home', 'animals':{'dog': 'dusty', 'cat': 'fluffy', 'bird': 'chirpy'}}
    >>> walk_dict(d)
    animals
      bird chirpy
      cat fluffy
      dog dusty
    location home
    >>> d = {'location': 'home', 'animals':{'dog': 'dusty', 'cat': 'fluffy', 'bird': {'name':'chirpy', 'color':'blue'}}}
    >>> walk_dict(d)
    animals
      bird
        color blue
        name chirpy
      cat fluffy
      dog dusty
    location home
    >>> d = { \
            'plan_code': 'b', \
            'quantity': '1', \
            'account': { \
                'account_code': 'b', \
                'username': 'jdoe', \
                'email': 'jdoe@domain.com', \
                'first_name': 'b', \
                'last_name': 'b', \
                'company_name': 'Company, LLC.', \
                'billing_info': { \
                    'first_name': 'b', \
                    'last_name': 'b', \
                    'address1': '123 Test St', \
                    'city': 'San Francisco', \
                    'state': 'CA', \
                    'country': 'US', \
                    'zip': '94105', \
                    'credit_card': { \
                        'number': '1', \
                        'year': '2018', \
                        'month': '12', \
                        'verification_value': '123', \
                    }, \
                }, \
            }, \
        } 
    >>> walk_dict(d)
    account
      account_code b
      billing_info
        address1 123 Test St
        city San Francisco
        country US
        credit_card
          month 12
          number 1
          verification_value 123
          year 2018
        first_name b
        last_name b
        state CA
        zip 94105
      company_name Company, LLC.
      email jdoe@domain.com
      first_name b
      last_name b
      username jdoe
    plan_code b
    quantity 1
    """
    items = seq.items()
    items.sort()
    for v in items:
        if isinstance(v[1], dict):
            # Print the key before make a recursive call
            print "%s%s" % ("  " * level, v[0])
            nextlevel = level + 1
            walk_dict(v[1], nextlevel)
        else:
            print "%s%s %s" % ("  " * level, v[0], v[1])


if __name__ == '__main__':
    doctest.testmod()

score 0 · Answer 8 · answered Feb 19 '20 at 19:09

The solutions mentioned so far didn't do what I wanted but working from Justin Peel's spelled out version, I was able to make something that printed in a way I wanted:

def dict_parser(data, depth=0):
    if isinstance(data, dict):
        for key in data:
            value = data[key]
            print('  ') * depth + '"' + key + '":'
            dict_parser(value, depth + 1)
    elif isinstance(data, list):
        for item in data:
            if isinstance(item, list):
                dict_parser(item, depth + 1)
            else:
                print('  ') * depth + '"' + item + '"'
    elif isinstance(data, bool):
        print('  ') * depth + str(data)
    else:
        print('  ') * depth + '"' + data + '"'

Which printed something like:

"saved_skels":
  "E:\Child_Skeleton_6ft.fbx"
  "E:\Female_Skeleton_6ft.fbx"
  "E:\HeroFemale_Skeleton.fbx"
  "E:\HeroMale_Skeleton.fbx"
"saved_roots":
  "E:\users\Characters"
  "E:\content\characters"
"saved_tabs":
  "Characters":
    "ProxyFemale":
      "HeroFemale_Skeleton.fbx"
    "animation":
      "HeroFemale_Skeleton.fbx"
    "ProxyMale":
      "HeroMale_Skeleton.fbx"
  "Game":
    ""
  "Proto":
    "Female":
      "Female_Skeleton_NewBP.fbx"
  "Assets":
    ""
  "characters":
    "player":
      "player_Skeleton.fbx"
    "actor":
      "Hero_Skeleton.fbx"
"edit_common_checkbox_state":
  False
"get_latest_checkbox_state":
  True

score 0 · Answer 9 · answered Jan 06 '23 at 16:37

Here is an instance that also converts arbitrary objects into dictionaries (if Python can):

from typing import Union

def walk_dict(d, depth=0) -> None:
    for k, v in sorted(d.items(), key=lambda x: x[0]):
        indentation = depth * "  "
        if not isinstance(v, Union[int, list, None, str]):
            if isinstance(v, dict):
                print(f"k={k}")
                walk_dict(v, depth + 1)
            elif isinstance(v.__dict__, dict):
                print(f"k={k}")
                walk_dict(v.__dict__, depth + 1)
        else:
            print(f"{indentation}k={k},  v={v}")


d = {
    "plan_code": "b",
    "quantity": "1",
    "account": {
        "account_code": "b",
        "username": "jdoe",
        "email": "jdoe@domain.com",
        "first_name": "b",
        "last_name": "b",
        "company_name": "Company, LLC.",
        "billing_info": {
            "first_name": "b",
            "last_name": "b",
            "address1": "123 Test St",
            "city": "San Francisco",
            "state": "CA",
            "country": "US",
            "zip": "94105",
            "credit_card": {
                "number": "1",
                "year": "2018",
                "month": "12",
                "verification_value": "123",
            },
        },
    },
}


walk_dict(d)

Outputs:

k=account
  k=account_code,  v=b
k=billing_info
    k=address1,  v=123 Test St
    k=city,  v=San Francisco
    k=country,  v=US
k=credit_card
      k=month,  v=12
      k=number,  v=1
      k=verification_value,  v=123
      k=year,  v=2018
    k=first_name,  v=b
    k=last_name,  v=b
    k=state,  v=CA
    k=zip,  v=94105
  k=company_name,  v=Company, LLC.
  k=email,  v=jdoe@domain.com
  k=first_name,  v=b
  k=last_name,  v=b
  k=username,  v=jdoe
k=plan_code,  v=b
k=quantity,  v=1

recursively traverse multidimensional dictionary, dimension unknown

9 Answers9

Linked