Перегрузка операторов
Перегрузка операторов — один из способов реализации полиморфизма, когда мы можем задать свою реализацию какого-либо метода в своём классе.
Например, у нас есть два класса:
В данном примере класс B наследует класс A, но переопределяет метод go, поэтому он имеет мало общего с аналогичным методом класса A.
Однако в python имеются методы, которые, как правило, не вызываются напрямую, а вызываются встроенными функциями или операторами.
Например, метод __init__ перегружает конструктор класса. Конструктор — создание экземпляра класса.
__new__(cls[, . ]) — управляет созданием экземпляра. В качестве обязательного аргумента принимает класс (не путать с экземпляром). Должен возвращать экземпляр класса для его последующей его передачи методу __init__.
__init__(self[, . ]) - как уже было сказано выше, конструктор.
__del__(self) - вызывается при удалении объекта сборщиком мусора.
__repr__(self) - вызывается встроенной функцией repr; возвращает "сырые" данные, использующиеся для внутреннего представления в python.
__str__(self) - вызывается функциями str, print и format. Возвращает строковое представление объекта.
__bytes__(self) - вызывается функцией bytes при преобразовании к байтам.
__format__(self, format_spec) - используется функцией format (а также методом format у строк).
__le__(self, other) - x ≤ y вызывает x.__le__(y).
__eq__(self, other) - x == y вызывает x.__eq__(y).
__ne__(self, other) - x != y вызывает x.__ne__(y)
__gt__(self, other) - x > y вызывает x.__gt__(y).
__ge__(self, other) - x ≥ y вызывает x.__ge__(y).
__hash__(self) - получение хэш-суммы объекта, например, для добавления в словарь.
__bool__(self) - вызывается при проверке истинности. Если этот метод не определён, вызывается метод __len__ (объекты, имеющие ненулевую длину, считаются истинными).
__getattr__(self, name) - вызывается, когда атрибут экземпляра класса не найден в обычных местах (например, у экземпляра нет метода с таким названием).
__setattr__(self, name, value) - назначение атрибута.
__delattr__(self, name) - удаление атрибута (del obj.name).
__call__(self[, args. ]) - вызов экземпляра класса как функции.
__len__(self) - длина объекта.
__getitem__(self, key) - доступ по индексу (или ключу).
__setitem__(self, key, value) - назначение элемента по индексу.
__delitem__(self, key) - удаление элемента по индексу.
__iter__(self) - возвращает итератор для контейнера.
__reversed__(self) - итератор из элементов, следующих в обратном порядке.
__contains__(self, item) - проверка на принадлежность элемента контейнеру (item in self).
Перегрузка арифметических операторов
__add__(self, other) - сложение. x + y вызывает x.__add__(y).
__sub__(self, other) - вычитание (x - y).
__mul__(self, other) - умножение (x * y).
__truediv__(self, other) - деление (x / y).
__floordiv__(self, other) - целочисленное деление (x // y).
__mod__(self, other) - остаток от деления (x % y).
__divmod__(self, other) - частное и остаток (divmod(x, y)).
__pow__(self, other[, modulo]) - возведение в степень (x ** y, pow(x, y[, modulo])).
__lshift__(self, other) - битовый сдвиг влево (x
__rshift__(self, other) - битовый сдвиг вправо (x >> y).
__and__(self, other) - битовое И (x & y).
__xor__(self, other) - битовое ИСКЛЮЧАЮЩЕЕ ИЛИ (x ^ y).
__or__(self, other) - битовое ИЛИ (x | y).
__rtruediv__(self, other),
__rfloordiv__(self, other),
__rdivmod__(self, other),
__rlshift__(self, other),
__rrshift__(self, other),
__ror__(self, other) - делают то же самое, что и арифметические операторы, перечисленные выше, но для аргументов, находящихся справа, и только в случае, если для левого операнда не определён соответствующий метод.
Например, операция x + y будет сначала пытаться вызвать x.__add__(y), и только в том случае, если это не получилось, будет пытаться вызвать y.__radd__(x). Аналогично для остальных методов.
__itruediv__(self, other) - /=.
__ifloordiv__(self, other) - //=.
__ipow__(self, other[, modulo]) - **=.
__ilshift__(self, other) -
__irshift__(self, other) - >>=.
__neg__(self) - унарный -.
__pos__(self) - унарный +.
__abs__(self) - модуль (abs()).
__invert__(self) - инверсия (~).
__complex__(self) - приведение к complex.
__int__(self) - приведение к int.
__float__(self) - приведение к float.
__round__(self[, n]) - округление.
__enter__(self), __exit__(self, exc_type, exc_value, traceback) - реализация менеджеров контекста.
Рассмотрим некоторые из этих методов на примере двухмерного вектора, для которого переопределим некоторые методы:
В заключение хочу сказать, что перегрузка специальных методов - вещь хорошая, но не стоит ей слишком злоупотреблять. Перегружайте их только тогда, когда вы уверены в том, что это поможет пониманию программного кода.
Для вставки кода на Python в комментарий заключайте его в теги
- Книги о Python
- GUI (графический интерфейс пользователя)
- Курсы Python
- Модули
- Новости мира Python
- NumPy
- Обработка данных
- Основы программирования
- Примеры программ
- Типы данных в Python
- Видео
- Python для Web
- Работа для Python-программистов
Перегрузка операторов в Python
Один и тот же оператор в Python по-разному ведет себя с разными типами. Например, оператор + в зависимости от типа операндов может складывать 2 числа, сливать 2 списка или объединять 2 строки. Когда-нибудь задумывались, почему так происходит? Дело в перегрузке операторов в Python.
Перегрузка оператора — это возможность переопределять различные операторы в классах, то есть менять операции, которые они выполняют, в зависимости от контекста.
Давайте рассмотрим пользовательский класс Point . Он должен моделировать точку в двумерной системе координат.
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y # задаем координаты точек p1, p2 p1 = Point(1, 2) p2 = Point(2, 3) # пытаемся вывести сумму точек print(p1+p2)
Traceback (most recent call last):
File "", line 9, in
print(p1+p2)
TypeError: unsupported operand type(s) for +: 'Point' and 'Point'
Python не знает, как «складывать» два объекта Point . Чтобы объяснить ему это, нужно задать поведение оператора + с операндами этого типа.
Тут-то и понадобится перегрузка оператора. Но сначала давайте познакомимся со специальными функциями в Python. Это поможет понять, как работает перегрузка операторов.
Специальные функции
Специальные функции классов начинаются с двойного подчеркивания __ . Их еще называют магическими методами.
Это не обычные методы, которые мы определяем в классе. В коде выше мы уже использовали специальную функцию __init__() . Она вызывается каждый раз, когда мы создаем новый объект класса Point .
С помощью специальных методов можно сделать наш класс совместимым со встроенными функциями.
Мы хотим, чтобы функция print() выводила на экран координаты объекта Point. Сейчас print( ) печатает что-то не то. Мы можем определить метод __str__() в нашем классе, который будет контролировать правильный вывод объекта. Давайте посмотрим, как это сделать.
class Point: def __init__(self, x = 0, y = 0): self.x = self.y = y def __str__(self): return "(,)".format(self.x,self.y)
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "(, )".format(self.x, self.y) # задаем координаты точки p1 p1 = Point(2, 3) # выводим точку — ее координаты print(p1)
Так-то лучше. Но оказывается, когда мы используем встроенные функции str() или format() , вызывается этот же метод.
Теперь, когда вы используете str(p1) или format(p1) , Python вызывает специальный метод p1.__str__() .
Давайте вернемся к перегрузке операторов.
Перегрузка оператора +
Чтобы перегрузить оператор + , нам нужно реализовать специальный метод __add__() в нашем классе. Внутри него мы можем делать все, что захотим. Но разумнее будет вернуть объект Point в виде координатной суммы. Так и сделаем.
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "(,)".format(self.x, self.y) def __add__(self, other): x = self.x + other.x y = self.y + other.y return Point(x, y)
Теперь еще раз попробуем операцию сложения.
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "(,)".format(self.x, self.y) def __add__(self, other): x = self.x + other.x y = self.y + other.y return Point(x, y) # задаем координаты точек p1, p2 p1 = Point(1, 2) p2 = Point(2, 3) print(p1+p2)
Когда мы используем p1 + p2 , Python вызывает p1.__add__(p2) , а тот, в свою очередь, вызывает Point.__add__(p1,p2) . После этого операция сложения выполняется указанным нами способом.
Точно так же мы можем перегрузить и другие операторы. Вот, какие для этого понадобятся специальные функции:
Специальная функция
Перегрузка операторов в Python
Перегрузка операторов в Python — это возможность определить, как должны работать операторы для созданных вами объектов. Если вам не хватает функциональности встроенных типов данных, Python позволяет программисту переопределять поведение операторов для собственных классов.
Например, мы создали класс автомобиля, и хотим иметь возможность узнать какой из них быстрее.
class Auto: def __init__(self, speed): self.speed = speed def __gt__(self, other): return self.speed > other.speed def __lt__(self, other): return self.speed < other.speed def __eq__(self, other): return self.speed == other.speed
a = Auto(100) b = Auto(120) a > b # вернет False a < b # вернет True a == b # вернет False
fastest = max(a, b) slowest = min(a, b)
Перегрузка операторов осуществляется путем реализации специальных методов, называемых методами перегрузки операторов или магическими методами.
Эти методы начинаются и заканчиваются двойным подчеркиванием, например, __add__ или __lt__. Каждый метод перегрузки оператора соответствует определенному оператору и определяет его поведение для объектов данного класса.
Мы можем перегрузить следующие типы операторов.
Перегрузка арифметических операторов в Python
Оператор
Описание
__add__(self, other)
Перегрузка оператора сложения (+)
__sub__(self, other)
Перегрузка оператора вычитания (-)
__mul__(self, other)
Перегрузка оператора умножения (*)
__truediv__(self, other)
Перегрузка оператора деления (/)
__floordiv__(self, other)
Перегрузка оператора целочисленного деления (//)
__mod__(self, other)
Перегрузка оператора деления по модулю (%)
__pow__(self, other)
Перегрузка оператора возведения в степень (**)
Перегрузка операторов сравнения в Python
Оператор
Описание
__lt__(self, other)
Перегрузка оператора меньше чем ( __le__(self, other)
Перегрузка оператора меньше чем или равно ( __eq__(self, other)
Перегрузка оператора равно (==)
__ne__(self, other)
Перегрузка оператора не равно (!=)
__gt__(self, other)
Перегрузка оператора больше (>)
__ge__(self, other)
Перегрузка оператора больше чем или равно (>=)
Перегрузка побитовых операторов в Python
Оператор
Описание
__lshift__(self, other)
Перегрузка оператора побитовый сдвиг влево ( __rshift__(self, other)
Перегрузка оператора побитовый сдвиг вправо (>>)
__and__(self, other)
Перегрузка оператора побитовое И (&)
__or__(self, other)
Перегрузка оператора побитовое ИЛИ (|)
__xor__(self, other)
Перегрузка оператора побитовое исключительный ИЛИ (^)
__invert__(self, other)
Перегрузка оператора побитовый НЕ (~)
Благодаря перегрузке операторов в Python, мы можем использовать привычные операторы сложения, вычитания, умножения и сравнения для созданных нами объектов. Это делает код более читаемым и интуитивно понятным, а также позволяет расширять функциональность встроенных операторов для пользовательских типов данных.