Skip to content

Магические методы математических операторов ​

В Python вы можете перегружать поведение стандартных математических операторов (+, -, * и т.д.) для своих собственных классов. Это делается с помощью специальных дандер-методов (double underscore). Когда Python видит выражение a + b, он внутри себя вызывает метод a.__add__(b).

В этом уроке мы разберем, как применить математику к нашему классу Почтовой Коробки (ParcelBox), какие операторы имеют для неё физический смысл, а какие мы вынесем в упражнения.

1. Справочник математических операторов в Python ​

ОператорВыражениеВнутренний вызовМетод для реализации в классе
Сложениеv1 + v2v1.__add__(v2)def __add__(self, other):
Вычитаниеv1 - v2v1.__sub__(v2)def __sub__(self, other):
Умножениеv1 * v2v1.__mul__(v2)def __mul__(self, other):
Возведение в степеньv1 ** v2v1.__pow__(v2)def __pow__(self, other):
Делениеv1 / v2v1.__truediv__(v2)def __truediv__(self, other):
Целочисленное делениеv1 // v2v1.__floordiv__(v2)def __floordiv__(self, other):
Остаток от деленияv1 % v2v1.__mod__(v2)def __mod__(self, other):

2. Физический смысл математики для Почтовой Коробки ​

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

  1. Сложение (+) — Объединение посылок: Если мы складываем две коробки, логично получить новую большую коробку, вес которой равен сумме весов двух исходных, а содержимое объединяется.
  2. Вычитание (-) — Извлечение веса/вещей: Если из коробки вычесть число, мы можем сымитировать разгрузку (уменьшение текущего веса).
  3. Умножение (*) — Масштабирование (опт): Если коробку умножить на число (например, на 3), мы можем вернуть список из трех одинаковых коробок для оптовой отправки.

Реализация класса ParcelBox ​

Давайте посмотрим, как реализовать методы __add__, __sub__ и __mul__ в коде:

python
class ParcelBox:
    """Класс, представляющий почтовую коробку для отправки посылок."""

    def __init__(self, description: str, weight: float) -> None:
        """Инициализирует коробку.

        Args:
            description (str): Описание содержимого (например, 'Книги').
            weight (float): Вес коробки в килограммах.
        """
        self.description: str = description
        self.weight: float = max(0.0, weight)

    def __add__(self, other: "ParcelBox") -> "ParcelBox":
        """Сложение двух коробок (`box1 + box2`).

        Объединяет содержимое и суммирует вес в новой коробке.
        """
        if not isinstance(other, ParcelBox):
            raise TypeError("Коробку можно сложить только с другой коробкой!")
        
        combined_description = f"Сборная посылка ({self.description} + {other.description})"
        combined_weight = self.weight + other.weight
        
        # Возвращаем НОВЫЙ объект класса ParcelBox
        return ParcelBox(combined_description, combined_weight)

    def __sub__(self, weight_to_remove: float) -> "ParcelBox":
        """Вычитание веса из коробки (`box - 2.5`).

        Уменьшает вес текущей коробки на заданное число.
        """
        if not isinstance(weight_to_remove, (int, float)):
            raise TypeError("Вычитать из веса коробки можно только число!")
        
        new_weight = max(0.0, self.weight - weight_to_remove)
        return ParcelBox(self.description, new_weight)

    def __mul__(self, count: int) -> list["ParcelBox"]:
        """Умножение коробки на число (`box * 3`).

        Возвращает список из N копий этой коробки для массовой отправки.
        """
        if not isinstance(count, int):
            raise TypeError("Умножить коробку можно только на целое число (количество)!")
        
        return [ParcelBox(self.description, self.weight) for _ in range(count)]

    def __repr__(self) -> str:
        """Техническое представление объекта для удобства вывода."""
        return f"ParcelBox(description='{self.description}', weight={self.weight})"


# === Демонстрация работы ===
if __name__ == "__main__":
    box_a = ParcelBox("Одежда", 3.5)
    box_b = ParcelBox("Игрушки", 1.5)

    # 1. Проверяем сложение (+)
    big_box = box_a + box_b
    print(f"Результат сложения: {big_box}")
    # Вывод: ParcelBox(description='Сборная посылка (Одежда + Игрушки)', weight=5.0)

    # 2. Проверяем вычитание (-) числа из коробки
    light_box = box_a - 1.2
    print(f"Результат вычитания веса: {light_box}")
    # Вывод: ParcelBox(description='Одежда', weight=2.3)

    # 3. Проверяем умножение (*) на число
    batch = box_b * 3
    print(f"Результат умножения (оптовая партия): {batch}")
    # Вывод: [ParcelBox(description='Игрушки', weight=1.5), ParcelBox(...), ParcelBox(...)]

Важное правило ООП

Магические методы математики (за редким исключением операторов присваивания вроде +=) не должны изменять исходный объект напрямую. Они должны вычислять значения и возвращать новый экземпляр класса с измененными данными.

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

❓Какой метод вызывает Python при вычислении выражения `a + b`?
❓Какой метод отвечает за оператор целочисленного деления `v1 // v2`?
❓Что делает `box_a + box_b` в примере с ParcelBox?
❓Что вернёт `box_b * 3`?
❓Какое главное правило ООП для магических методов математики?
❓Зачем в `__add__` стоит проверка `isinstance(other, ParcelBox)`?

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

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

Упражнение 1: Деление коробки (__truediv__ и __floordiv__) ​

Добавьте в наш класс ParcelBox поддержку деления на число:

  1. Реализуйте обычное деление __truediv__(self, divisor). Команда box / 2 должна возвращать новую коробку, вес которой уменьшен ровно в 2 раза, а к описанию добавляется текст " (Половина)".
  2. Реализуйте целочисленное деление __floordiv__(self, divisor). Команда box // 2 должна возвращать целое число — сколько таких облегченных коробок весом по 2 кг можно собрать из текущего веса посылки.

Упражнение 2: Остаток от деления и Степень (__mod__ и __pow__) ​

Поскольку для Почтовой Коробки операторы % и ** не имеют смысла, реализуйте их на другом классическом классе — NumberFilter (Математический фильтр) или Vector (Вектор).

Создайте класс CustomNumber (Кастомное число):

  • Реализуйте __mod__, чтобы выражение CustomNumber(10) % 3 возвращало остаток от деления.
  • Реализуйте __pow__, чтобы выражение CustomNumber(2) ** 3 возводило внутреннее число в степень.

Упражнение 3: Накопление остатка посылки (__mod__) ​

Давайте найдем оригинальное применение для оператора остатка от деления % (__mod__) в контексте почтовых отправлений.

Представьте, что у курьера есть ограничение на максимальный вес посылки, которую он может унести за один раз (например, 5.0 кг). Если коробка весит больше, курьер забирает максимально возможный кратный вес, а остаток перекладывается в другую, меньшую коробку.

Задание: Реализуйте в классе ParcelBox метод __mod__.

  • Выражение box % 5.0 должно возвращать новый объект ParcelBox с тем же описанием, но его вес должен быть равен остатку от деления текущего веса на указанный лимит.
  • Если текущий вес коробки меньше лимита или делится без остатка, вес новой коробки должен быть равен 0.0.
python
# Ожидаемое поведение:
heavy_box = ParcelBox("Строительные материалы", 12.3)
leftover_box = heavy_box % 5.0  # 12.3 % 5.0 = 2.3
print(leftover_box.weight)  # Должно вывести: 2.3

Упражнение 4: Операторы с разным порядком (Правостороннее сложение __radd__) ​

В текущей реализации метод __add__ позволяет складывать только Коробку + Коробку. А что если мы хотим быстро добавить вес к коробке, написав число в начале? Например: 1.5 + box.

Если запустить такой код сейчас, Python выдаст ошибку TypeError, потому что тип float (число 1.5) не умеет складываться с классом ParcelBox. Для решения этой проблемы существует зеркальный метод __radd__ (right add). Он вызывается, если наш объект находится справа от оператора +.

Задание: Добавьте в класс ParcelBox методы __add__ (обновленный) и __radd__:

  1. Измените __add__ так, чтобы выражение box + 2.0 (коробка + число) увеличивало вес коробки на 2.0 кг и возвращало новую коробку.
  2. Реализуйте __radd__, чтобы выражение 2.0 + box (число + коробка) делало абсолютно то же самое.

Подсказка по __radd__

Поскольку сложение веса коммутативно (перемена мест слагаемых не меняет результат), внутри метода __radd__ вы можете просто вызвать уже написанный __add__:

python
def __radd__(self, other):
    return self.__add__(other)

Упражнение 5: Масштабирование площади коробки через степень (__pow__) ​

Давайте применим оператор возведения в степень ** (__pow__) для вычисления условной площади основания коробки или масштабирования её габаритов.

Представьте, что у нас есть класс квадратной коробки SquareBox, у которой измеряется длина одной стороны.

Задание: Создайте класс SquareBox с атрибутом side_length (длина стороны).

  • Реализуйте метод __pow__. Если мы возводим коробку в степень 2 (box ** 2), метод должен возвращать площадь основания коробки (число типа float или int).
  • Если мы возводим в степень 3 (box ** 3), метод должен возвращать объем кубической коробки.
  • Для любых других степеней метод должен выбрасывать ошибку ValueError.
python
# Ожидаемое поведение:
cube = SquareBox(side_length=4)
print(cube ** 2)  # Вывод: 16 (площадь)
print(cube ** 3)  # Вывод: 64 (объем)

Упражнение 6: Класс "Игровой инвентарь" (Комплексная практика) ​

Чтобы полностью абстрагироваться от коробок и закрепить математические методы на классической IT-задаче, создайте класс Inventory. Он моделирует инвентарь персонажа в RPG-игре.

  • Атрибуты: gold (int — золото), items (list — список названий предметов, строк).
  • Магические методы:
    1. __add__: Сложение двух инвентарей (inv1 + inv2) объединяет их золото и списки предметов в один общий новый инвентарь.
    2. __sub__: Вычитание строки из инвентаря (inv - "Меч") удаляет данный предмет из списка (если он там есть) и возвращает новый инвентарь. Если предмета нет — возвращает инвентарь без изменений.
    3. __mul__: Умножение инвентаря на число (inv * 2) удваивает количество золота (персонаж получил бонус), но предметы остаются в единственном экземпляре. Возвращает новый инвентарь.

Решения для самопроверки дополнительных упражнений ​

Посмотреть подсказку/решение для Упражнения 1 (Деление ParcelBox)
python
# Допишите эти методы внутрь класса ParcelBox:

def __truediv__(self, divisor: float) -> "ParcelBox":
    if not isinstance(divisor, (int, float)) or divisor <= 0:
        raise ValueError("Делить можно только на положительное число!")
    return ParcelBox(f"{self.description} (Половина)", self.weight / divisor)

def __floordiv__(self, target_weight: float) -> int:
    if not isinstance(target_weight, (int, float)) or target_weight <= 0:
        raise ValueError("Целевой вес должен быть положительным числом!")
    # Возвращаем именно int, так как // возвращает целое количество
    return int(self.weight // target_weight)
Посмотреть решение Упражнения 3 (__mod__ для курьера)
python
def __mod__(self, limit: float) -> "ParcelBox":
    if not isinstance(limit, (int, float)) or limit <= 0:
        raise ValueError("Лимит курьера должен быть положительным числом!")
    
    # Вычисляем остаток веса
    leftover_weight = self.weight % limit
    return ParcelBox(f"Остаток от {self.description}", leftover_weight)
Посмотреть решение Упражнения 4 (Двустороннее сложение __add__ и __radd__)
python
def __add__(self, other):
    # Если складываем Коробку с Коробкой
    if isinstance(other, ParcelBox):
        combined_description = f"Сборная посылка ({self.description} + {other.description})"
        return ParcelBox(combined_description, self.weight + other.weight)
    
    # Если складываем Коробку с числом (добавляем вес)
    elif isinstance(other, (int, float)):
        return ParcelBox(self.description, self.weight + other)
    
    raise TypeError("Неподдерживаемый тип данных для сложения с ParcelBox")

def __radd__(self, other):
    # Вызывается при операции: Число + Коробка
    # Просто перенаправляем логику в обычный __add__
    return self.__add__(other)
Посмотреть решение Упражнения 5 (SquareBox и степени)
python
class SquareBox:
    def __init__(self, side_length: float) -> None:
        self.side_length: float = side_length

    def __pow__(self, power: int) -> float:
        if power == 2:
            return self.side_length ** 2
        elif power == 3:
            return self.side_length ** 3
        else:
            raise ValueError("Класс SquareBox поддерживает возведение только в степень 2 (площадь) или 3 (объем)!")
Посмотреть решение Упражнения 6 (Игровой инвентарь)
python
class Inventory:
    def __init__(self, gold: int, items: list[str]) -> None:
        self.gold: int = gold
        self.items: list[str] = items

    def __add__(self, other: "Inventory") -> "Inventory":
        if not isinstance(other, Inventory):
            raise TypeError("Инвентарь можно складывать только с другим инвентарем")
        return Inventory(self.gold + other.gold, self.items + other.items)

    def __sub__(self, item_to_remove: str) -> "Inventory":
        new_items = self.items.copy()
        if item_to_remove in new_items:
            new_items.remove(item_to_remove)
        return Inventory(self.gold, new_items)

    def __mul__(self, multiplier: int) -> "Inventory":
        if not isinstance(multiplier, int):
            raise TypeError("Умножать инвентарь можно только на целое число")
        return Inventory(self.gold * multiplier, self.items.copy())

    def __repr__(self) -> str:
        return f"Inventory(gold={self.gold}, items={self.items})"

Дополнительное упражнение: Сквозной трек «Римское Число» (RomanNumber) ​

В предыдущих домашних заданиях вы создали базовую структуру класса RomanNumber, которая умеет принимать римскую строку (например, "V" или "XIV"), хранить её и красиво выводить на экран.

Сегодня ваша задача — превратить этот класс в полноценный математический инструмент. Нам нужно сделать так, чтобы объекты класса умели складываться, вычитываться, умножаться и делиться между собой, автоматически выполняя конвертацию под капотом.

Функции-помощники для перевода чисел

Для упрощения кода и чтобы не тратить время на алгоритмы конвертации, добавьте эти готовые функции в самое начало вашего файла скрипта:

python
ROMAN_MAP = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
ARABIC_MAP = [(1000, 'M'), (900, 'CM'), (500, 'D'), (400, 'CD'), (100, 'C'), 
              (90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'), 
              (5, 'V'), (4, 'IV'), (1, 'I')]

def roman_to_int(roman: str) -> int:
    """Переводит римскую строку в арабское число (например, 'XIV' -> 14)."""
    total = 0
    prev_value = 0
    for char in reversed(roman):
        value = ROMAN_MAP[char]
        if value < prev_value:
            total -= value
        else:
            total += value
        prev_value = value
    return total

def int_to_roman(number: int) -> str:
    """Переводит арабское число в римскую строку (например, 14 -> 'XIV')."""
    if number <= 0:
        raise ValueError("В римской системе нет нуля и отрицательных чисел!")
    result = []
    for arabic, roman in ARABIC_MAP:
        while number >= arabic:
            result.append(roman)
            number -= arabic
    return "".join(result)

Часть 1: Сложение и вычитание (__add__, __sub__) ​

Реализуйте перегрузку операторов + и - для класса RomanNumber.

Требования:

  1. При сложении двух объектов (num1 + num2) класс должен перевести оба римских числа в обычные int, сложить их арабские значения, перевести результат обратно в римскую систему и вернуть новый объект RomanNumber.
  2. При вычитании (num1 - num2) логика аналогична.
  3. Обработка ошибок: Если в результате вычитания получается число 0 или меньше, метод должен выбросить ошибку ValueError("В римской системе нет чисел меньше I").
python
# Ожидаемое поведение:
a = RomanNumber("V")     # 5
b = RomanNumber("III")   # 3

c = a + b
print(c)  # Должно вывести: VIII (8)

d = a - b
print(d)  # Должно вывести: II (2)

Часть 2: Расширенная математика (__mul__, __truediv__, __floordiv__, __mod__, __pow__) ​

Добавьте поддержку всех остальных математических операторов, чтобы полностью закрыть таблицу встроенных методов Python.

Требования:

  1. Умножение (*) и Степень (**): Должны перемножать значения объектов или возводить их в степень, возвращая новый объект класса.
  2. Деление (/ и //):
    • Обычное деление (/) должно автоматически округлять результат до целого числа с помощью функции round(), так как дробных римских чисел не существует.
    • Целочисленное деление (//) должно отсекать дробную часть.
  3. Остаток от деления (%): Должен возвращать остаток. Если остаток равен нулю, метод выбрасывает ValueError (в римской системе нет нуля).
python
# Ожидаемое поведение:
x = RomanNumber("X")   # 10
y = RomanNumber("III") # 3

print(x * y)   # Должно вывести: XXX (30)
print(x // y)  # Должно вывести: III (10 // 3 = 3)
print(x ** y)  # Должно вывести: M (10 ** 3 = 1000)

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

Посмотреть эталонный код класса RomanNumber
python
class RomanNumber:
    """Класс для работы с Римскими числами и поддержки математических операций."""

    def __init__(self, roman_str: str) -> None:
        self.value: str = roman_str

    def __str__(self) -> str:
        return self.value

    def __repr__(self) -> str:
        return f"RomanNumber('{self.value}')"

    def __add__(self, other: "RomanNumber") -> "RomanNumber":
        if not isinstance(other, RomanNumber):
            raise TypeError("Операция применима только к Римским числам")
        arabic_sum = roman_to_int(self.value) + roman_to_int(other.value)
        return RomanNumber(int_to_roman(arabic_sum))

    def __sub__(self, other: "RomanNumber") -> "RomanNumber":
        if not isinstance(other, RomanNumber):
            raise TypeError("Операция применима только к Римским числам")
        arabic_sub = roman_to_int(self.value) - roman_to_int(other.value)
        if arabic_sub <= 0:
            raise ValueError("В римской системе нет чисел меньше I (нуля и отрицательных)")
        return RomanNumber(int_to_roman(arabic_sub))

    def __mul__(self, other: "RomanNumber") -> "RomanNumber":
        if not isinstance(other, RomanNumber):
            raise TypeError("Операция применима только к Римским числам")
        arabic_mul = roman_to_int(self.value) * roman_to_int(other.value)
        return RomanNumber(int_to_roman(arabic_mul))

    def __truediv__(self, other: "RomanNumber") -> "RomanNumber":
        if not isinstance(other, RomanNumber):
            raise TypeError("Операция применима только к Римским числам")
        arabic_div = round(roman_to_int(self.value) / roman_to_int(other.value))
        if arabic_div <= 0:
            raise ValueError("Результат деления меньше I, что недопустимо")
        return RomanNumber(int_to_roman(arabic_div))

    def __floordiv__(self, other: "RomanNumber") -> "RomanNumber":
        if not isinstance(other, RomanNumber):
            raise TypeError("Операция применима только к Римским числам")
        arabic_floor = roman_to_int(self.value) // roman_to_int(other.value)
        if arabic_floor <= 0:
            raise ValueError("Результат деления нацело меньше I, что недопустимо")
        return RomanNumber(int_to_roman(arabic_floor))

    def __mod__(self, other: "RomanNumber") -> "RomanNumber":
        if not isinstance(other, RomanNumber):
            raise TypeError("Операция применима только к Римским числам")
        arabic_mod = roman_to_int(self.value) % roman_to_int(other.value)
        if arabic_mod == 0:
            raise ValueError("Остаток от деления равен 0, но в римской системе нет нуля!")
        return RomanNumber(int_to_roman(arabic_mod))

    def __pow__(self, other: "RomanNumber") -> "RomanNumber":
        if not isinstance(other, RomanNumber):
            raise TypeError("Операция применима только к Римским числам")
        arabic_pow = roman_to_int(self.value) ** roman_to_int(other.value)
        return RomanNumber(int_to_roman(arabic_pow))