如何在Python类层级结构中正确实现__eq__方法？

假设我们有如下类结构：父类Person包含name属性，子类Student继承自Person并新增student_id属性：

class Person:
    """A person with a name."""

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

    def __eq__(self, other):
        if not isinstance(other, type(self)):
            return NotImplemented
        return self.name == other.name

    def __repr__(self):
        return f'Person("{self.name}")'


class Student(Person):
    """A student with a name and a student id."""

    def __init__(self, name, student_id):
        super().__init__(name)
        self.student_id = student_id

    def __repr__(self):
        return f'Student("{self.name}", {self.student_id})'

当前实现的问题 #

当前Person类的__eq__用isinstance(other, type(self))判断类型兼容性，运行以下代码会得到不符合预期的结果：

p = Person("SomeName")
s = Student("SomeName", 1)
print(p == s)  # 输出True

背后的执行逻辑是：

1. 首先调用s.__eq__(p)，但Person不是Student的子类，返回NotImplemented
2. Python自动尝试调用p.__eq__(s)，由于Student是Person的子类，且二者name属性相同，因此返回True

但多数场景下，Student比Person多了student_id属性，语义上属于更具体的概念，不应该和父类实例判定为相等。

两种核心实现思路 #

1. 严格类型匹配：仅同类型实例可相等 #

如果要求只有类型完全相同的实例才可能相等，将__eq__中的类型判断改为type(self) == type(other)：

class Person:
    # 其他方法不变
    def __eq__(self, other):
        if type(self) != type(other):
            return NotImplemented
        return self.name == other.name

此时p == s会返回False，因为类型不同，==运算符退化为判断对象标识。

这种方式语义清晰，但子类无法直接继承父类的__eq__，必须重写以扩展逻辑：

class Student(Person):
    # 其他方法不变
    def __eq__(self, other):
        if type(self) != type(other):
            return NotImplemented
        # 先复用父类的相等判断，再比较子类独有的属性
        return super().__eq__(other) and self.student_id == other.student_id

2. 兼容子类的宽松匹配（需谨慎使用） #

如果业务场景确实允许父类和子类实例在核心属性一致时相等，可保留isinstance判断，但必须让子类重写__eq__以保证对称性：

class Student(Person):
    # 其他方法不变
    def __eq__(self, other):
        if isinstance(other, Student):
            return super().__eq__(other) and self.student_id == other.student_id
        # 针对父类实例，转由父类的__eq__处理，保证对称性
        elif isinstance(other, Person):
            return other.__eq__(self)
        return NotImplemented

修改后p == s和s == p都会返回True，维持了相等运算符的对称性，但这种方式需要严格匹配业务语义，避免逻辑混淆。

通用实现范式 #

无论选择哪种方式，都应遵循以下原则：

• 保证对称性：若a == b为True，则b == a必须也为True
• 明确类型规则：提前确定是严格匹配类型，还是允许子类与父类兼容
• 子类扩展逻辑：子类重写__eq__时，先调用父类的判断逻辑，再补充子类独有的属性比较
• 返回NotImplemented：类型不匹配时返回NotImplemented，让Python尝试对方的__eq__方法，维持运算符的一致性

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