Python - Operator Overloading

We can use the same operator for multiple purposes. This concept is called Operator Overloading.

For example, the + operator is already overloaded for several built-in Python types:

• For numbers, + performs arithmetic addition.
• For strings, + performs concatenation.
• For lists, + performs list concatenation.

Python also allows programmers to define how operators should work with their own class objects. This is done with special methods called Magic Methods.

Consider a class named Book where each object contains the number of pages.

Suppose we create two Book objects and try to add them using the + operator:

TypeError: unsupported operand type(s) for +: 'Book' and 'Book'

Python already knows how to use + with built-in types such as integers, floats, strings, and lists.

But Python does not automatically know what + should mean for two Book objects. Should it add their page counts? Should it combine the objects? Python cannot decide automatically, so it raises a TypeError.

To solve this problem, we have to overload the + operator for the Book class.

Python provides special methods for operator overloading. These special methods are commonly called:

• Magic Methods
• Special Methods
• Dunder Methods

The word dunder means double underscore.

No output captured.

Whenever we use an operator with objects, Python internally calls the corresponding magic method.

Suppose we write:

No output captured.

Internally, Python converts b1 + b2 into:

No output captured.

• b1 is available as self.
• b2 is available as other.

Using these references, we can define exactly how two Book objects should be added.

The __add__() method tells Python what should happen when the + operator is used between two Book objects.

When b1 + b2 executes, Python internally calls b1.__add__(b2). Inside the method, self.pages is 100 and other.pages is 200, so the result is 300.

Operator	Magic Method	Example
+	__add__()	a + b
-	__sub__()	a - b
*	__mul__()	a * b
/	__truediv__()	a / b
//	__floordiv__()	a // b
%	__mod__()	a % b
**	__pow__()	a ** b
+=	__iadd__()	a += b
-=	__isub__()	a -= b

Python allows us to overload comparison operators for programmer-defined class objects.

For every comparison operator, Python provides a corresponding magic method:

• The > operator uses __gt__().
• The <= operator uses __le__().
• The == operator uses __eq__().
• The != operator uses __ne__().

Operator	Magic Method
<	__lt__()
<=	__le__()
>	__gt__()
>=	__ge__()
==	__eq__()
!=	__ne__()

The following program overloads the > and <= operators for Student objects. The comparison is performed based on the students' marks.

10>20 = False
s1>s2= False
s1=s2= False

s1 > s2 internally calls s1.__gt__(s2), which compares 100 with 200 and returns False.

s1 <= s2 internally calls s1.__le__(s2), which checks whether 100 is less than or equal to 200 and returns True.

The < and >= comparisons work through Python's reflected rich-comparison protocol: s1 < s2 is answered by asking whether s2 > s1 is true, and s1 >= s2 is answered by asking whether s2 <= s1 is true.

Python allows us to overload the multiplication operator * for programmer-defined objects.

The magic method corresponding to the * operator is __mul__().

In this example, we use an Employee class and a TimeSheet class to calculate the employee's monthly salary based on the salary value and the number of working days.

When e * t executes, Python internally calls e.__mul__(t).

Inside the method:

• self refers to the Employee object e, so self.salary is 500.
• other refers to the TimeSheet object t, so other.days is 25.

The method returns 500 * 25, which is 12500.

Expression	Internal Method Call
a + b	a.__add__(b)
a - b	a.__sub__(b)
a * b	a.__mul__(b)
a / b	a.__truediv__(b)
a > b	a.__gt__(b)
a <= b	a.__le__(b)