Python Operator Overloading

We know that an operator is a symbol that performs some action. For example, '+' is an operator that performs addition operation when used on numbers. When an operator can perform different actions, it is said to exhibit polymorphism.

Python Operator Overloading Examples

#Using + operator on objects 
class BookX: 
   def __init__(self, pages): 
      self.pages = pages 
class BookY:
   def __init__(self, pages): 
      self.pages = pages 
b1 = BookX(100) 
b2 = BookY(150) 
print('Total pages=', b1+b2)

Python Operator Overloading Example using same Class Objects

#Using + operator on objects 
class BookX: 
   def __init__(self, pages): 
      self.pages = pages 
class BookY:
   def __init__(self, pages): 
      self.pages = pages 
b1 = BookX(100) 
b2 = BookY(150) 
print('Total pages=', b1+b2)

We can overload the '+' operator to act upon the two objects and perform addition operation on the contents of the objects. That means we are giving additional task to the '+' operator.

Python Operator Overloading Example using different Class Objects

#overloading + operator to act on objects 
class BookX: 
   def __init__(self, pages): 
      self.pages = pages 
   def __add__(self, other): 
      return self.pages+other.pages 
class BookY: 
   def __init__(self, pages): 
      self.pages = pages 
b1 = BookX(100) 
b2 = BookY(150) 
print('Total pages=', b1+b2)

Following Table summarizes important operators and their corresponding internal methods that can be overridden to act on objects. These methods are called magic methods.

Operator	Magic method
+	object._add_(self,other)
-	object._sub_(self,other)
*	object._mul_(self,other)
/	object._div_(self,other)
//	object._floordiv_(self,other)
%	object._mod_(self,other)
**	object._pow_(self,other[,modulo])
+=	object._iadd_(self,other)
-=	object._isub_(self,other)
*=()	object._imul_(self,other)
/=	object._idiv_(self,other)
//=	object._ifloordiv_(self,other)
%=	object._imod_(self,other[,modulo])
**=	object._ipow_(self,other)
<	object._lt_(self,other)
<=	object._le_(self,other)
>	object._gt_(self,other)
>=	object._ge_(self,other)
==	object._eq_(self,other)
!=	object._ne_(self,other)

If we want to overload the greater than (>) operator. For this purpose the magic method __gt__() should be overridden. For example,

def __gt__(self, other):

return self.pages>other.pages

Python greater than (>) operator overload on class objects

#overloading > operator 
class Ramayan: 
   def __init__(self, pages): 
      self.pages = pages 
   def __gt__(self, other): 
      return self.pages>other.pages 
class Mahabharat: 
   def __init__(self, pages): 
      self.pages = pages 
b1 = Ramayan(1000) 
b2 = Mahabharat(1500) 
if(b1>b2): 
   print('Ramayan has more pages') 
else: 
   print('Mahabharat has more pages')

Python multiplication operator (*) overload on class objects

#overloading the * operator 
class Employee: 
   def __init__(self, name, salary): 
      self.name = name 
      self.salary = salary 
   def __mul__(self, other): 
      return self.salary*other.days 
class Attendance: 
   def __init__(self, name, days): 
      self.name = name 
      self.days = days 
x1 = Employee('Srinu', 500.00) 
x2 = Attendance('Srinu', 25) 
print('This month salary=', x1*x2)

Inheritance