Appearance
Магические методы математических операторов
В Python вы можете перегружать поведение стандартных математических операторов (+, -, * и т.д.) для своих собственных классов. Это делается с помощью специальных дандер-методов (double underscore). Когда Python видит выражение a + b, он внутри себя вызывает метод a.__add__(b).
В этом уроке мы разберем, как применить математику к нашему классу Почтовой Коробки (ParcelBox), какие операторы имеют для неё физический смысл, а какие мы вынесем в упражнения.
1. Справочник математических операторов в Python
| Оператор | Выражение | Внутренний вызов | Метод для реализации в классе |
|---|---|---|---|
| Сложение | v1 + v2 | v1.__add__(v2) | def __add__(self, other): |
| Вычитание | v1 - v2 | v1.__sub__(v2) | def __sub__(self, other): |
| Умножение | v1 * v2 | v1.__mul__(v2) | def __mul__(self, other): |
| Возведение в степень | v1 ** v2 | v1.__pow__(v2) | def __pow__(self, other): |
| Деление | v1 / v2 | v1.__truediv__(v2) | def __truediv__(self, other): |
| Целочисленное деление | v1 // v2 | v1.__floordiv__(v2) | def __floordiv__(self, other): |
| Остаток от деления | v1 % v2 | v1.__mod__(v2) | def __mod__(self, other): |
2. Физический смысл математики для Почтовой Коробки
Не все операторы логично применять к физической коробке. Например, возведение коробки в степень или деление коробки на коробку не имеют понятного жизненного смысла. Однако некоторые операторы подходят идеально:
- Сложение (
+) — Объединение посылок: Если мы складываем две коробки, логично получить новую большую коробку, вес которой равен сумме весов двух исходных, а содержимое объединяется. - Вычитание (
-) — Извлечение веса/вещей: Если из коробки вычесть число, мы можем сымитировать разгрузку (уменьшение текущего веса). - Умножение (
*) — Масштабирование (опт): Если коробку умножить на число (например, на 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 поддержку деления на число:
- Реализуйте обычное деление
__truediv__(self, divisor). Командаbox / 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__:
- Измените
__add__так, чтобы выражениеbox + 2.0(коробка + число) увеличивало вес коробки на 2.0 кг и возвращало новую коробку. - Реализуйте
__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 — список названий предметов, строк). - Магические методы:
__add__: Сложение двух инвентарей (inv1 + inv2) объединяет их золото и списки предметов в один общий новый инвентарь.__sub__: Вычитание строки из инвентаря (inv - "Меч") удаляет данный предмет из списка (если он там есть) и возвращает новый инвентарь. Если предмета нет — возвращает инвентарь без изменений.__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.
Требования:
- При сложении двух объектов (
num1 + num2) класс должен перевести оба римских числа в обычныеint, сложить их арабские значения, перевести результат обратно в римскую систему и вернуть новый объектRomanNumber. - При вычитании (
num1 - num2) логика аналогична. - Обработка ошибок: Если в результате вычитания получается число
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.
Требования:
- Умножение (
*) и Степень (**): Должны перемножать значения объектов или возводить их в степень, возвращая новый объект класса. - Деление (
/и//):- Обычное деление (
/) должно автоматически округлять результат до целого числа с помощью функцииround(), так как дробных римских чисел не существует. - Целочисленное деление (
//) должно отсекать дробную часть.
- Обычное деление (
- Остаток от деления (
%): Должен возвращать остаток. Если остаток равен нулю, метод выбрасывает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))