Python：基于嵌套字典递归生成指定结构列表的问询

首先明确核心规则：

• 全量列表通过深度优先遍历生成，每个非叶子节点的子键按逆序排列后加入列表；
• 输入特定键时，结果列表长度与全量列表一致，仅保留目标键路径上的节点对应位置的内容，其余位置填None。

步骤1：生成全量模板与节点映射 #

先遍历嵌套字典，生成全量结果列表，同时记录每个列表项对应的父节点及原父节点的子键列表，用于后续匹配路径。

def build_full_template(nested_dict):
    template = []
    node_info = []  # 每个元素为 (父节点键, 父节点的原始子键列表)

    def dfs(current_dict, parent_key):
        current_keys = list(current_dict.keys())
        if current_keys:
            # 子键逆序后加入模板
            reversed_keys = sorted(current_keys, reverse=True)
            template.append(reversed_keys)
            node_info.append((parent_key, current_keys))
            # 按原始顺序递归处理每个子键
            for key in current_keys:
                dfs(current_dict[key], key)

    # 处理顶层节点
    top_keys = list(nested_dict.keys())
    if top_keys:
        template.append(top_keys)
        node_info.append((None, top_keys))
        for key in top_keys:
            dfs(nested_dict[key], key)
    return template, node_info

步骤2：查找目标键的完整路径 #

通过深度优先遍历，从顶层开始向下查找目标键，记录从顶层到目标键的所有节点组成的路径。

def find_key_path(nested_dict, target_key):
    def dfs(current_dict, current_path):
        for key, value in current_dict.items():
            new_path = current_path + [key]
            if key == target_key:
                return new_path
            if isinstance(value, dict) and value:
                result = dfs(value, new_path)
                if result:
                    return result
        return None
    return dfs(nested_dict, [])

步骤3：生成目标结果列表 #

根据全量模板和目标键路径，匹配每个列表项对应的节点，生成符合要求的结果。

def generate_target_list(nested_dict, target_key):
    template, node_info = build_full_template(nested_dict)
    path = find_key_path(nested_dict, target_key)
    
    if not path:
        return [None] * len(template)
    
    result = []
    for parent_key, child_keys in node_info:
        if parent_key is None:
            # 顶层节点，仅保留路径中的顶层键
            result.append([path[0]])
        elif parent_key not in path:
            result.append(None)
        else:
            path_idx = path.index(parent_key)
            if path_idx + 1 >= len(path):
                # 父节点是路径最后一个节点，无后续键，填None
                result.append(None)
            else:
                next_key = path[path_idx + 1]
                result.append([next_key] if next_key in child_keys else None)
    return result

对疑问的解答 #

1. 如何追溯键的路径：
   不需要向上递归，而是通过向下深度优先遍历实现。每进入一个子字典，就将当前键加入路径，找到目标键时直接返回完整路径（从顶层到目标键的顺序），这种方式更贴合嵌套字典的层级结构。

2. 如何存储递归信息生成列表：
   分两次存储关键信息：

   • 第一次遍历生成全量模板和节点映射，记录每个列表项对应的父节点及原始子键列表，确定结果的长度和每个位置的节点关系；
   • 第二次根据目标键的路径，匹配节点映射中的每个位置，判断是否需要填入对应内容，最终生成结果列表。

测试示例 #

使用你提供的嵌套字典：

nested_dict = {
    "1": {
        "1.1": {"1.1.1": {}},
        "1.2": {"1.2.1": {}}
    },
    "2": {
        "2.1": {"2.1.1": {}},
        "2.2": {"2.2.2": {}}
    }
}

print(generate_target_list(nested_dict, '2.2.2'))
# 输出: [['2'], None, None, None, ['2.2'], None, ['2.2.2']]

print(generate_target_list(nested_dict, '1.1'))
# 输出: [['1'], ['1.1'], None, None, None, None, None]

print(generate_target_list(nested_dict, '1.2.1'))
# 输出: [['1'], ['1.2'], None, ['1.2.1'], None, None, None]

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