Appearance
Специальные методы (или магические методы)
В Python — это методы, которые имеют специальные имена и используются для выполнения определенных операций. Они начинаются и заканчиваются двойными подчеркиваниями, например, __init__, __str__, __add__, и т.д. Эти методы предоставляют возможность переопределить поведение стандартных операторов и встроенных функций, таких как конкатенация, сравнение и доступ к элементам.
Основные специальные методы
Конструктор и деструктор:
__init__(self, ...):вызывается при создании объекта.__del__(self):вызывается при уничтожении объекта.
Методы представления:
__str__(self):возвращает строковое представление объекта (для print).__repr__(self):возвращает официальное представление объекта (для отладки).
Операторы сравнения — разбираются подробно ниже:
Оператор Выражение Специальная функция Метод класса Равно v1 == v2 v1.__eq__(v2)__eq__(self, value):Не равно v1 != v2 v1.__ne__(v2)__ne__(self, value):Больше v1 > v2 v1.__gt__(v2)__gt__(self, value):Больше или равно v1 >= v2 v1.__ge__(v2)__ge__(self, value):Меньше v1 < v2 v1.__lt__(v2)__lt__(self, value):Меньше или равно v1 <= v2 v1.__le__(v2)__le__(self, value):
Сравнение объектов: __lt__, __le__, __eq__, __ne__, __gt__, __ge__
Как работает по умолчанию
У любого объекта сравнения по умолчанию не смотрят на содержимое:
==и!=сравнивают по тождественности — это один и тот же объект (тот же адрес), то есть какis;<,<=,>,>=не поддерживаются и бросаютTypeError.
python
class ParcelBox:
pass
box_a = ParcelBox()
box_b = ParcelBox()
print(box_a == box_b) # False — разные объекты
print(box_a is box_b) # False — == по умолчанию проверяет именно это
print(box_a != box_b) # True
try:
box_a < box_b
except TypeError as e:
print(e) # '<' not supported between instances of 'ParcelBox' and 'ParcelBox'Чтобы сравнение шло «по смыслу», методы нужно переопределить.
Заметим тонкость прямого вызова: box_a.__eq__(8) в этом разделе не вызывает оператор == — по умолчанию он вернёт объект NotImplemented (как в python_method.py: print(5, box.__eq__(2)) печатает NotImplemented). Fallback на тождественность выполняется оператором: box_a == 8 → NotImplemented → «тот же объект?» → False.
Переопределение: класс ParcelBox (пример из python_method.py)
В файле python_method.py определён ParcelBox с полем weight, где уже реализованы все шесть методов сравнения. Ниже — тот же класс в актуальной форме (домен description + weight):
python
# Класс берём из темы `__str__`/`__repr__`; сравниваем по полю weight
class ParcelBox:
"""Коробка с описанием содержимого и весом."""
def __init__(self, description, weight):
self.description, self.weight = description, weight
def __str__(self):
return f'Посылка {self.description!r} — {self.weight} кг'
def __repr__(self):
return f"ParcelBox(description={self.description!r}, weight={self.weight})"
def __eq__(self, other):
return self.weight == other.weight
def __ne__(self, other):
return self.weight != other.weight
def __lt__(self, other):
return self.weight < other.weight
def __le__(self, other):
return self.weight <= other.weight
def __gt__(self, other):
return self.weight > other.weight
def __ge__(self, other):
return self.weight >= other.weight
box_a = ParcelBox('Одежда', 3.5)
box_b = ParcelBox('Игрушки', 1.5)
box_c = ParcelBox('Книги', 3.5)
print(box_a) # Посылка 'Одежда' — 3.5 кг
print(box_a == box_b) # False
print(box_a.__eq__(box_b)) # False — оператор и прямой вызов метода дают один результат
print(box_a == box_c) # True — разные объекты, но равные weight
print(box_a != box_b) # True
print(box_a > box_b) # True
print(box_a.__gt__(box_b)) # True
print(box_a < box_b) # False
print(box_a >= box_c) # True
print(box_a <= box_b) # FalseКлючевой момент: box_a == box_c — True, хотя объекты разные. Сравнение теперь идёт по смыслу (weight), а не по адресу.
Методы в python_method.py написаны так же (без проверки типа): выражение box_1 < 8 там упало бы в AttributeError: 'int' object has no attribute 'weight' — следующий раздел показывает, как с этим справиться.
Сравнение с другими типами: NotImplemented
В python_method.py строка # print(box_1 != 8) закомментирована — не случайно: при реализации из файла это выражение падает с AttributeError: 'int' object has no attribute 'weight', потому что __ne__ пытается прочитать other.weight у числа.
Правильная реакция на сравнение с несовместимым типом — не исключение, а специальное значение NotImplemented («я этот тип сравнить не умею, пусть попробует другой операнд»):
python
class ParcelBoxSafe:
def __init__(self, description, weight):
self.description, self.weight = description, weight
def __eq__(self, other):
if not isinstance(other, ParcelBoxSafe):
return NotImplemented
return self.weight == other.weight
def __lt__(self, other):
if not isinstance(other, ParcelBoxSafe):
return NotImplemented
return self.weight < other.weight«Зеркальная» механика:
box_a != 8→ Python использует выведенный__ne__=not (a == b):ParcelBoxSafe.__eq__(box_a, 8)→NotImplemented→ зеркальныйint.__eq__(8, box_a)→NotImplemented→ fallback по тождественностиbox_a is 8→False→ отрицание →True;8 == box_a→ сначалаint.__eq__(8, box_a)→NotImplemented→ затем зеркальныйParcelBoxSafe.__eq__(box_a, 8)→NotImplemented→ fallback по тождественности →False.
python
box_a = ParcelBoxSafe('Одежда', 3.5)
print(box_a == 8) # False
print(box_a != 8) # True — объекты разные (по тождественности)
print(8 == box_a) # False
try:
box_a < 8
except TypeError as e:
print(e) # '<' not supported between instances of 'ParcelBoxSafe' and 'int'Правила:
- возвращать нужно именно
NotImplemented, а неFalseилиNone: иначе «зеркальный» вызов не состоится, и другие типы (и подклассыParcelBox) не смогут определить своё поведение при сравнении сParcelBox; NotImplemented— обычный объект-синглтон, его можно использовать в условиях:if result is NotImplemented:.
__ne__ можно не писать
Если определён __eq__, а __ne__ нет, Python сам выводит != как not (a == b). Поэтому из пар ==/!= достаточно одного метода.
Цепочки сравнений
a < b < c — фича Python: она эквивалентна a < b and b < c, при этом каждое выражение вычисляется один раз (в C промежуточное выражение b вычислялось бы дважды):
python
print(ParcelBox('А', 5.0) < ParcelBox('Б', 17.0) < ParcelBox('В', 30.0)) # True
print(ParcelBox('А', 1.0) <= ParcelBox('Б', 7.0) <= ParcelBox('В', 17.0)) # TrueСортировка, min, max, in
sorted(),min(),max()используют только__lt__— достаточно его, чтобы объекты сортировались;- оператор
inиспользует==, то есть__eq__.
Продолжаем использовать класс ParcelBox из раздела «Переопределение»:
python
boxes = [ParcelBox('А', 9.0), ParcelBox('Б', 1.0), ParcelBox('В', 5.0)]
print(sorted(boxes)) # [ParcelBox(description='Б', weight=1.0), ParcelBox(description='В', weight=5.0), ParcelBox(description='А', weight=9.0)]
print(min(boxes)) # Посылка 'Б' — 1.0 кг
print(max(boxes)) # Посылка 'А' — 9.0 кг
print(ParcelBox('В', 5.0) in boxes) # True — поиск идёт через ==Контракт __eq__ и __hash__ (важно!)
Если в классе определён __eq__, но не определён __hash__, класс теряет хэшируемость:
python
try:
boxes_dict = {ParcelBox('А', 5.0): 'five'}
except TypeError as e:
print(e) # unhashable type: 'ParcelBox'Причина — инвариант хэш-таблиц: если a == b, то hash(a) == hash(b). После переопределения __eq__ «по weight» стандартный hash (по адресу) этот инвариант ломает, поэтому Python запрещает использовать такой объект как ключ, а не работает некорректно.
Чинится симметричным __hash__ — от тех же полей, что и в __eq__ (в примере — отдельный класс с обоими методами, чтобы не затенять предыдущий ParcelBox):
python
class ParcelBoxHash:
def __init__(self, description, weight):
self.description, self.weight = description, weight
def __eq__(self, other):
return self.weight == other.weight
def __hash__(self):
return hash(self.weight)
s = {ParcelBoxHash('А', 5.0): 'five', ParcelBoxHash('Б', 1.0): 'one'}
print(s[ParcelBoxHash('А', 5.0)]) # five — ключ найден по значению, а не по адресуУкорочение: functools.total_ordering
Писать все шесть методов — избыточно. Декоратор @total_ordering дорисовывает недостающие порядковые методы, зная __eq__ и один из </<=:
python
from functools import total_ordering
@total_ordering
class ParcelBoxFast:
def __init__(self, description, weight):
self.description, self.weight = description, weight
def __eq__(self, other):
if not isinstance(other, ParcelBoxFast):
return NotImplemented
return self.weight == other.weight
def __lt__(self, other):
if not isinstance(other, ParcelBoxFast):
return NotImplemented
return self.weight < other.weight
print(ParcelBoxFast('А', 17.0) != ParcelBoxFast('Б', 7.0)) # True — __ne__ выведен Python из __eq__
print(ParcelBoxFast('А', 17.0) >= ParcelBoxFast('А', 17.0)) # True — __ge__ дорисован total_ordering
print(ParcelBoxFast('А', 17.0) > ParcelBoxFast('Б', 7.0)) # True — __gt__ дорисован total_orderingЧто писать внутри методов сравнения — чек-лист
- Сравнивайте только смысловые поля: для
ParcelBox—weight, а не адреса и вспомогательные счётчики. - Возвращайте
bool: операторы сравнения даютTrue/False. - Несовместимый тип —
NotImplemented, не исключение и неFalse. __ne__можно не писать — Python выведет его из__eq__.- Изменили
__eq__— подумайте про__hash__: инвариантa == b → hash(a) == hash(b). - Для сортировки достаточно
__lt__;inи==требуют__eq__.
Достоинства специальных методов:
- Кастомизация: Позволяют настраивать поведение операторов и встроенных функций для объектов собственных классов.
- Упрощение кода: Позволяют создавать более интуитивно понятные и удобные интерфейсы для работы с объектами, что делает код более читаемым и поддерживаемым.
- Системность: Позволяют интегрировать пользовательские классы в стандартные механизмы Python, как, например, использование встроенных функций и операторов.
Недостатки специальных методов:
- Сложность для новичков: Понимание и использование специальных методов может показаться сложным для тех, кто только начинает изучать язык, так как они могут добавить уровень абстракции.
- Потенциальная путаница: Переопределение стандартного поведения операторов может привести к неожиданным результатам, если не соблюдаются определенные соглашения (например, логика сравнения объектов).
- Потенциальные проблемы с производительностью: Частое использование магических методов, особенно в больших и сложных структурах, может негативно сказаться на производительности.
Использование специальных методов позволяет создавать более элегантные и удобные классы, но требует тщательного подхода к их реализации и понимания интерфейсов, которые они предоставляют.
Проверьте себя
По умолчанию (без `__eq__`) что сравнивает `==` у объектов?
Что произойдёт при `box_a < box_b`, если `__lt__` не переопределён?
Что нужно вернуть в `__eq__`, если объект сравнивают с несовместимым типом?
Почему нельзя вернуть `False` вместо `NotImplemented`?
Почему `__ne__` можно не писать, если есть `__eq__`?
Что случится, если в классе определён `__eq__`, но нет `__hash__`?
Какие методы используют `sorted()`, `min()`, `max()`?
Упражнения:
Возьмите класс
RomanNumber(с__str__/__repr__). Добавьте метод_to_int(self), превращающий римскую строку в целое (словарьI=1, V=5, X=10, L=50, C=100, M=1000+ стандартный алгоритм слева направо). Реализуйте сравнение по значению:__eq__,__ne__,__lt__,__le__,__gt__,__ge__. Проверьте:pythona, b = RomanNumber('IX'), RomanNumber('III') print(a > b) # True print(sorted([RomanNumber('IX'), RomanNumber('I'), RomanNumber('VII'), RomanNumber('III')])) # [I, III, VII, IX]«Ловушка» хэша: создайте
RomanNumberс__eq__, но без__hash__; положите два равных объекта вset— что выведет программа? Добавьте__hash__(хэш целого значения) и проверьте работуsetиdict.Добавьте в
__lt__вывод (или счётчик-атрибут) и посчитайте, сколько раз он вызывается приsorted()списка из 5 разныхRomanNumber.Проверьте
in:RomanNumber('V') in [RomanNumber('I'), RomanNumber('V')]— сколько раз вызывается__eq__?Что вернёт
RomanNumber('V') == 5? Объясните рольNotImplemented. Добейтесь, чтобы сравнение сintработало по значению:RomanNumber('V') == 5 → True.