在具有未知键和未知数量的嵌套字典的字典中迭代

Question

有没有更好的方法来解析 API 我不知道我可以得到多少嵌套字典的响应？

API 的响应发生变化，现在会抛出嵌套的字典。所有获得响应的代码都是基于字典的。

我发现了一个可怕的方法，但有时我会得到 5 级嵌套字典.....

示例响应示例：

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

我准备了带有输入数据的代码，就像真实的结构一样。但这是一种可怕的方法，如果 API 响应获得更多级别的嵌套字典......那么......需要更多可怕的代码，看看......

我糟糕的代码（为了更好地理解而编辑）：

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)

代码抛出：

{'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'}

它有效...但前提是我知道嵌套字典的级别，有时我会看到 5 个级别...

有什么更好的方法吗？？？？

Answer 1

在此处找到更好的视图：展平嵌套字典，压缩键

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

输出：

{'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

api

parsing

dictionary

nested

python-3.7