Python：比较不同类型的对象是否相等时引发错误

Question

As far as I understand, in Python, comparing the instances of two different classes for equality, does:

• evaluate the __eq__ method of the first instance and return the result
• Except if the result is NotImplemented , then evaluate the __eq__ method of the second instance and return the result
• Except if the result is NotImplemented , then compare for object identity and return the result (which is False)

I encountered multiple times situations where a raised Exception would have helped me to spot a bug in my code. Martijn Pieters has sketched in this post a way to do that, but also mentioned that it's unpythonic.

Besides being unpythonic, are there actual problems arising from this approach?

Answer 1

Strictly speaking, it is, of course, "unpythonic" because Python encourages duck typing alongside strict subtyping. But I personally prefer strictly typed interfaces, so I throw TypeError s. Never had any issues, but I can't difinitively say that you will never have any.

Theoretically, I can imagine it being a problem if you find yourself in need to use a mixed-type container like list[Optional[YourType]] and then compare its elements, maybe indirectly, like in constructing set(your_mixed_list) .

Answer 2

It would cause problems for dictionaries with mixed keys that have the same hash. Dictionaries allow several keys to have the same hash, and then do an equality check to distinguish keys. See https://stackoverflow.com/a/9022835/1217284

The following script demonstrates this, it fails when the class Misbehaving1 is used:

#!/usr/bin/env python3

class Behaving1:
    def __init__(self, value):
        self.value = value
    def __hash__(self):
        return 7

class Behaving2:
    def __init__(self, value):
        self.value = value
    def __hash__(self):
        return 7
    def __eq__(self, other):
        if not (isinstance(other, type(self)) or isinstance(self, type(other))):
            return NotImplemented
        return self.value == other.value


class MisBehaving1:
    def __init__(self, value):
        self.value = value
    def __hash__(self):
        return 7
    def __eq__(self, other):
        if not (isinstance(other, type(self)) or isinstance(self, type(other))):
            raise TypeError(f"Cannot compare {self} of type {type(self)} with {other} of type {type(other)}")
        return self.value == other.value


d = {Behaving1(5): 'hello', Behaving2(4): 'world'}
print(d)

dd = {Behaving1(5): 'hello', MisBehaving1(4): 'world'}
print(dd)