Что делает пользовательский класс нехешируемым?

Просто присвоить методу __hash__ метод класса tuple недостаточно. На самом деле вы не сказали, как хэшировать по-другому. кортежи можно хэшировать, потому что они неизменяемы. Если вы действительно хотите, чтобы ваш конкретный пример работал, это может быть так:

class X2(list):
    def __hash__(self):
        return hash(tuple(self))

В этом случае вы фактически определяете, как хешировать свой собственный подкласс списка. Вам просто нужно точно определить, как он может генерировать хэш. Вы можете хешировать все, что хотите, в отличие от использования метода хеширования кортежа:

def __hash__(self):
    return hash("foobar"*len(self))

Из документов Python3:

Если класс не определяет метод __eq__(), он также не должен определять операцию __hash__(); если он определяет __eq__(), но не __hash__(), его экземпляры нельзя будет использовать в качестве элементов в хешируемых коллекциях. Если класс определяет изменяемые объекты и реализует метод __eq__(), он не должен реализовывать __hash__(), так как реализация хешируемых коллекций требует, чтобы хеш-значение ключа было неизменным (если хеш-значение объекта изменится, оно будет неправильным). ведро хэша).

Ссылка: object.__hash__(self)

Образец кода:

class Hashable:
    pass

class Unhashable:
    def __eq__(self, other):
        return (self == other)

class HashableAgain:
    def __eq__(self, other):
        return (self == other)

    def __hash__(self):
        return id(self)

def main():
    # OK
    print(hash(Hashable()))
    # Throws: TypeError("unhashable type: 'X'",)
    print(hash(Unhashable()))  
    # OK
    print(hash(HashableAgain()))

Что вы могли бы и должны сделать, исходя из вашего другого вопроса, так это: ничего не подклассифицировать, просто инкапсулировать кортеж. Это совершенно нормально сделать в файле init.

class X(object):
    def __init__(self, *args):
        self.tpl = args
    def __hash__(self):
        return hash(self.tpl)
    def __eq__(self, other):
        return self.tpl == other
    def __repr__(self):
        return repr(self.tpl)

x1 = X()
s = {x1}

который дает:

>>> s
set([()])
>>> x1
()

Если вы не изменяете экземпляры X после создания, почему вы не создаете подкласс кортежа?

Но я укажу, что на самом деле это не вызывает ошибки, по крайней мере, в Python 2.6.

>>> class X(list):
...     __hash__ = tuple.__hash__
...     __eq__ = tuple.__eq__
... 
>>> x = X()
>>> s = set((x,))
>>> s
set([[]])

Я не решаюсь сказать «работает», потому что это не делает то, что вы думаете.

>>> a = X()
>>> b = X((5,))
>>> hash(a)
4299954584
>>> hash(b)
4299954672
>>> id(a)
4299954584
>>> id(b)
4299954672

Он просто использует идентификатор объекта в качестве хэша. Когда вы на самом деле вызываете __hash__, вы все равно получаете сообщение об ошибке; аналогично для __eq__.

>>> a.__hash__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: descriptor '__hash__' for 'tuple' objects doesn't apply to 'X' object
>>> X().__eq__(X())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: descriptor '__eq__' for 'tuple' objects doesn't apply to 'X' object

Я понимаю, что внутренние компоненты Python по какой-то причине обнаруживают, что X имеет методы __hash__ и __eq__, но не вызывают их.

Мораль всего этого такова: просто напишите настоящую хеш-функцию. Поскольку это объект последовательности, наиболее очевидным подходом является преобразование его в кортеж и хэширование.

def __hash__(self):
    return hash(tuple(self))

В дополнение к приведенным выше ответам. Для конкретного случая класса данных в python3.7+ - чтобы сделать класс данных хешируемым, вы можете использовать

@dataclass(frozen=True)
class YourClass:
    pass

как украшение вместо

@dataclass
class YourClass:
    pass