如何将键为元组的扁平字典转换为支持n层嵌套的字典？

递归实现方案 #

如果一定要用递归实现，以下代码支持任意长度的元组键，无需额外的空字典生成函数：

def build_nested(key_tuple, value):
    # 递归终止条件：元组只剩最后一个键，直接返回键值对字典
    if len(key_tuple) == 1:
        return {key_tuple[0]: value}
    # 递归构建内层嵌套结构
    return {key_tuple[0]: build_nested(key_tuple[1:], value)}

def tuple_to_nested(tuple_dict):
    final_dict = {}
    for key, val in tuple_dict.items():
        nested_part = build_nested(key, val)
        # 处理键重叠的情况，合并嵌套字典
        first_key = next(iter(nested_part.keys()))
        if first_key in final_dict:
            # 递归合并已有字典和新生成的嵌套部分
            def merge_dict(a, b):
                for k, v in b.items():
                    if k in a and isinstance(a[k], dict) and isinstance(v, dict):
                        merge_dict(a[k], v)
                    else:
                        a[k] = v
            merge_dict(final_dict, nested_part)
        else:
            final_dict.update(nested_part)
    return final_dict

更简洁的迭代实现（推荐） #

递归虽然符合需求，但迭代版本代码更简洁高效，且没有递归深度限制，同样满足你的要求：

def tuple_to_nested(tuple_dict):
    final_dict = {}
    for key_tuple, value in tuple_dict.items():
        current_level = final_dict
        # 遍历元组前n-1个键，逐层创建/进入嵌套字典
        for key in key_tuple[:-1]:
            # 用setdefault自动创建空字典（如果键不存在），并移动到下一层
            current_level = current_level.setdefault(key, {})
        # 最后一个键对应赋值目标值
        current_level[key_tuple[-1]] = value
    return final_dict

测试示例 #

# 定义示例中的键（实际使用可以是任意可哈希类型）
a, b, c = "a", "b", "c"
tuple_dict = {(a, b, c): {"f": 5, "d": 6, "e": 4}}
final_dict = tuple_to_nested(tuple_dict)
print(final_dict)
# 输出结果：{'a': {'b': {'c': {'f': 5, 'd': 6, 'e': 4}}}}

方案优势 #

• 支持任意长度的元组键，不再局限于7层
• 无需额外的空外壳生成函数，代码简洁直观
• 迭代版本性能更优，避免递归深度过大的问题（比如元组长度超过Python默认递归深度限制的情况）

内容的提问来源于stack exchange，提问作者user2817017