如何将任意长度的元组列表转换为嵌套字典？

问题描述 #

给定一组元组构成的列表：

my_list = [('a','aa','aaa',0),('a','aa','aab',1),('a','ab','aba',2)]

需要将其转换为多层嵌套的字典结构：

out = {'a':{'aa':{'aaa':0,'aab':1},'ab':{'aba':2}}}

核心要求：元组的长度不固定，需实现可适配任意合法长度元组的通用转换逻辑（元组前n-1个元素为嵌套键路径，最后一个元素为对应值）。

迭代实现方案 #

迭代方式逻辑直观，逐层遍历键路径并构建嵌套字典，性能更稳定，适合处理大规模数据：

def build_nested_dict(tuple_list):
    root = {}
    for tpl in tuple_list:
        # 拆分键路径与最终值
        key_path = tpl[:-1]
        final_value = tpl[-1]
        current_layer = root
        
        # 遍历键路径的前n-1个键，逐层创建嵌套字典
        for key in key_path[:-1]:
            if key not in current_layer:
                current_layer[key] = {}
            current_layer = current_layer[key]
        
        # 将最后一个键与值绑定
        current_layer[key_path[-1]] = final_value
    return root

# 测试示例
my_list = [('a','aa','aaa',0),('a','aa','aab',1),('a','ab','aba',2)]
output = build_nested_dict(my_list)
print(output)
# 输出结果: {'a': {'aa': {'aaa': 0, 'aab': 1}, 'ab': {'aba': 2}}}

递归实现方案 #

如果偏好递归写法，可通过逐层拆解元组实现：

def recursive_build(current_dict, tpl):
    if len(tpl) == 2:
        # 仅剩键和值，直接完成赋值
        current_dict[tpl[0]] = tpl[1]
        return
    # 处理当前层级的键，不存在则创建空字典
    current_key = tpl[0]
    if current_key not in current_dict:
        current_dict[current_key] = {}
    # 递归处理剩余元素
    recursive_build(current_dict[current_key], tpl[1:])

def tuple_to_nested(tuple_list):
    result = {}
    for tpl in tuple_list:
        recursive_build(result, tpl)
    return result

# 测试长元组场景
test_long_tuples = [('x','y','z','w',100),('x','y','z','v',200)]
print(tuple_to_nested(test_long_tuples))
# 输出结果: {'x': {'y': {'z': {'w': 100, 'v': 200}}}}

方案通用性说明 #

上述两种方案均支持任意长度的元组（只要元组格式统一：前n-1个元素为嵌套键，最后一个为对应值），无需提前指定元组长度，完全适配需求。

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