Operator overloading Python

Welcome to a tutorial on Operator Overloading in Python. In python, operator overloading is used to perform specific operations on the given operands. Also, operations that any particular operator will perform on a predefined data type are already defined in Python language.

All types of an operator can be used in a different way for different types of operands. E.g. the + operator is used for adding two integers to obtain an integer as a result; but if it is used with float operands, then the result is a float value; and used with string operands, then it concatenates the two operands provided.

Thus, the different behavior of a single operator for different types of operands is referred to as Operator Overloading. Check out the example below:

>>> x=10
>>> y=20
>>> x+y
30

>>> z=10.4
>>> x+z
20.4

>>> s1 = 'hello '
>>> s2 = 'world'
>>> s1+s2
'hello world'

Can + Operator Add anything?

The answer is a typical No, it can't. But we can use the + operator to add two integer values, two float values, or to concatenate two strings only: because you can use the + operator to add two objects of a class. The + operator can add two integer values, and two float values or can be used to concatenate two strings only because these behaviors have been defined in python.

So if you want to use the same operator to add two objects of some user-defined class then you will have to define that behavior yourself and inform python about that.

Check out the example below for clarification. We will create a class and try to use the + operator to add two objects to that class.

class Complex:
    def __init__(self, r, i):
        self.real = r
        self.img = i

c1 = Complex(5,3)
c2 = Complex(2,4)
print("sum = ", c1+c2)

From the above example, you can see that the + operator is not supported in a user-defined class. However, you can do the same by overloading the + operator for our class Complex. 

Special Functions in Python

In Python, Special functions are the functions that are used to perform special tasks. These special functions have '__' as prefix and suffix to their name just like the '__init__()’ method, a special function. Below are some special functions used for overloading operators.

Mathematical Operator

The table shows the names of special functions used to overload the mathematical operators.

Assignment Operator

The table shows the names of special functions used to overload the assignment operators.

Relational Operator

The table shows the names of special functions used to overload the relational operators.

Let’s check out examples for better understanding.

Overloading + operator

In the example below, we will overload the operator + for our class complex.

class Complex:
    # defining init method for class
    def __init__(self, r, i):
        self.real = r
        self.img = i

    # overloading the add operator using special function
    def __add__(self, sec):
        r = self.real + sec.real
        i = self.img + sec.img
        return complx(r,i)

    # string function to print object of Complex class
    def __str__(self):
        return str(self.real)+' + '+str(self.img)+'i'

c1 = Complex(5,3)
c2 = Complex(2,4)
print("sum = ",c1+c2)

Output:

sum =  7 + 7i

From the above example, the function __add__() is used to overload the + operator meaning that the + operator is used with two Complex class objects then the function __add__() is called.

__str__() is another special function that is typically used to provide a format of the object that is good for printing.

Overloading < operator

To overload, the less than operator, for us to we can easily compare two Complex class objects' values by using the less than operator <.

class Complex:
    # defining init method for class
    def __init__(self, r, i):
        self.real = r
        self.img = i

    # overloading the less than operator using special function
    def __lt__(self, other):
        if self.real < other.real:
            return true
        elif self.real == other.real:
            if self.img < other.real:
                return True
            else:
                return False
        else:
            return False

    # string function to print object of Complex class
    def __str__(self):
        return str(self.real)+' + '+str(self.img)+'i'

c1 = Complex(5,3)
c2 = Complex(2,4)
print("Is c1 less than c2: ",c1<c2)

Output:

Is c1 less than c2:  False

We already know, to overload the less than operator, we have to define the __lt__ special function in our class.

Considering the requirement of comparing the class object, you can therefore define the logic for the special functions for overriding an operator. From the example above, we have given precedence to the real part of the complex number, but, if it is less, then the whole complex number is less, if that is equal then we check for the imaginary part.

Conclusively, overloading operators is easy in python using the special functions and is less confusion.