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獨(dú)有的鍵
unique_to_dict1 = dict1.keys() - dict2.keys()
print("dict1獨(dú)有鍵:", unique_to_dict1)  # {'a'}

# 找出dict2獨(dú)有的鍵
unique_to_dict2 = dict2.keys() - dict1.keys()
print("dict2獨(dú)有鍵:", 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("嵌套字典比較結(jié)果:")
import pprint
pprint.pprint(diff_report)

def advanced_dict_compare(dict1, dict2, 
                         key_comparator=None, 
                         value_comparator=None):
    """支持自定義比較器的字典比較"""
    # 默認(rèn)比較器
    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

# 使用示例：浮點(diǎn)數(shù)容差比較
def float_compare(v1, v2, tolerance=1e-5):
    """浮點(diǎn)數(shù)容差比較"""
    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("容差比較結(jié)果:")
pprint.pprint(comparison)

def type_agnostic_compare(dict1, dict2):
    """類型無關(guān)的字典比較"""
    common_keys = set(dict1.keys()) & set(dict2.keys())
    
    same_items = {}
    diff_items = {}
    
    for key in common_keys:
        # 嘗試類型轉(zhuǎn)換后比較
        try:
            val1 = dict1[key]
            val2 = dict2[key]
            
            # 數(shù)值類型統(tǒng)一轉(zhuǎn)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)
            # 字符串類型統(tǒng)一轉(zhuǎn)小寫比較
            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("類型無關(guān)比較結(jié)果:")
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"相同項數(shù)量: {len(result['same_items'])}")
print(f"差異項數(shù)量: {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:
    """配置差異分析系統(tǒng)"""
    
    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:
    """基于字典比較的數(shù)據(jù)同步引擎"""
    
    def __init__(self):
        self.source_data = {}
        self.target_data = {}
    
    def load_source(self, data):
        """加載源數(shù)據(jù)"""
        self.source_data = data
    
    def load_target(self, data):
        """加載目標(biāo)數(shù)據(jù)"""
        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):
        """執(zhí)行同步操作"""
        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()

# 加載數(shù)據(jù)
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)

# 執(zhí)行同步
synced_data = sync_engine.execute_sync()
print("同步后數(shù)據(jù):", synced_data)

class APIResponseValidator:
    """API響應(yīng)驗證系統(tǒng)"""
    
    def __init__(self):
        self.expected_response = None
        self.tolerance = 0.01  # 數(shù)值容差
    
    def set_expected_response(self, response):
        """設(shè)置預(yù)期響應(yīng)"""
        self.expected_response = response
    
    def validate_response(self, actual_response):
        """驗證實(shí)際響應(yīng)"""
        if self.expected_response is None:
            raise ValueError("未設(shè)置預(yù)期響應(yīng)")
        
        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
                            })
            # 數(shù)值容差比較
            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': '數(shù)值超出容差',
                        '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()

# 設(shè)置預(yù)期響應(yīng)
expected = {
    'status': 'success',
    'code': 200,
    'data': {
        'user': {
            'id': 123,
            'name': 'Alice',
            'scores': [85, 90, 78]
        }
    }
}

validator.set_expected_response(expected)

# 實(shí)際響應(yīng)
actual = {
    'status': 'success',
    'code': 200,
    'data': {
        'user': {
            'id': 123,
            'name': 'Alice Smith',  # 名字不同
            'scores': [85, 90.1, 78]  # 數(shù)值有微小差異
        }
    },
    'timestamp': '2023-08-15'  # 多余字段
}

# 驗證響應(yīng)
errors = validator.validate_response(actual)
print("API響應(yīng)錯誤:")
for error in errors:
    print(f"- [{error['path']}]: {error['error']}")
    if 'expected' in error and 'actual' in error:
        print(f"  預(yù)期: {error['expected']}, 實(shí)際: {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("安全比較結(jié)果:")
pprint.pprint(result)