На этом шаге мы рассмотрим особенности реализации перегрузки операторов.
Перегрузка операторов позволяет экземплярам классов участвовать в обычных операциях. Чтобы перегрузить оператор, необходимо в классе определить метод со специальным названием. Для перегрузки математических операторов используются следующие методы:
- x + y - сложение: x.__add__(y);
- y + x - сложение (экземпляр класса справа): x.__radd__(y);
- x += y - сложение и присваивание: x.__iadd__(y);
- x - y - вычитание: x.__sub__(y);
- y - x - вычитание (экземпляр класса справа): x.__rsub__(y);
- x -= y - вычитание и присваивание: x.__isub__(y);
- x * y - умножение: x.__mul__(y);
- y * x - умножение (экземпляр класса справа): x.__rmul__(y);
- x *= y - умножение и присваивание: x.__imul__(y);
- x / у - деление: x.__truediv__(y);
- y / x - деление (экземпляр класса справа): x.__rtruediv__(y);
- x /= y - деление и присваивание: x.__itruediv__(y);
- x // y - деление с округлением вниз: x.__f loordiv__(y);
- y // x - деление с округлением вниз (экземпляр класса справа): x._rfloordiv__(y);
- x //= y - деление с округлением вниз и присваивание: x.__ifloordiv__(y);
- x % y - остаток от деления: x.__mod__(y);
- y % x - остаток от деления (экземпляр класса справа): x.__mod__(y);
- x %= y - остаток от деления и присваивание: x.__imod__(y);
- х ** у - возведение в степень: x.__pow__(y);
- y ** x - возведение в степень (экземпляр класса справа): x.__rpow__(y);
- x **= y - возведение в степень и присваивание: x.__ipow__(y);
- -х - унарный минус: х.__neg__();
- +х - унарный плюс: х.__pos__();
- abs (x) - абсолютное значение: х.__abs__().
Пример перегрузки математических операторов:
class MyClass: def __init__ (self, y): self.x = y def __add__ (self, y): # Перегрузка оператора + print("Экземпляр слева") return self.x + y def __radd__(self, y): # Перегрузка оператора + print("Экземпляр справа") return self.x + y def __iadd__(self, y): # Перегрузка оператора += print("Сложение с присваиванием") self.x += y return self c = MyClass(50) print(c + 10) # Выведет: Экземпляр слева 60 print(20 + c) # Выведет: Экземпляр справа 70 c += 30 # Выведет: Сложение с присваиванием print (c.x) # Выведет: 80
Результат работы приложения:
Экземпляр слева
60
Экземпляр справа
70
Сложение с присваиванием
80
Методы перегрузки двоичных операторов:
- ~х - двоичная инверсия: х.__invert__();
- х & у - двоичное И: х.__and__(у);
- у & х - двоичное И (экземпляр класса справа): х.__rand__(у);
- x &= у - двоичное И и присваивание: х.__iand__(у);
- х | у - двоичное ИЛИ: х.__or__(у);
- у | х - двоичное ИЛИ (экземпляр класса справа): х.__ror__(у);
- х |= у - двоичное ИЛИ и присваивание: х.__ior__(у);
- х ^ у - двоичное исключающее ИЛИ: х.__хоr__(у);
- у ^ х - двоичное исключающее ИЛИ (экземпляр класса справа): х.__rxor__(у);
- х ^= у - двоичное исключающее ИЛИ и присваивание: х.__ixor__(у);
- х << у - сдвиг влево: х.__lshift__(у);
- у << х - сдвиг влево (экземпляр класса справа): х.__rlshift__(у);
- х <<= у - сдвиг влево и присваивание: х.__ilshift__(y);
- х >> у - сдвиг вправо: х.__rshift__(у);
- у >> х - сдвиг вправо (экземпляр класса справа): х.__rrshift__(y);
- х >>= у - сдвиг вправо и присваивание: х.__irshift__(у).
Перегрузка операторов сравнения производится с помощью следующих методов:
- х == у - равно: х.__eq__(у);
- х != у - не равно: х.__ne__(у);
- х < у - меньше: х.__it__(у);
- х > у - больше: х.__gt__(у);
- х <= у - меньше или равно: х.__lе__(у);
- х >= у - больше или равно: х.__ge__(у);
- у in х - проверка на вхождение: х.__contains__(у).
Приведем пример перегрузки операторов сравнения:
class MyClass: def __init__ (self): self.x = 50 self.arr = [1, 2, 3, 4, 5] def __eq__ (self, y): # Перегрузка оператора == return self.x == y def __contains__ (self, y): # Перегрузка оператора in return y in self.arr c = MyClass() print("Равно" if c == 50 else "He равно") # Выведет: Равно print("Равно" if c == 51 else "He равно") # Выведет: Не равно print("Есть" if 5 in c else "Нет") # Выведет: Есть
Результат работы приложения:
Равно
He равно
Есть
На следующем шаге мы рассмотрим статические методы и методы класса.
