Существует эта концепция ООП, называемая «полиморфизмом», которая встречается в двух формах, а именно «статический полиморфизм» и «динамический полиморфизм». В этой статье я больше сосредоточусь на статическом полиморфизме, так как перегрузка операторов подпадает под эту категорию. Другой тип статического полиморфизма — перегрузка функций.

Хотя это функция или оператор, перегружающий основной смысл обоих типов, заключается в том, чтобы разрешить статически (поскольку эти два относятся к статическому полиморфизму) разные формы для одного и того же объекта. При перегрузке функций объектом является «Функция», тогда как при перегрузке оператора объектом является «Оператор».

Впервые я столкнулся с «операторской перегрузкой» во время учебы в лаборатории CPP. Тогда я был очарован и продолжал следить за этой концепцией. Эта концепция не является чем-то полностью из нашей жизни, даже многие современные языки программирования, ориентированные на ООП, поддерживают частичную перегрузку оператора оператором, таким как «+». Просто подумайте, как работает оператор «+», когда он используется между двумя числами, и тот же оператор работает, когда он используется между двумя строками. В первом случае выполняется «Сложение», а во втором — «Конкатенация».

Такой язык, как JAVA, который считается языком, не поддерживающим перегрузку операторов, обеспечивает упомянутую выше неявную перегрузку для оператора «+». Для этого очевиден следующий код.

public class HelloWorld{
public static void main(String []args){
         String s = new String("hello");
         String p = new String("hi");
         System.out.println(s+" "+p);
         int a = 5, b = 4;
         System.out.println(a+b);
     }
}

Вывод для кода:

hello hi
9

Теперь мой интерес направлен на то, чтобы найти такие же возможности в «Python». Следующая программа иллюстрирует неявную перегрузку оператора в python:

s = "Hello"
p = "hi"
print(s+" "+p)
s = 5
p = 4
print(s+p)
s = [1,2,3]
p = [4,5,6]
print(s+p)

Поскольку python — это «язык с динамической типизацией», я могу использовать одни и те же переменные, и на основе контекста интерпретатор выбирает тип переменных, и в зависимости от типа переменных поведение оператора «+» изменяется. Следующий вывод показывает изменение.

Hello hi
9
[1, 2, 3, 4, 5, 6]

Но «Это то, что python может делать в контексте перегрузки операторов?» — это мой следующий вопрос. Такие языки, как Java, которые считаются языками, не поддерживающими перегрузку операторов, поддерживают эту неявную перегрузку операторов. Итак, есть ли что-нибудь, что python может сделать больше в контексте перегрузки операторов? Определенно, большое ДА.

Мы можем использовать/определять поведение операторов в контексте пользовательских объектов. Следующий пример иллюстрирует это.

Рассмотрим сценарий, в котором у нас есть Пузырь идеальной сферической формы с размерным объемом (в некоторой идеальной вселенной), и в той же Вселенной, если два Пузыря сталкиваются, они сливаются и образуют больший Пузырь, объем которого равен сумме обоих пузырей. Пузыри. В следующем примере показана операция Python для этого сценария.

class Bubble:
    def __init__(self, volume):
        self.__volume = volume

    # built in function that helps to override addition operator
    def __add__(self, bubble2):
        return self.__volume + bubble2.__volume


# bubble 1
b1 = Bubble(20)
# bubble 2
b2 = Bubble(30)

# merging of two bubbles on collision
print("resultant volume on merging two bubbles is:", b1 + b2)

Вывод этой программы

resultant volume on merging two bubbles is: 50

Это показывает, как я перегрузил поведение «+» и заставил его добавлять объемы пузырьков. Точно так же существуют другие встроенные функции, которые помогают перегружать различные другие операторы.