如何修复嵌套字典键名更新函数并实现通用化改造？

需求说明 #

基于嵌套的key_dict更新嵌套old_dict中的键名：当old_dict中的键与key_dict的顶层键匹配时，遍历该键下的所有子元素，按照key_dict内对应的映射规则替换子键名，同时支持key_dict中多个顶层键的批量处理。

示例数据 #

old_Dict = {
    'candela_samples_generic': {
        'drc_dtcs': {
            'domain_name': 'TEMPLATE-DOMAIN',
            'dtc_all': {
                '0x930001': {
                    'identification': {
                        'code': '0x9300',
                        'fault_type': '0x11',
                        'description': 'GNSS antenna short to ground'
                    },
                    'snapshots': {
                        'snapshot_record_content': 'base',
                        'snapshot_records_numbers': ['0x01']
                    },
                    'functional_conditions': {
                        'failure_name': 'short_to_ground',
                        'mnemonic': 'DTC_GNSS_Antenna_Short_to_ground'
                    }
                }
            }
        }
    }
}

key_dict = {
    'dtc_all': {
        'code': 'udsDtcValue',
        'failure_name': 'failname',
        'mnemonic': 'LongName',
        'fault_type': 'FaultType',
        'snapshot_records_numbers': 'snapshotrecordsnumbers'
    }
}

现有函数问题 #

原函数仅硬编码处理dtc_all键，且逻辑错误导致返回空字典：

def replace_keys(old_dict, key_dict):
    new_dict = {}

    if isinstance(old_dict, dict):
        for key, value in old_dict.items():
            if key == "dtc_all":
                for key in key.keys():
                    new_key = key_dict.get(key, key)
                    if isinstance(old_dict[key], dict):
                        new_dict[new_key] = replace_keys(old_dict[key], key_dict)
                    else:
                        new_dict[new_key] = old_dict[key]
        return new_dict

修复后的通用函数 #

def replace_keys(old_dict, key_dict):
    new_dict = {}
    if isinstance(old_dict, dict):
        for current_key, current_value in old_dict.items():
            # 先递归处理子元素，保证深层结构优先更新
            processed_value = replace_keys(current_value, key_dict)
            
            # 检查当前键是否是key_dict中的顶层目标键
            if current_key in key_dict:
                # 按映射规则替换子键名
                mapped_subdict = {}
                for subkey, subvalue in processed_value.items():
                    new_subkey = key_dict[current_key].get(subkey, subkey)
                    mapped_subdict[new_subkey] = subvalue
                new_dict[current_key] = mapped_subdict
            else:
                # 非目标键直接保留处理后的键值对
                new_dict[current_key] = processed_value
    elif isinstance(old_dict, list):
        # 处理列表中的嵌套元素
        new_dict = [replace_keys(item, key_dict) for item in old_dict]
    else:
        # 基础数据类型直接返回
        new_dict = old_dict
    return new_dict

验证结果 #

调用new_Dict = replace_keys(old_Dict, key_dict)后，得到期望输出：

{
    'candela_samples_generic': {
        'drc_dtcs': {
            'domain_name': 'TEMPLATE-DOMAIN',
            'dtc_all': {
                '0x930001': {
                    'identification': {
                        'udsDtcValue': '0x9300',
                        'FaultType': '0x11',
                        'description': 'GNSS antenna short to ground'
                    },
                    'snapshots': {
                        'snapshot_record_content': 'base',
                        'snapshotrecordsnumbers': ['0x01']
                    },
                    'functional_conditions': {
                        'failname': 'short_to_ground',
                        'LongName': 'DTC_GNSS_Antenna_Short_to_ground'
                    }
                }
            }
        }
    }
}

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