为何字节完全一致的对象会导致unittest的assertEqual断言失败？

这种情况真的太让人头疼了——明明肉眼瞅着完全一致，类型也对得上，但unittest就是硬报不相等，还找不到半点儿差异痕迹。我之前也踩过一模一样的坑，大概率是自定义对象的相等性判断逻辑在搞鬼，而非真的存在差异。下面给你梳理几个排查方向和解决办法：

1. 自定义类未实现__eq__方法 #

Python里的对象默认是通过内存地址来判断相等性的（也就是is关键字的逻辑），如果你的SomeClass和SomeOtherClass没有重写__eq__方法，哪怕两个实例的所有属性都完全相同，它们也会被判定为不相等。比如：

# 没有__eq__的情况，两个实例永远不相等
class SomeClass:
    def __init__(self, value):
        self.value = value

a = SomeClass(10)
b = SomeClass(10)
print(a == b)  # 输出: False

解决办法：给所有自定义类添加__eq__方法，明确指定相等性判断规则：

class SomeClass:
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        # 先判断类型是否一致
        if not isinstance(other, SomeClass):
            return False
        # 再比较所有关键属性
        return self.value == other.value

class SomeOtherClass:
    def __init__(self, name):
        self.name = name

    def __eq__(self, other):
        if not isinstance(other, SomeOtherClass):
            return False
        return self.name == other.name

注意：如果类里有嵌套的自定义对象，嵌套类也需要实现__eq__，否则还是会出现判断不一致的问题。

2. 手动递归打印对象细节，揪出隐藏差异 #

有时候unittest的默认差异输出太简略，尤其是对象体积大的时候根本没用。可以写个辅助函数，递归打印对象的所有属性和值，对比细节：

def get_obj_details(obj, prefix="", return_str=False):
    result = []
    if isinstance(obj, dict):
        result.append(f"{prefix}Dict:")
        for k, v in obj.items():
            result.append(f"{prefix}  Key:")
            result.extend(get_obj_details(k, prefix + "    ", return_str=True))
            result.append(f"{prefix}  Value:")
            result.extend(get_obj_details(v, prefix + "    ", return_str=True))
    elif hasattr(obj, "__dict__"):
        result.append(f"{prefix}Instance of {type(obj).__name__}:")
        for attr, value in obj.__dict__.items():
            result.append(f"{prefix}  {attr}:")
            result.extend(get_obj_details(value, prefix + "    ", return_str=True))
    else:
        result.append(f"{prefix}{repr(obj)} (type: {type(obj).__name__})")
    
    if return_str:
        return result
    print("\n".join(result))

# 调用对比两个字典的细节
print("=== 第一个字典详情 ===")
get_obj_details(first_dict)
print("\n=== 第二个字典详情 ===")
get_obj_details(second_dict)

这种方法能帮你发现很多肉眼忽略的细节：比如浮点数精度差异、隐藏的私有属性、动态生成的属性值等。

3. 检查哈希方法（如果对象作为字典键） #

如果你的自定义类是字典的键，除了__eq__，还需要实现__hash__方法（规则要和__eq__匹配），否则可能出现哈希冲突，导致字典的相等性判断异常。比如：

class SomeClass:
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        if not isinstance(other, SomeClass):
            return False
        return self.value == other.value

    def __hash__(self):
        # 基于参与相等性判断的属性生成哈希值
        return hash(self.value)

4. 增强unittest的断言输出 #

如果默认的断言信息不够用，可以自定义断言消息，把对象细节直接放到错误提示里：

def obj_details_to_str(obj):
    return "\n".join(get_obj_details(obj, return_str=True))

self.assertEqual(
    first_dict, 
    second_dict, 
    msg=f"字典不匹配！\n\n第一个字典详情:\n{obj_details_to_str(first_dict)}\n\n第二个字典详情:\n{obj_details_to_str(second_dict)}"
)

最后总结 #

90%的概率是自定义类没实现__eq__导致的，先从这个方向排查。如果还是找不到问题，用递归打印细节的方法，绝对能揪出那些藏得很深的差异点。

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