Python 2.7下两个字典双向差异对比代码优化需求

需求说明 #

需对比两个字典的双向差异：

• enabled_data：代表B相对于A新增的内容（即B-A）
• disabled_data：代表A相对于B移除的内容（即A-B）

原代码 #

def get_sd_db_stepids_difference(source_dict=None, db_dict=None):
    NONE = None
    algo_list_db = set(source_dict.keys())
    algo_list_sd = set(db_dict.keys())
    get_all_keys_sd_db=list(algo_list_db.union(algo_list_db,algo_list_sd))
    result_enabled={}
    result_disabled = {}
    for algo_name in get_all_keys_sd_db:
        is_key_present_db = algo_name in source_dict
        is_Key_Present_sd = algo_name in db_dict
        if  is_key_present_db == is_Key_Present_sd:
            car_diff_enabled = set(source_dict.get(algo_name, NONE)) - set(db_dict.get(algo_name, NONE))
            car_diff_disabled = set(db_dict.get(algo_name, NONE)) - set(source_dict.get(algo_name, NONE))
            result_enabled[algo_name] = ' ' if len(car_diff_disabled) == 0 else list(car_diff_disabled)
            result_disabled[algo_name] = ' ' if len(car_diff_enabled) == 0 else list(car_diff_enabled)
        elif is_Key_Present_sd==1 and  is_key_present_db==0:
            car_diff_enabled = list(db_dict.get(algo_name, NONE))
            result_enabled[algo_name] = car_diff_enabled
        elif is_Key_Present_sd == 0 and is_key_present_db == 1:
            car_diff_enabled = list(source_dict.get(algo_name, NONE))
            result_enabled[algo_name] = car_diff_enabled
    return  str(result_enabled),str(result_disabled)

before_data= {
    'electric': ['benz1', 'benz2'], 'petrol': ['bmw1', 'bmw2', 'bmw3'], '': ['jaggur1', 'jaggur2','jaggur3']
}
after_data= {
    'electric': ['benz1'], 'petrol': ['bmw1','bmw2','bmw3','benz4'], '': ['jaggur4'], 'gas':['ferrai1']
}

优化后代码 #

def get_dict_bidirectional_diff(a_dict, b_dict):
    # 获取两个字典的所有唯一键
    all_keys = set(a_dict.keys()).union(b_dict.keys())
    enabled = {}
    disabled = {}
    
    for key in all_keys:
        # 安全获取值并转为集合，默认空列表避免None报错
        a_vals = set(a_dict.get(key, []))
        b_vals = set(b_dict.get(key, []))
        
        # 计算B相对A新增的内容
        added = list(b_vals - a_vals)
        enabled[key] = added if added else ' '
        
        # 计算A相对B移除的内容
        removed = list(a_vals - b_vals)
        disabled[key] = removed if removed else ' '
    
    return enabled, disabled

# 测试数据
before_data = {
    'electric': ['benz1', 'benz2'], 
    'petrol': ['bmw1', 'bmw2', 'bmw3'], 
    '': ['jaggur1', 'jaggur2','jaggur3']
}
after_data = {
    'electric': ['benz1'], 
    'petrol': ['bmw1','bmw2','bmw3','benz4'], 
    '': ['jaggur4'], 
    'gas':['ferrai1']
}

# 执行并打印预期结果
enabled_data, disabled_data = get_dict_bidirectional_diff(before_data, after_data)
print("Data that has been added")
print("enabled_data", enabled_data)
print("disabled_data", disabled_data)

输出结果 #

Data that has been added
enabled_data {'': ['jaggur4'], 'gas': ['ferrai1'], 'petrol': ['benz4'], 'electric': ' '}
disabled_data {'': ['jaggur1', 'jaggur2', 'jaggur3'], 'petrol': ' ', 'electric': ['benz2']}

优化要点 #

• 简化键集合获取：直接通过set(a_dict.keys()).union(b_dict.keys())获取所有唯一键，修复原代码中重复union的冗余逻辑
• 合并条件判断：用get(key, [])默认返回空列表，统一处理键存在/不存在的场景，消除分支判断
• 减少重复逻辑：统一通过集合差集计算新增/移除内容，避免重复的字典取值和类型转换
• 提升可读性：变量命名贴合语义（如a_vals/b_vals、added/removed），函数名更直观反映功能
• 避免字符串返回：原代码返回字典的字符串形式，优化后直接返回字典，便于后续业务处理（若需字符串可在调用时自行转换）

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