Skip to content

Equality and Hash - __eq__ и __hash__ ​

По умолчанию == сравнивает объекты по тождеству (одинаковость в памяти), а hash() — по памяти объекта. Для «данных» объектов, где два экземпляра с равным содержимым должны считаться равными, переопределяют __eq__, а чтобы такие объекты работали в set/dict — и __hash__.

Проблема: равенство по памяти ​

python
class Box:
    def __init__(self, length, width, height):
        self.length, self.width, self.height = length, width, height


b1, b2 = Box(2, 3, 4), Box(2, 3, 4)
print(b1 == b2)   # False — разные объекты в памяти
print(b1 is b2)   # False

[1, 2] == [1, 2] возвращает True, потому что список сам переопределил __eq__. Класс пользователя — только с переопределением.

__eq__: сравнение по содержимому ​

python
class BoxEq(Box):
    def __eq__(self, other):
        if not isinstance(other, BoxEq):
            return NotImplemented          # даём шанс другому типу; иначе — False
        return ((self.length, self.width, self.height)
                == (other.length, other.width, other.height))


b1, b2 = BoxEq(2, 3, 4), BoxEq(2, 3, 4)
print(b1 == b2)   # True
print(b1 is b2)   # False

NotImplemented — особый ответ «не знаю, сравнивай ты». Без него сравнение с чужим типом упало бы в False или в ошибку.

__hash__: ключи set и dict ​

Класс, переопределивший __eq__, теряет __hash__ (становится unhashable) — иначе нарушилось бы правило «равные объекты имеют равные хеши». Верните хеш, основанный на тех же данных:

python
class BoxEq(Box):
    def __eq__(self, other):
        if not isinstance(other, BoxEq):
            return NotImplemented
        return ((self.length, self.width, self.height)
                == (other.length, other.width, other.height))

    def __hash__(self):
        return hash((self.length, self.width, self.height))

    def __repr__(self):
        return f'BoxEq({self.length}, {self.width}, {self.height})'


b1, b2 = BoxEq(2, 3, 4), BoxEq(2, 3, 4)
print(hash(b1) == hash(b2))     # True
print({b1, b2})                 # одноэлементное множество: {BoxEq(2, 3, 4)}
box = {BoxEq(2, 3, 4): 'small'}
print(box[BoxEq(2, 3, 4)])      # small — ключ найден по равному объекту

Класс без __hash__ ​

Если __eq__ есть, а __hash__ — нет, объекты нельзя использовать как ключи:

python
class BoxNoHash:
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        return isinstance(other, BoxNoHash) and self.value == other.value


a1, a2 = BoxNoHash(1), BoxNoHash(1)
print(a1 == a2)          # True
print(a1.__hash__)       # None — unhashable
# {a1, a2}               # TypeError: unhashable type: 'BoxNoHash'

Правила ​

  1. __eq__ сравнивает содержимое, __hash__ — хешит те же самые поля.
  2. Если объект мутирует — его хеш менялся бы, и set/dict сломались: изменяемые объекты обычно не хешируют (как list).
  3. Для неизменяемых данных (кортежи полей, frozenset) хеш стабилен — так и делайте.
  4. NotImplemented в __eq__ — стандартная практика при сравнении с другим типом.

Проверьте себя (автопроверка) ​

Выполните каждый блок кода и сравните фактический вывод с ожидаемым, записанным в конце строки комментариями. Классы Box, BoxEq, BoxNoHash уже определены в предыдущих разделах урока.

Тест 1. Равенство по содержимому, тождество — нет:

python
b3 = BoxEq(2, 3, 4)
print(b3 == b1, b3 is b1)   # True False

Тест 2. Равные объекты — равные хеши, в set один элемент:

python
print(hash(b3) == hash(b1))   # True
print({b1, b2, b3})           # {BoxEq(2, 3, 4)} — три равных → один элемент

Тест 3. Чужой тип — NotImplemented:

python
print(BoxEq(2, 3, 4) == (2, 3, 4))   # False — BoxEq не сравнивается с кортежем

Тест 4. __eq__ без __hash__ — unhashable:

python
print(a1 == a2, a1.__hash__ is None)   # True True
try:
    hash(a1)
except TypeError as err:
    print(type(err).__name__)   # TypeError
Пояснения к ответам

Тест 1. b3 == b1 — True, потому что __eq__ сравнивает кортежи полей (2, 3, 4) == (2, 3, 4). b3 is b1 — False: это два разных объекта в памяти.

Тест 2. Правило «равные → одинаковый хеш» выполняется: хеш строится из тех же полей. Поэтому set объединяет три равных объекта в один.

Тест 3. BoxEq.__eq__ получает кортеж, isinstance не проходит, возвращается NotImplemented; отражённое сравнение кортежа с BoxEq тоже не знает, что делать, и Python возвращает False.

Тест 4. Переопределение __eq__ обнуляет __hash__ (становится None). Любой hash(a1) бросает TypeError — такой объект нельзя использовать в set/dict как ключ.

Проверьте себя ​

❓По умолчанию что вернёт `b1 == b2` для двух одинаковых `Box(2, 3, 4)`?
❓Почему `[1, 2] == [1, 2]` даёт True, а два одинаковых Box — нет?
❓Что происходит с `__hash__`, когда класс переопределяет `__eq__`?
❓Как вернуть классу пригодность как ключу `set`/`dict`?
❓Почему изменяемые объекты обычно не хешируют (как `list`)?
❓Зачем в `__eq__` при сравнении с чужим типом возвращают `NotImplemented`?

Практические упражнения ​

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

Упражнение 1: Точка в set (Point) ​

Задание: Создайте Point(x, y) с __eq__, __hash__ и __repr__; убедитесь, что set из двух равных точек содержит один элемент.

python
# Ожидаемое поведение:
# pts = {Point(1, 2), Point(1, 2)}
# print(len(pts))   # 1
# print(pts)        # {Point(1, 2)}

Упражнение 2: Равный, но unhashable (EqOnly) ​

Задание: Переопределите __eq__ у Box (наследник BoxEqOnly), не задавая __hash__, и покажите TypeError при попытке x in {x}.

python
# Ожидаемое поведение:
# x = BoxEqOnly(1, 2, 3)
# try:
#     result = x in {x}
# except TypeError as err:
#     print(type(err).__name__, '-', err)   # TypeError - unhashable type: 'BoxEqOnly'

Упражнение 3: Сравнение с кортежем (TupleEq) ​

Задание: Создайте BoxTuple(BoxEq), чей __eq__ возвращает True для кортежа (2, 3, 4), а для остальных типов передаёт сравнение дальше через super().__eq__.

python
# Ожидаемое поведение:
# bt = BoxTuple(2, 3, 4)
# print(bt == (2, 3, 4))        # True
# print((2, 3, 4) == bt)        # True — симметрично через NotImplemented
# print(bt == BoxEq(2, 3, 4))   # True — наследованный путь

Упражнение 4: Мутируемый Counter (MutableCounter) ​

Задание: Создайте Counter с полем value, методом bump() и __eq__. Покажите, что объект равен другому, но не имеет __hash__ — и объясните, почему это опасно для set.

python
# Ожидаемое поведение:
# c1, c2 = Counter(5), Counter(5)
# print(c1 == c2)                  # True
# print(c1.__hash__ is None)       # True — unhashable

Упражнение 5: Счётчик точек в dict (PointDict) ​

Задание: Напишите count_points(points), возвращающий dict «точка → сколько раз встретилась». Ключами работают именно Point (нужны __eq__ + __hash__).

python
# Ожидаемое поведение:
# pts = [Point(1, 2), Point(1, 2), Point(0, 0)]
# print(count_points(pts))   # {Point(1, 2): 2, Point(0, 0): 1}

Упражнение 6: Хеш исчезает после __eq__ (HashLost) ​

Задание: Создайте класс Data(value) без __eq__ (хеш есть), затем DataEq(Data) с __eq__ (хеш пропадает). Покажите разницу __hash__ у обоих.

python
# Ожидаемое поведение:
# print(Data(1).__hash__ is not None)   # True — по умолчанию хеш по памяти
# print(DataEq(1).__hash__)             # None — __eq__ обнулил хеш

Решения для самопроверки ​

Посмотреть решение Упражнения 1 (Point)
python
class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

    def __hash__(self):
        return hash((self.x, self.y))

    def __repr__(self):
        return f'Point({self.x}, {self.y})'


pts = {Point(1, 2), Point(1, 2)}
print(len(pts))   # 1
print(pts)        # {Point(1, 2)}

Пояснение: __eq__ и __hash__ опираются на один и тот же кортеж (x, y) — это гарантирует, что равные точки дают равные хеши и set корректно дедуплицирует.

Посмотреть решение Упражнения 2 (EqOnly)
python
class BoxEqOnly(Box):
    def __eq__(self, other):
        if not isinstance(other, BoxEqOnly):
            return NotImplemented
        return ((self.length, self.width, self.height)
                == (other.length, other.width, other.height))


x = BoxEqOnly(1, 2, 3)
try:
    result = x in {x}
except TypeError as err:
    print(type(err).__name__, '-', err)   # TypeError - unhashable type: 'BoxEqOnly'

Пояснение: как только у класса появляется __eq__ без __hash__, Python присваивает __hash__ = None. x in {x} сначала хеширует x — и падает в TypeError.

Посмотреть решение Упражнения 3 (TupleEq)
python
class BoxTuple(BoxEq):
    def __eq__(self, other):
        if isinstance(other, tuple):
            return (self.length, self.width, self.height) == other
        return super().__eq__(other)


bt = BoxTuple(2, 3, 4)
print(bt == (2, 3, 4))        # True
print((2, 3, 4) == bt)        # True — симметрично через NotImplemented
print(bt == BoxEq(2, 3, 4))   # True — наследованный путь

Пояснение: (2, 3, 4) == bt сначала спрашивает кортеж, тот не понимает BoxTuple и возвращает NotImplemented; Python отражает вызов в bt.__eq__((2,3,4)) — и получает True. Симметрия сохранена.

Посмотреть решение Упражнения 4 (MutableCounter)
python
class Counter:
    def __init__(self, value=0):
        self.value = value

    def __eq__(self, other):
        return isinstance(other, Counter) and self.value == other.value

    def bump(self):
        self.value += 1


c1, c2 = Counter(5), Counter(5)
print(c1 == c2)                  # True
print(c1.__hash__ is None)       # True — unhashable

Пояснение: если бы Counter был хешируем, bump() изменил бы value, но хеш, по которому объект уже разложен по корзинам set/dict, остался бы старым — объект стал бы «недостижимым». Поэтому изменяемые объекты с __eq__ делают unhashable (как list).

Посмотреть решение Упражнения 5 (PointDict)
python
def count_points(points):
    counts = {}
    for p in points:
        counts[p] = counts.get(p, 0) + 1
    return counts


pts = [Point(1, 2), Point(1, 2), Point(0, 0)]
print(count_points(pts))   # {Point(1, 2): 2, Point(0, 0): 1}

Пояснение: counts[p] и counts.get(p, 0) находят ключ именно благодаря __hash__ + __eq__: равные точки попадают в одну корзину и сравниваются как равные.

Посмотреть решение Упражнения 6 (HashLost)
python
class Data:
    def __init__(self, value):
        self.value = value


class DataEq(Data):
    def __eq__(self, other):
        return isinstance(other, DataEq) and self.value == other.value


print(Data(1).__hash__ is not None)   # True — по умолчанию хеш по памяти
print(DataEq(1).__hash__)             # None — __eq__ обнулил хеш

Пояснение: правило Python: пользовательский __eq__ без __hash__ обнуляет хеш, чтобы не нарушать инвариант «равные → равные хеши». Если классу нужен set/dict — добавьте __hash__ явно.