Python字典深度比较之如何高效寻找两个字典的相同点

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 20, 'c': 3, 'd': 4}

# 找出共同键
common_keys = dict1.keys() & dict2.keys()
print("共同键:", common_keys)  # {'b', 'c'}

# 找出dict1独有的键
unique_to_dict1 = dict1.keys() - dict2.keys()
print("dict1独有键:", unique_to_dict1)  # {'a'}

# 找出dict2独有的键
unique_to_dict2 = dict2.keys() - dict1.keys()
print("dict2独有键:", unique_to_dict2)  # {'d'}

# 找出完全相同的键值对
common_items = dict1.items() & dict2.items()
print("相同键值对:", common_items)  # {('c', 3)}

# 找出键相同但值不同的项
common_keys_diff_values = {
    k: (dict1[k], dict2[k])
    for k in dict1.keys() & dict2.keys()
    if dict1[k] != dict2[k]
}
print("键同值异:", common_keys_diff_values)  # {'b': (2, 20)}

# 找出共同值
common_values = set(dict1.values()) & set(dict2.values())
print("共同值:", common_values)  # {3}

# 值相同的键映射
value_key_map = {}
for value in common_values:
    keys1 = [k for k, v in dict1.items() if v == value]
    keys2 = [k for k, v in dict2.items() if v == value]
    value_key_map[value] = (keys1, keys2)

print("值相同键映射:", value_key_map)  # {3: (['c'], ['c'])}

def compare_nested_dicts(dict1, dict2, path=""):
    """递归比较嵌套字典"""
    diff = {}
    
    # 检查共同键
    common_keys = set(dict1.keys()) & set(dict2.keys())
    
    for key in common_keys:
        new_path = f"{path}.{key}" if path else key
        
        # 值都是字典则递归比较
        if isinstance(dict1[key], dict) and isinstance(dict2[key], dict):
            nested_diff = compare_nested_dicts(dict1[key], dict2[key], new_path)
            if nested_diff:
                diff[new_path] = nested_diff
        # 值相同则记录
        elif dict1[key] == dict2[key]:
            diff[new_path] = ("相同", dict1[key])
        # 值不同则记录差异
        else:
            diff[new_path] = ("不同", dict1[key], dict2[key])
    
    return diff

# 使用示例
config1 = {
    'database': {
        'host': 'db1.example.com',
        'port': 3306,
        'credentials': {
            'user': 'admin',
            'password': 'secret'
        }
    },
    'logging': {
        'level': 'info',
        'path': '/var/log'
    }
}

config2 = {
    'database': {
        'host': 'db2.example.com',
        'port': 3306,
        'credentials': {
            'user': 'admin',
            'password': 'newsecret'
        }
    },
    'logging': {
        'level': 'debug',
        'path': '/var/log'
    },
    'cache': {
        'enabled': true
    }
}

diff_report = compare_nested_dicts(config1, config2)
print("嵌套字典比较结果:")
import pprint
pprint.pprint(diff_report)

def advanced_dict_compare(dict1, dict2, 
                         key_comparator=none, 
                         value_comparator=none):
    """支持自定义比较器的字典比较"""
    # 默认比较器
    key_comparator = key_comparator or (lambda x, y: x == y)
    value_comparator = value_comparator or (lambda x, y: x == y)
    
    result = {
        'common_keys': [],
        'common_items': [],
        'key_diff': {
            'only_in_dict1': [],
            'only_in_dict2': []
        },
        'value_diff': []
    }
    
    # 键比较
    all_keys = set(dict1.keys()) | set(dict2.keys())
    for key in all_keys:
        if key in dict1 and key in dict2:
            result['common_keys'].append(key)
            
            # 值比较
            if value_comparator(dict1[key], dict2[key]):
                result['common_items'].append((key, dict1[key]))
            else:
                result['value_diff'].append((key, dict1[key], dict2[key]))
        elif key in dict1:
            result['key_diff']['only_in_dict1'].append(key)
        else:
            result['key_diff']['only_in_dict2'].append(key)
    
    return result

# 使用示例：浮点数容差比较
def float_compare(v1, v2, tolerance=1e-5):
    """浮点数容差比较"""
    if isinstance(v1, float) and isinstance(v2, float):
        return abs(v1 - v2) < tolerance
    return v1 == v2

dict1 = {'a': 1.0, 'b': 2.00001, 'c': 3}
dict2 = {'a': 1.000001, 'b': 2.0, 'd': 4}

comparison = advanced_dict_compare(
    dict1, dict2, 
    value_comparator=float_compare
)

print("容差比较结果:")
pprint.pprint(comparison)

def type_agnostic_compare(dict1, dict2):
    """类型无关的字典比较"""
    common_keys = set(dict1.keys()) & set(dict2.keys())
    
    same_items = {}
    diff_items = {}
    
    for key in common_keys:
        # 尝试类型转换后比较
        try:
            val1 = dict1[key]
            val2 = dict2[key]
            
            # 数值类型统一转float比较
            if isinstance(val1, (int, float)) and isinstance(val2, (int, float)):
                if float(val1) == float(val2):
                    same_items[key] = val1
                else:
                    diff_items[key] = (val1, val2)
            # 字符串类型统一转小写比较
            elif isinstance(val1, str) and isinstance(val2, str):
                if val1.lower() == val2.lower():
                    same_items[key] = val1
                else:
                    diff_items[key] = (val1, val2)
            # 其他类型直接比较
            elif val1 == val2:
                same_items[key] = val1
            else:
                diff_items[key] = (val1, val2)
        except exception:
            diff_items[key] = (dict1[key], dict2[key])
    
    return {
        'same_items': same_items,
        'diff_items': diff_items,
        'unique_to_dict1': set(dict1.keys()) - common_keys,
        'unique_to_dict2': set(dict2.keys()) - common_keys
    }

# 使用示例
dict1 = {'a': 'hello', 'b': 100, 'c': '2023-01-01'}
dict2 = {'a': 'hello', 'b': '100', 'c': '2023-01-01'}

result = type_agnostic_compare(dict1, dict2)
print("类型无关比较结果:")
pprint.pprint(result)

def efficient_large_dict_compare(dict1, dict2):
    """高效大型字典比较"""
    # 第一步：键比较（使用集合操作）
    keys1 = set(dict1.keys())
    keys2 = set(dict2.keys())
    
    common_keys = keys1 & keys2
    unique_keys1 = keys1 - keys2
    unique_keys2 = keys2 - keys1
    
    # 第二步：并行值比较
    from concurrent.futures import threadpoolexecutor
    
    same_items = {}
    diff_items = {}
    
    def compare_key(key):
        if dict1[key] == dict2[key]:
            return (key, true, dict1[key])
        else:
            return (key, false, (dict1[key], dict2[key]))
    
    with threadpoolexecutor() as executor:
        results = executor.map(compare_key, common_keys)
        
        for key, is_same, value in results:
            if is_same:
                same_items[key] = value
            else:
                diff_items[key] = value
    
    return {
        'same_items': same_items,
        'diff_items': diff_items,
        'unique_to_dict1': unique_keys1,
        'unique_to_dict2': unique_keys2
    }

# 生成大型字典
dict_large1 = {str(i): i for i in range(100000)}
dict_large2 = {str(i): i if i % 100 != 0 else i+1 for i in range(100000)}

# 比较大型字典
result = efficient_large_dict_compare(dict_large1, dict_large2)
print(f"相同项数量: {len(result['same_items'])}")
print(f"差异项数量: {len(result['diff_items'])}")

class dictcomparator:
    """惰性字典比较器"""
    
    def __init__(self, dict1, dict2):
        self.dict1 = dict1
        self.dict2 = dict2
        self._common_keys = none
        self._unique_keys1 = none
        self._unique_keys2 = none
    
    @property
    def common_keys(self):
        if self._common_keys is none:
            self._common_keys = set(self.dict1.keys()) & set(self.dict2.keys())
        return self._common_keys
    
    @property
    def unique_keys1(self):
        if self._unique_keys1 is none:
            self._unique_keys1 = set(self.dict1.keys()) - set(self.dict2.keys())
        return self._unique_keys1
    
    @property
    def unique_keys2(self):
        if self._unique_keys2 is none:
            self._unique_keys2 = set(self.dict2.keys()) - set(self.dict1.keys())
        return self._unique_keys2
    
    def get_common_items(self):
        """获取相同键值对"""
        return {
            k: self.dict1[k]
            for k in self.common_keys
            if self.dict1[k] == self.dict2[k]
        }
    
    def get_diff_items(self):
        """获取键同值异项"""
        return {
            k: (self.dict1[k], self.dict2[k])
            for k in self.common_keys
            if self.dict1[k] != self.dict2[k]
        }
    
    def find_keys_with_value(self, value):
        """查找具有特定值的键"""
        keys1 = [k for k, v in self.dict1.items() if v == value]
        keys2 = [k for k, v in self.dict2.items() if v == value]
        return keys1, keys2

# 使用示例
comparator = dictcomparator(dict1, dict2)
print("共同键:", comparator.common_keys)
print("相同键值对:", comparator.get_common_items())
print("值相同的键:", comparator.find_keys_with_value(3))

class configdiffanalyzer:
    """配置差异分析系统"""
    
    def __init__(self):
        self.config_history = {}
    
    def add_config_version(self, version, config):
        """添加配置版本"""
        self.config_history[version] = config
    
    def compare_versions(self, version1, version2):
        """比较两个配置版本"""
        if version1 not in self.config_history or version2 not in self.config_history:
            raise valueerror("配置版本不存在")
        
        config1 = self.config_history[version1]
        config2 = self.config_history[version2]
        
        return self._compare_dicts(config1, config2)
    
    def _compare_dicts(self, dict1, dict2, path=""):
        """递归比较字典"""
        diff = []
        
        # 检查所有键
        all_keys = set(dict1.keys()) | set(dict2.keys())
        
        for key in all_keys:
            new_path = f"{path}.{key}" if path else key
            
            if key in dict1 and key in dict2:
                # 值都是字典则递归比较
                if isinstance(dict1[key], dict) and isinstance(dict2[key], dict):
                    nested_diff = self._compare_dicts(dict1[key], dict2[key], new_path)
                    diff.extend(nested_diff)
                # 值相同
                elif dict1[key] == dict2[key]:
                    diff.append({
                        'path': new_path,
                        'status': '相同',
                        'value': dict1[key]
                    })
                # 值不同
                else:
                    diff.append({
                        'path': new_path,
                        'status': '修改',
                        'old_value': dict1[key],
                        'new_value': dict2[key]
                    })
            elif key in dict1:
                diff.append({
                    'path': new_path,
                    'status': '删除',
                    'old_value': dict1[key]
                })
            else:
                diff.append({
                    'path': new_path,
                    'status': '新增',
                    'new_value': dict2[key]
                })
        
        return diff
    
    def generate_diff_report(self, version1, version2):
        """生成差异报告"""
        diff = self.compare_versions(version1, version2)
        
        report = {
            'summary': {
                'added': 0,
                'deleted': 0,
                'modified': 0,
                'same': 0
            },
            'details': []
        }
        
        for item in diff:
            report['details'].append(item)
            if item['status'] == '新增':
                report['summary']['added'] += 1
            elif item['status'] == '删除':
                report['summary']['deleted'] += 1
            elif item['status'] == '修改':
                report['summary']['modified'] += 1
            else:
                report['summary']['same'] += 1
        
        return report

# 使用示例
config_system = configdiffanalyzer()

# 添加配置版本
config_system.add_config_version('v1.0', {
    'database': {'host': 'db1', 'port': 3306},
    'logging': {'level': 'info'}
})

config_system.add_config_version('v1.1', {
    'database': {'host': 'db2', 'port': 3306},
    'logging': {'level': 'debug'},
    'cache': {'enabled': true}
})

# 生成差异报告
report = config_system.generate_diff_report('v1.0', 'v1.1')
print("配置差异报告:")
pprint.pprint(report)

class datasyncengine:
    """基于字典比较的数据同步引擎"""
    
    def __init__(self):
        self.source_data = {}
        self.target_data = {}
    
    def load_source(self, data):
        """加载源数据"""
        self.source_data = data
    
    def load_target(self, data):
        """加载目标数据"""
        self.target_data = data
    
    def generate_sync_operations(self):
        """生成同步操作"""
        # 键比较
        source_keys = set(self.source_data.keys())
        target_keys = set(self.target_data.keys())
        
        common_keys = source_keys & target_keys
        keys_to_add = source_keys - target_keys
        keys_to_delete = target_keys - source_keys
        
        # 生成操作列表
        operations = []
        
        # 添加操作
        for key in keys_to_add:
            operations.append(('add', key, self.source_data[key]))
        
        # 删除操作
        for key in keys_to_delete:
            operations.append(('delete', key))
        
        # 更新操作
        for key in common_keys:
            if self.source_data[key] != self.target_data[key]:
                operations.append(('update', key, self.source_data[key]))
        
        return operations
    
    def execute_sync(self):
        """执行同步操作"""
        operations = self.generate_sync_operations()
        
        for op in operations:
            if op[0] == 'add':
                self.target_data[op[1]] = op[2]
            elif op[0] == 'delete':
                del self.target_data[op[1]]
            elif op[0] == 'update':
                self.target_data[op[1]] = op[2]
        
        return self.target_data

# 使用示例
sync_engine = datasyncengine()

# 加载数据
source = {'a': 1, 'b': 2, 'c': 3}
target = {'b': 20, 'c': 3, 'd': 4}

sync_engine.load_source(source)
sync_engine.load_target(target)

# 生成同步操作
operations = sync_engine.generate_sync_operations()
print("同步操作序列:")
for op in operations:
    print(op)

# 执行同步
synced_data = sync_engine.execute_sync()
print("同步后数据:", synced_data)

class apiresponsevalidator:
    """api响应验证系统"""
    
    def __init__(self):
        self.expected_response = none
        self.tolerance = 0.01  # 数值容差
    
    def set_expected_response(self, response):
        """设置预期响应"""
        self.expected_response = response
    
    def validate_response(self, actual_response):
        """验证实际响应"""
        if self.expected_response is none:
            raise valueerror("未设置预期响应")
        
        return self._compare_dicts(self.expected_response, actual_response)
    
    def _compare_dicts(self, expected, actual, path=""):
        """递归比较字典"""
        errors = []
        
        # 检查所有键
        expected_keys = set(expected.keys())
        actual_keys = set(actual.keys())
        
        # 缺失键
        missing_keys = expected_keys - actual_keys
        for key in missing_keys:
            errors.append({
                'path': f"{path}.{key}" if path else key,
                'error': '字段缺失',
                'expected': expected[key]
            })
        
        # 多余键
        extra_keys = actual_keys - expected_keys
        for key in extra_keys:
            errors.append({
                'path': f"{path}.{key}" if path else key,
                'error': '多余字段',
                'actual': actual[key]
            })
        
        # 共同键比较
        common_keys = expected_keys & actual_keys
        for key in common_keys:
            new_path = f"{path}.{key}" if path else key
            exp_val = expected[key]
            act_val = actual[key]
            
            # 嵌套字典递归比较
            if isinstance(exp_val, dict) and isinstance(act_val, dict):
                nested_errors = self._compare_dicts(exp_val, act_val, new_path)
                errors.extend(nested_errors)
            # 列表比较
            elif isinstance(exp_val, list) and isinstance(act_val, list):
                if len(exp_val) != len(act_val):
                    errors.append({
                        'path': new_path,
                        'error': '列表长度不同',
                        'expected': len(exp_val),
                        'actual': len(act_val)
                    })
                else:
                    for i, (exp_item, act_item) in enumerate(zip(exp_val, act_val)):
                        if isinstance(exp_item, dict) and isinstance(act_item, dict):
                            nested_errors = self._compare_dicts(
                                exp_item, act_item, f"{new_path}[{i}]"
                            )
                            errors.extend(nested_errors)
                        elif exp_item != act_item:
                            errors.append({
                                'path': f"{new_path}[{i}]",
                                'error': '值不同',
                                'expected': exp_item,
                                'actual': act_item
                            })
            # 数值容差比较
            elif isinstance(exp_val, (int, float)) and isinstance(act_val, (int, float)):
                if abs(exp_val - act_val) > self.tolerance:
                    errors.append({
                        'path': new_path,
                        'error': '数值超出容差',
                        'expected': exp_val,
                        'actual': act_val,
                        'difference': abs(exp_val - act_val)
                    })
            # 其他类型直接比较
            elif exp_val != act_val:
                errors.append({
                    'path': new_path,
                    'error': '值不同',
                    'expected': exp_val,
                    'actual': act_val
                })
        
        return errors

# 使用示例
validator = apiresponsevalidator()

# 设置预期响应
expected = {
    'status': 'success',
    'code': 200,
    'data': {
        'user': {
            'id': 123,
            'name': 'alice',
            'scores': [85, 90, 78]
        }
    }
}

validator.set_expected_response(expected)

# 实际响应
actual = {
    'status': 'success',
    'code': 200,
    'data': {
        'user': {
            'id': 123,
            'name': 'alice smith',  # 名字不同
            'scores': [85, 90.1, 78]  # 数值有微小差异
        }
    },
    'timestamp': '2023-08-15'  # 多余字段
}

# 验证响应
errors = validator.validate_response(actual)
print("api响应错误:")
for error in errors:
    print(f"- [{error['path']}]: {error['error']}")
    if 'expected' in error and 'actual' in error:
        print(f"  预期: {error['expected']}, 实际: {error['actual']}")

def safe_dict_compare(dict1, dict2):
    """带错误处理的字典比较"""
    try:
        # 键比较
        common_keys = set(dict1.keys()) & set(dict2.keys())
        
        # 值比较
        same_items = {}
        diff_items = {}
        
        for key in common_keys:
            try:
                if dict1[key] == dict2[key]:
                    same_items[key] = dict1[key]
                else:
                    diff_items[key] = (dict1[key], dict2[key])
            except exception as e:
                # 记录比较错误
                diff_items[key] = f"比较错误: {str(e)}"
        
        return {
            'same_items': same_items,
            'diff_items': diff_items,
            'unique_to_dict1': set(dict1.keys()) - common_keys,
            'unique_to_dict2': set(dict2.keys()) - common_keys
        }
    except exception as e:
        # 返回错误信息
        return {
            'error': f"字典比较失败: {str(e)}",
            'exception_type': type(e).__name__
        }

# 使用示例
dict_with_error = {'a': 1, 'b': object()}  # 不可比较对象
result = safe_dict_compare({'a': 1, 'b': 2}, {'a': 1, 'b': dict_with_error})
print("安全比较结果:")
pprint.pprint(result)