如何在Python中将复杂的嵌套字典结构转化为扁平化列表？-Python教程-PHP中文网

flatten_dict 应支持 dict 和 list 递归展开，键路径用 sep 参数拼接（如 . 或 _），列表索引需转字符串并纳入路径，用 isinstance(v, (dict, list)) 判断容器类型，深度场景建议用 path 列表优化字符串拼接。

如何在python中将复杂的嵌套字典结构转化为扁平化列表？

用 `flatten_dict` 递归展开嵌套字典时，键名拼接规则必须提前约定

直接用 json.dumps 或 str() 转字符串再解析，只会得到不可用的文本，不是结构化列表。真正要的是把 {"a": {"b": 1, "c": {"d": 2}}} 变成 [{"key": "a.b", "value": 1}, {"key": "a.c.d", "value": 2}] 这类可迭代、可存库、可导出的扁平结构。

关键在键路径拼接方式：用点号 . 最常见，但遇到含 . 的原始 key（比如 API 返回的 {"user.email": "x@y.z"}）就会冲突；下划线 _ 更安全，但需全局统一。建议初始化时传入 sep 参数，避免硬编码。

示例函数骨架：

def flatten_dict(d, parent_key='', sep='.'):
    items = []
    for k, v in d.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.extend(flatten_dict(v, new_key, sep=sep))
        else:
            items.append({"key": new_key, "value": v})
    return items

处理列表嵌套时，`list` 元素索引必须转为字符串并纳入路径

很多嵌套结构里夹着 list，比如 {"users": [{"name": "Alice"}, {"name": "Bob"}]}。如果忽略 list，只处理 dict，会漏掉全部 user 数据。

正确做法是：遇到 list 时，对每个元素递归调用，并把当前索引（str(i)）追加到路径中。否则你根本分不清哪个值属于哪个数组项。

不处理 list → 扁平结果只有 {"key": "users", "value": [...]}，内部数据丢失
处理 list 但索引没转字符串 → TypeError: can only concatenate str (not "int") to str
索引未纳入路径 → 所有 name 都变成 "users.name"，无法区分 Alice 和 Bob

补丁逻辑加在原函数里：

if isinstance(v, list):
    for i, item in enumerate(v):
        new_key = f"{parent_key}{sep}{k}[{i}]" if parent_key else f"{k}[{i}]"
        if isinstance(item, dict):
            items.extend(flatten_dict(item, new_key, sep=sep))
        else:
            items.append({"key": new_key, "value": item})

`isinstance(v, (dict, list))` 判断比 `type(v) == dict` 更可靠

有些库返回的是 collections.OrderedDict 或 types.SimpleNamespace 实例，甚至自定义的映射类。用 type(v) == dict 会跳过它们，导致深层结构被当普通值截断。

Shadows Python Sensei

Python 最佳实践助手——代码规范、设计模式、性能优化、测试与类型注解。适用于编写或审查 Python 代码。

下载

isinstance(v, dict) 能覆盖所有 dict 子类，但注意：它不包含 list，所以必须显式写成 isinstance(v, (dict, list)) —— 括号里是 tuple，不是 list。

另一个坑：None、bool、int、float、str 都该直接作为 value 输出，不要误判为容器类型。检查顺序很重要：先判 dict/list，再处理基础类型。

性能敏感场景下，避免重复拼接字符串路径

深度嵌套（比如 10 层以上）+ 大量字段时，频繁用 f"{a}{sep}{b}" 创建新字符串会明显拖慢速度，尤其在 Python 3.8 之前。

更高效的做法是传入一个 path 列表，每次 .append(k) / .pop()，最后 sep.join(path) 一次生成键名。内存占用略增，但字符串操作开销大幅下降。

改动示意：

def flatten_dict(d, path=None, sep='.'):
    if path is None:
        path = []
    items = []
    for k, v in d.items():
        path.append(k)
        if isinstance(v, dict):
            items.extend(flatten_dict(v, path, sep=sep))
        elif isinstance(v, list):
            for i, item in enumerate(v):
                path.append(f"[{i}]")
                if isinstance(item, dict):
                    items.extend(flatten_dict(item, path, sep=sep))
                else:
                    items.append({"key": sep.join(path), "value": item})
                path.pop()
        else:
            items.append({"key": sep.join(path), "value": v})
        path.pop()
    return items

这种写法在千级嵌套字段时，实测快 2–3 倍。但日常小数据量没必要折腾，可读性反而下降。

最常被忽略的是：原始数据里混有 datetime、Decimal、bytes 等类型，它们不能直接 JSON 序列化，扁平后若要导出 JSON，得提前统一转 str 或 float。