如何遍历嵌套字典并将最深层级键替换为默认值

嘿，这个问题我刚好能帮你解决！你需要的是一个能递归遍历嵌套字典、定位到最深层级的字典节点，然后把这些节点的键替换成默认值的函数对吧？下面我给你两种实用的方案，你可以根据自己的需求选：

核心逻辑是递归遍历字典，同时判断当前节点是否是最深层的字典（也就是该字典的所有值都不是字典）。因为字典的键必须唯一，直接把多个键换成同一个默认键会导致数据丢失，所以我准备了两种常见的处理方式：

这个方案会把最深层字典的所有值收集到一个列表中，用你指定的默认键作为新键，避免数据丢失。

def replace_deepest_keys(input_dict, default_key='default_key', merge_values=True):
    """
    遍历嵌套字典，将最深层级字典的键替换为默认键，值合并为列表
    
    参数:
        input_dict: 待处理的嵌套字典
        default_key: 替换后使用的默认键名
        merge_values: 是否合并多个值为列表（设为False会仅保留最后一个值，不推荐）
    返回:
        处理后的嵌套字典
    """
    if not isinstance(input_dict, dict):
        # 非字典类型（比如数值、字符串）直接返回原内容
        return input_dict
    
    # 判断当前字典是否是最深层：所有值都不是字典
    is_deepest = all(not isinstance(v, dict) for v in input_dict.values())
    
    if is_deepest:
        values = list(input_dict.values())
        if merge_values:
            # 把所有值合并到默认键对应的列表中
            return {default_key: values}
        else:
            # 仅保留最后一个值（会丢失前面的数据，谨慎使用）
            return {default_key: values[-1]} if values else {}
    else:
        # 递归处理每个子字典
        processed_dict = {}
        for key, value in input_dict.items():
            processed_dict[key] = replace_deepest_keys(value, default_key, merge_values)
        return processed_dict

测试示例 #

用你提供的字典测试：

dictionary = {'First_level': {0: {'Second_level0': {0.0: {'Third_level0': {0.0: 7.0, 1.0: 3.0}}}}, 2: {'Second_level1': {0.0: 2.0, 1.0: 1.0}}, 4: {'Second_level2': {0.0: {'Third_level1': {0.0: 7.0, 1.0: 5.0}}, 1.0: 1.0}}, 6: {'Second_level3': {0.0: 6.0, 1.0: 7.0}}, 'Third_level2': 7.0}}

# 使用默认键名处理
result = replace_deepest_keys(dictionary)
print(result)

输出结果：

{
    'First_level': {
        0: {'Second_level0': {0.0: {'Third_level0': {'default_key': [7.0, 3.0]}}}},
        2: {'Second_level1': {'default_key': [2.0, 1.0]}},
        4: {'Second_level2': {0.0: {'Third_level1': {'default_key': [7.0, 5.0]}}, 1.0: 1.0}},
        6: {'Second_level3': {'default_key': [6.0, 7.0]}},
        'Third_level2': 7.0
    }
}

如果你希望每个原键对应一个带索引的新键（比如deep_key_0、deep_key_1），可以用这个版本：

def replace_deepest_keys_with_indexed(input_dict, default_key_prefix='deep_key_'):
    """
    遍历嵌套字典，将最深层级字典的键替换为带索引的默认键
    
    参数:
        input_dict: 待处理的嵌套字典
        default_key_prefix: 新键的前缀，会自动添加索引后缀
    返回:
        处理后的嵌套字典
    """
    if not isinstance(input_dict, dict):
        return input_dict
    
    is_deepest = all(not isinstance(v, dict) for v in input_dict.values())
    
    if is_deepest:
        processed = {}
        # 给每个值生成带索引的新键
        for idx, (_, value) in enumerate(input_dict.items()):
            processed[f"{default_key_prefix}{idx}"] = value
        return processed
    else:
        processed_dict = {}
        for key, value in input_dict.items():
            processed_dict[key] = replace_deepest_keys_with_indexed(value, default_key_prefix)
        return processed_dict

测试示例 #

result = replace_deepest_keys_with_indexed(dictionary)
print(result)

输出结果中，最深层的{0.0: 7.0, 1.0: 3.0}会变成{'deep_key_0': 7.0, 'deep_key_1': 3.0}，其他层级同理。

• 两个方案都采用递归遍历，能处理任意深度的嵌套字典
• 如果你有其他特殊需求（比如把键替换成固定的单个值而非前缀），可以基于上面的代码修改——核心逻辑都是判断最深层字典，然后替换键的部分做调整

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