将扁平字典转换为嵌套字典时遇RecursionError问题求助

原始需求 #

现有扁平字典：

d = {"QR": "", "Customer Details": "",
     "feature prompt": "something", "chain": "lee", "store": "levis"}

需要将其转换为嵌套字典，其中值为空字符串的键代表嵌套层级的节点，最终目标结构如下：

{
    "QR": {
        "Customer Details": {
            "feature prompt": "something",
            "chain": "lee",
            "store": "levis"
        }
    }
}

遇到的错误 #

编写的转换代码触发了RecursionError，报错信息如下：

Traceback (most recent call last):
  File "/Users/asmita/so_test/test.py", line 18, in <module>
    print(nest_dict(d))
  File "/Users/asmita/so_test/test.py", line 7, in nest_dict
    split(k,v,result)
  File "/Users/asmita/so_test/test.py", line 14, in split
    split(k,v,out.setdefault(k,{}))
  File "/Users/asmita/so_test/test.py", line 14, in split
    split(k,v,out.setdefault(k,{}))
  File "/Users/asmita/so_test/test.py", line 14, in split
    split(k,v,out.setdefault(k,{}))
  [Previous line repeated 994 more times]
  File "/Users/asmita/so_test/test.py", line 13, in split
    if v=='':
RecursionError: maximum recursion depth exceeded in comparison

错误原因 #

递归函数逻辑存在漏洞：处理值为空字符串的键时，代码会反复对同一个键和空值发起递归调用，形成无限循环。比如每次执行split(k, v, out.setdefault(k, {}))时，传入的k和v没有变化，且v始终是空字符串，导致函数不断自我调用，直到超出Python的递归深度限制。

解决方案 #

改用迭代方式构建嵌套结构，彻底避免递归问题：

def nest_dict(flat_dict):
    # 提取所有空值键作为嵌套层级（Python 3.7+字典保留插入顺序）
    nested_levels = [key for key, val in flat_dict.items() if val == ""]
    # 收集非空值的键值对作为内层数据
    inner_content = {key: val for key, val in flat_dict.items() if val != ""}
    
    # 逐层构建嵌套字典
    result = {}
    current_node = result
    for level_key in nested_levels:
        current_node[level_key] = {}
        current_node = current_node[level_key]
    # 将内层数据写入最底层节点
    current_node.update(inner_content)
    
    return result

# 测试
d = {"QR": "", "Customer Details": "", "feature prompt": "something", "chain": "lee", "store": "levis"}
print(nest_dict(d))

代码逻辑说明 #

1. 分离层级与数据：遍历扁平字典，将值为空的键单独存为嵌套层级列表，非空键值对存为内层内容字典。
2. 迭代构建嵌套结构：从空字典开始，依次创建每个层级的键对应的子字典，逐步移动到下一层级节点。
3. 填充内层数据：将非空键值对更新到最内层的字典中。

这种方式完全通过循环实现，没有递归调用，既避免了无限递归问题，又准确实现了预期的嵌套结构。

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