如何将列表的列表转换为多层嵌套字典（Python）

我想把嵌套列表转换成如下格式的多层嵌套字典：

x = [[1, 2, 3, 4],
     [1, 2, 4, 5],
     [5, 6, 7, 8]]

print(f(x))
# {
#  1: {2: {3: 4,
#          4: 5}
#      },
#  5: {6: {7: 8}}    
# }

内部列表可以是任意长度。另外，任意一组嵌套键对应的唯一值是确定的，不会出现像下面这样的冲突列表：

x = [[1,2,3,4],
     [1,2,3,5]]

我尝试了下面的函数，但它抛出AttributeError: 'int' object has no attribute 'keys'错误，而且输出结果完全不符合需求：

def listoflists_dict(listformat):
    a = dict()
    cur = a
    for inner_list in listformat:
        for i, ele in enumerate(inner_list):
            print(a)
            if (ele not in cur.keys()) and (i < len(inner_list) - 1):
                cur[ele] = dict()
                cur = cur[ele]
            elif (ele not in cur.keys()) and (i == len(inner_list) - 1):
                cur[ele] = inner_list[-1]
            else:
                cur = cur[ele]
    
    return a

listformat = [[1, 2, 3, 4],
     [1, 2, 4, 5],
     [5, 6, 7, 8]]

listoflists_dict(listformat)

# 输出（中间打印的a）：
# {}
# {1: {}}
# {1: {2: {}}}
# {1: {2: {3: {}}}}
# {1: {2: {3: {4: 4}}}}
# {1: {2: {3: {4: 4, 1: {}}}}}
# {1: {2: {3: {4: 4, 1: {2: {}}}}}}
# {1: {2: {3: {4: 4, 1: {2: {4: {}}}}}}}
# {1: {2: {3: {4: 4, 1: {2: {4: {5: 5}}}}}}}
# {1: {2: {3: {4: 4, 1: {2: {4: {5: 5}}}}}}}

解决方案 #

你的代码核心问题有两个：

1. 处理新的内部列表时，没有把cur重置回根字典a，导致后续列表的键会被错误嵌套到上一个列表的最后一层结构里
2. 处理最后一个元素时逻辑错误，把值当成键去赋值，导致后续遍历到int类型的值时，调用keys()方法抛出异常

迭代实现（推荐） #

正确思路是把每个内部列表拆分为嵌套键路径和对应的值：前n-1个元素是逐层嵌套的键，最后一个元素是最内层键对应的值。从根字典开始，顺着键路径逐层创建字典，最后完成赋值。

def list_to_nested_dict(lst):
    result = {}
    for inner in lst:
        # 拆分键路径和对应值
        keys = inner[:-1]
        value = inner[-1]
        current = result
        # 遍历键路径，逐层构建嵌套字典
        for key in keys:
            if key not in current:
                current[key] = {}
            current = current[key]
        # 给最后一个键赋值
        current[keys[-1]] = value
    return result

# 测试
x = [[1, 2, 3, 4],
     [1, 2, 4, 5],
     [5, 6, 7, 8]]
print(list_to_nested_dict(x))
# 输出：{1: {2: {3: 4, 4: 5}}, 5: {6: {7: 8}}}

递归实现 #

如果偏好递归写法，也可以通过递归处理剩余的键路径：

def recursive_list_to_dict(lst):
    result = {}
    for inner in lst:
        if len(inner) == 1:
            # 处理单元素列表的情况，可根据需求调整
            result[inner[0]] = inner[0]
        else:
            first_key = inner[0]
            if first_key not in result:
                result[first_key] = {}
            # 递归处理剩余的子列表
            result[first_key].update(recursive_list_to_dict([inner[1:]]))
    return result

# 测试
print(recursive_list_to_dict(x))
# 输出：{1: {2: {3: 4, 4: 5}}, 5: {6: {7: 8}}}

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