Iterate in a dictionary with unknown keys and unknown number of nested dictionaries

Question

Is there a better way of parsing API responses in which I don't know how many nested dicts I can get in?

A change in the responses of the API, now throws nested dicts. All the code to get responses is dict based.

I found a horrible way, but sometimes I get level 5 nested dictionaries.....

Sample of example response:

                    "MalwareProtectionStatus": "disabled",
                    "malware": {
                        "QuarantineStatus": "Disabled",
                        "config": {
                            "av": {
                                "status": "Disabled",
                                "quarantine": {
                                    "status": "Disabled"
                                }
                            },
                            "mg": {
                                "status": "Disabled",
                                "quarantine": {
                                    "status": "Disabled"
                                }
                            }
                        }
                    }

I prepared code with input data like the real one structure. But it is a horrible way to do this, and if the API response gets more levels of nested dicts.... then... more horrible code needed, take a look....

My awful code (edited for better understanding):

def flatted(_key, _value):
    flatted_rslt = {}
    for k, v in _value.items():
        flatted_rslt.update({f'{_key}_{k}': v})
    return flatted_rslt


def parse_to_flat(_api_response):
    result = {}
    for key, value in _api_response.items():
        if isinstance(value, dict):
            result.update(flatted(key, value))
        else:
            result.update({key: value})
    return result


if __name__ == '__main__':

    api_response = {'level-a1': '1', 'level-a2': {'level-b1': '21',
                    'level-b2': {'level-c1': '31', 'level-c2': {'level-d1': '41'}}}}

    # flattening level 1
    parsed_api_response_level_1 = parse_to_flat(api_response)
    print(parsed_api_response_level_1)

    # flattening level 2
    parsed_api_response_level_2 = parse_to_flat(parsed_api_response_level_1)
    print(parsed_api_response_level_2)

    # flattening level 3
    parsed_api_response_level_3 = parse_to_flat(parsed_api_response_level_2)
    print(parsed_api_response_level_3)

The code throws:

{'level-a1': '1', 'level-a2_level-b1': '21', 'level-a2_level-b2': {'level-c1': '31', 'level-c2': {'level-d1': '41'}}}
{'level-a1': '1', 'level-a2_level-b1': '21', 'level-a2_level-b2_level-c1': '31', 'level-a2_level-b2_level-c2': {'level-d1': '41'}}
{'level-a1': '1', 'level-a2_level-b1': '21', 'level-a2_level-b2_level-c1': '31', 'level-a2_level-b2_level-c2_level-d1': '41'}

It works... but only if I know the level of nested dicts, sometimes I saw 5 levels...

Any idea of doing this in a better way????

Nand0san · Accepted Answer · 2019-11-12T11:30:33.907

Found better view here: Flatten nested dictionaries, compressing keys

def flatten_dict(dd, separator='_', prefix=''):
    return {prefix + separator + k if prefix else k: v
             for kk, vv in dd.items()
             for k, v in flatten_dict(vv, separator, kk).items()
             } if isinstance(dd, dict) else { prefix : dd }

api_response = {'level-1': '1', 'level-2': {'leve2-1': '21',
                    'leve2-2': {'leve3-1': '31', 'leve3-2': {'leve4-1': '41',
                    'level4-2': {'level5-1': '51'}, 'level5-2': '52'}}}}


print(flatten(api_response))

Output:

{'level-1': '1', 'level-2_leve2-1': '21', 
'level-2_leve2-2_leve3-1': '31', 
'level-2_leve2-2_leve3-2_leve4-1': '41', 
'level-2_leve2-2_leve3-2_level4-2_level5-1': '51', 
'level-2_leve2-2_leve3-2_level5-2': '52'}

Iterate in a dictionary with unknown keys and unknown number of nested dictionaries

1 Answers1