Skip to content

Специальные методы (или магические методы) ​

В Python — это методы, которые имеют специальные имена и используются для выполнения определенных операций. Они начинаются и заканчиваются двойными подчеркиваниями, например, __init__, __str__, __add__, и т.д. Эти методы предоставляют возможность переопределить поведение стандартных операторов и встроенных функций, таких как конкатенация, сравнение и доступ к элементам.

Основные специальные методы ​

  1. Конструктор и деструктор:

    • __init__(self, ...): вызывается при создании объекта.
    • __del__(self): вызывается при уничтожении объекта.
  2. Методы представления:

    • __str__(self): возвращает строковое представление объекта (для print).
    • __repr__(self): возвращает официальное представление объекта (для отладки).
  3. Операторы сравнения — разбираются подробно ниже:

    ОператорВыражениеСпециальная функцияМетод класса
    Равноv1 == v2v1.__eq__(v2)__eq__(self, value):
    Не равноv1 != v2v1.__ne__(v2)__ne__(self, value):
    Большеv1 > v2v1.__gt__(v2)__gt__(self, value):
    Больше или равноv1 >= v2v1.__ge__(v2)__ge__(self, value):
    Меньшеv1 < v2v1.__lt__(v2)__lt__(self, value):
    Меньше или равноv1 <= v2v1.__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

Что писать внутри методов сравнения — чек-лист ​

  1. Сравнивайте только смысловые поля: для ParcelBox — weight, а не адреса и вспомогательные счётчики.
  2. Возвращайте bool: операторы сравнения дают True/False.
  3. Несовместимый тип — NotImplemented, не исключение и не False.
  4. __ne__ можно не писать — Python выведет его из __eq__.
  5. Изменили __eq__ — подумайте про __hash__: инвариант a == b → hash(a) == hash(b).
  6. Для сортировки достаточно __lt__; in и == требуют __eq__.

Достоинства специальных методов: ​

  1. Кастомизация: Позволяют настраивать поведение операторов и встроенных функций для объектов собственных классов.
  2. Упрощение кода: Позволяют создавать более интуитивно понятные и удобные интерфейсы для работы с объектами, что делает код более читаемым и поддерживаемым.
  3. Системность: Позволяют интегрировать пользовательские классы в стандартные механизмы Python, как, например, использование встроенных функций и операторов.

Недостатки специальных методов: ​

  1. Сложность для новичков: Понимание и использование специальных методов может показаться сложным для тех, кто только начинает изучать язык, так как они могут добавить уровень абстракции.
  2. Потенциальная путаница: Переопределение стандартного поведения операторов может привести к неожиданным результатам, если не соблюдаются определенные соглашения (например, логика сравнения объектов).
  3. Потенциальные проблемы с производительностью: Частое использование магических методов, особенно в больших и сложных структурах, может негативно сказаться на производительности.

Использование специальных методов позволяет создавать более элегантные и удобные классы, но требует тщательного подхода к их реализации и понимания интерфейсов, которые они предоставляют.

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

❓По умолчанию (без `__eq__`) что сравнивает `==` у объектов?
❓Что произойдёт при `box_a < box_b`, если `__lt__` не переопределён?
❓Что нужно вернуть в `__eq__`, если объект сравнивают с несовместимым типом?
❓Почему нельзя вернуть `False` вместо `NotImplemented`?
❓Почему `__ne__` можно не писать, если есть `__eq__`?
❓Что случится, если в классе определён `__eq__`, но нет `__hash__`?
❓Какие методы используют `sorted()`, `min()`, `max()`?

Упражнения: ​

  1. Возьмите класс RomanNumber (с __str__/__repr__). Добавьте метод _to_int(self), превращающий римскую строку в целое (словарь I=1, V=5, X=10, L=50, C=100, M=1000 + стандартный алгоритм слева направо). Реализуйте сравнение по значению: __eq__, __ne__, __lt__, __le__, __gt__, __ge__. Проверьте:

    python
    a, b = RomanNumber('IX'), RomanNumber('III')
    print(a > b)   # True
    print(sorted([RomanNumber('IX'), RomanNumber('I'), RomanNumber('VII'), RomanNumber('III')]))
    # [I, III, VII, IX]
  2. «Ловушка» хэша: создайте RomanNumber с __eq__, но без __hash__; положите два равных объекта в set — что выведет программа? Добавьте __hash__ (хэш целого значения) и проверьте работу set и dict.

  3. Добавьте в __lt__ вывод (или счётчик-атрибут) и посчитайте, сколько раз он вызывается при sorted() списка из 5 разных RomanNumber.

  4. Проверьте in: RomanNumber('V') in [RomanNumber('I'), RomanNumber('V')] — сколько раз вызывается __eq__?

  5. Что вернёт RomanNumber('V') == 5? Объясните роль NotImplemented. Добейтесь, чтобы сравнение с int работало по значению: RomanNumber('V') == 5 → True.