Operator Overloading in Python

Last Updated on March 10, 2023 by Abhishek Sharma

Python is a dynamically typed, high-level programming language that supports object-oriented programming. One of the features of object-oriented programming is operator overloading, which allows programmers to change the behavior of built-in operators. Operator Overloading in Python is a powerful tool that can be used to create more expressive and concise code.

Let us understand Operator Overloading in Python in detail.

What is Operator Overloading in Python?

Operator overloading is the ability to change the behavior of operators when used with user-defined classes or objects. In Python, operators are special functions that can be defined to modify the behavior of built-in operators, such as addition or multiplication. Operator overloading allows programmers to use built-in operators with user-defined objects, making code more expressive and concise.

Why use Operator Overloading in Python?

There are several reasons to use operator overloading in Python:

• It allows programmers to use built-in operators with user-defined objects, making code more expressive and concise.
• It can simplify code by allowing complex operations to be expressed in a single line of code.
• It can improve performance by allowing Python to use built-in operators, which are optimized for performance.
• It can make code more readable by allowing operators to be used in a natural way.

How to Overload Operators in Python?

To overload an operator in Python, you need to define a special method that corresponds to the operator. The special method should have a specific name and signature that corresponds to the operator.

For example, to overload the addition operator, you need to define the add() method:

class MyClass:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        return MyClass(self.value + other.value)

In this example, the add() method takes two arguments, self and other, and returns a new instance of MyClass with the sum of the value attributes of self and other.

You can use the overloaded operator like this:

a = MyClass(1)
b = MyClass(2)
c = a + b
print(c.value) 

This will give out output as “3”.

The following table shows some special methods for Operator Overloading in Python.

Common Examples of Operator Overloading in Python

Here are some common examples of Operator Overloading in Python:

Example 1: Adding Two Objects

Adding two objects of a user-defined class can be accomplished by overloading the add method:

Code:

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y


    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)


p1 = Point(1, 2)
p2 = Point(3, 4)


p3 = p1 + p2
print(p3.x, p3.y)

Output:

4 6

Explanation:
In this example, we define a Point class with an add method that takes another Point object as an argument and returns a new Point object whose x and y coordinates are the sum of the corresponding coordinates of the two input points. We then create two Point objects and add them together using the + operator, which calls the add method.

Example 2: Comparing Two Objects**

Comparing two objects of a user-defined class can be accomplished by overloading the comparison operators (lt, le, eq, ne, gt, and ge):

Code:

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height


    def __lt__(self, other):
        return self.width * self.height < other.width * other.height


    def __eq__(self, other):
        return self.width == other.width and self.height == other.height


r1 = Rectangle(2, 3)
r2 = Rectangle(3, 4)
print(r1 < r2)   # This will Output: True
print(r1 == r2)  # This will Output: False

Output:

True
False

Explanation:
In this example, we define a Rectangle class with lt and eq methods that compare rectangles based on their area (lt) and dimensions (eq). We then create two Rectangle objects and compare them using the < and == operators, which call the corresponding methods.

Example 3: Multiplying an Object by a Scalar**

Multiplying an object of a user-defined class by a scalar (i.e., an integer or floating-point number) can be accomplished by overloading the mul method:

Code:

class Vector:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z


    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar, self.z * scalar)


v1 = Vector(1, 2, 3)
v2 = v1 * 2
print(v2.x, v2.y, v2.z)

Output:

2 4 6

Explanation:
In this example, we define a Vector class with an mul method that multiplies the vector by a scalar. We then create a Vector object and multiply it by an integer using the * operator, which calls the mul method.

Example 4: Converting an Object to a String**

One common example of operator overloading in Python is the str() method, which allows us to convert an object to a string representation.

Code:

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year


    def __str__(self):
        return f"{self.year} {self.make} {self.model}"


car1 = Car("Toyota", "Corolla", 2023)
print(car1)

Output:

2023 Toyota Corolla

Explanation:
In this example, we define a Car class that has a make, model, and year attribute. We also define the str() method, which returns a string representation of the Car object. When we call the print() function on the car1 object, Python automatically calls the str() method and prints the string representation of the object, which is "2022 Toyota Corolla". Without the str() method, if we call print(car1), it would just print the memory address of the object (e.g.,