Appearance
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) # FalseNotImplemented — особый ответ «не знаю, сравнивай ты». Без него сравнение с чужим типом упало бы в 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'Правила
__eq__сравнивает содержимое,__hash__— хешит те же самые поля.- Если объект мутирует — его хеш менялся бы, и
set/dictсломались: изменяемые объекты обычно не хешируют (какlist). - Для неизменяемых данных (кортежи полей, frozenset) хеш стабилен — так и делайте.
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__ явно.