{"id":2588,"date":"2021-10-19T03:10:29","date_gmt":"2021-10-19T03:10:29","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=2588"},"modified":"2025-03-31T10:08:45","modified_gmt":"2025-03-31T10:08:45","slug":"python-operator-overloading","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-oop\/python-operator-overloading\/","title":{"rendered":"Python Operator Overloading"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn Python operator overloading and how to use it to make your objects work with built-in operators.<\/p>\n\n\n\n

Introduction to the Python operator overloading #<\/a><\/h2>\n\n\n\n

Suppose you have a 2D point class<\/a> with x and y coordinate attributes<\/a>:<\/p>\n\n\n

class<\/span> Point2D<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, x, y)<\/span>:<\/span>\n        self.x = x\n        self.y = y\n\n    def<\/span> __str__<\/span>(self)<\/span>:<\/span>\n        return<\/span> f'({self.x}<\/span>,{self.y}<\/span>)'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To add two Point2D<\/code> objects, you can define an add()<\/code> method as follows:<\/p>\n\n\n
class<\/span> Point2D<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, x, y)<\/span>:<\/span>\n        self.x = x\n        self.y = y\n\n    def<\/span> __str__<\/span>(self)<\/span>:<\/span>\n        return<\/span> f'({self.x}<\/span>,{self.y}<\/span>)'<\/span>\n\n    def<\/span> add<\/span>(self, point)<\/span>:<\/span>\n        if<\/span> not<\/span> isinstance(point, Point2D):\n            raise<\/span> ValueError('The other must be an instance of the Point2D'<\/span>)\n\n        return<\/span> Point2D(self.x + point.x, self.y + point.y)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The add()<\/code> method raises an error if the point is not an instance of the Point2D<\/code> class. Otherwise, it returns a new Point2D<\/code> object whose x and y coordinates are the sums of x<\/code> and y<\/code> coordinates of two points.<\/p>\n\n\n\n
The following creates two instances of the Point2D<\/code> class and use the add()<\/code> method to add two points:<\/p>\n\n\n
class<\/span> Point2D<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, x, y)<\/span>:<\/span>\n        self.x = x\n        self.y = y\n\n    def<\/span> __str__<\/span>(self)<\/span>:<\/span>\n        return<\/span> f'({self.x}<\/span>,{self.y}<\/span>)'<\/span>\n\n    def<\/span> add<\/span>(self, point)<\/span>:<\/span>\n        if<\/span> not<\/span> isinstance(point, Point2D):\n            raise<\/span> ValueError('The other must be an instance of the Point2D'<\/span>)\n\n        return<\/span> Point2D(self.x + point.x, self.y + point.y)\n\na = Point2D(10<\/span>, 20<\/span>)\nb = Point2D(15<\/span>, 25<\/span>)\nc = a.add(b)\n\nprint(c)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
(25<\/span>,45<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
This code works perfectly fine. But Python has a better way to implement it. Instead of using the add()<\/code> method, you can use the built-in operator (+) like this:<\/p>\n\n\n
c = a + b<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
When you use the +<\/code> operator on the Point2D<\/code> object, Python will call the special method __add__()<\/code> on the object. The following calls are equivalent:<\/p>\n\n\n
c = a + b\nc = a.__add__(b)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The __add__()<\/code> method must return a new instance of the Point2D<\/code> object.<\/p>\n\n\n\n
The ability to use the built-in operator (+<\/code>) on a custom type is known as operator overloading.<\/p>\n\n\n\n
The following shows the Point2D<\/code> class that implements the __add__()<\/code> special operator to support the +<\/code> operator:<\/p>\n\n\n
class<\/span> Point2D<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, x, y)<\/span>:<\/span>\n        self.x = x\n        self.y = y\n\n    def<\/span> __str__<\/span>(self)<\/span>:<\/span>\n        return<\/span> f'({self.x}<\/span>,{self.y}<\/span>)'<\/span>\n\n    def<\/span> __add__<\/span>(self, point)<\/span>:<\/span>\n        if<\/span> not<\/span> isinstance(point, Point2D):\n            raise<\/span> ValueError('The other must be an instance of the Point2D'<\/span>)\n\n        return<\/span> Point2D(self.x + point.x, self.y + point.y)\n\n\na = Point2D(10<\/span>, 20<\/span>)\nb = Point2D(15<\/span>, 25<\/span>)\nc = a + b\nprint(c)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
(25,45)<\/code><\/span><\/pre>\n\n\n
Special methods for operator overloading #<\/a><\/h2>\n\n\n\n
The following shows the operators with their corresponding special methods:<\/p>\n\n\n\n
Operator<\/th>Special Methods<\/th><\/tr><\/thead>
+<\/td>__add__(self, other)<\/td><\/tr>
–<\/td>__sub__(self, other)<\/td><\/tr>
*<\/td> __mul__(self, other) <\/td><\/tr>
\/<\/td> __truediv__(self, other) <\/td><\/tr>
\/\/<\/td> __floordiv__(self, other) <\/td><\/tr>
%<\/td> __mod__(self, other) <\/td><\/tr>
**<\/td> __pow__(self, other) <\/td><\/tr>
>><\/td> __rshift__(self, other) <\/td><\/tr>
<<<\/td> __lshift__(self, other) <\/td><\/tr>
&<\/td>  __and__(self, other) <\/td><\/tr>
|<\/td> __or__(self, other) <\/td><\/tr>
^<\/td> __xor__(self, other) <\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
For example, you can implement the __sub__()<\/code> method in the Point2D to support subtraction (-<\/code>) of two points:<\/p>\n\n\n
class<\/span> Point2D<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, x, y)<\/span>:<\/span>\n        self.x = x\n        self.y = y\n\n    def<\/span> __str__<\/span>(self)<\/span>:<\/span>\n        return<\/span> f'({self.x}<\/span>,{self.y}<\/span>)'<\/span>\n\n    def<\/span> __add__<\/span>(self, point)<\/span>:<\/span>\n        if<\/span> not<\/span> isinstance(point, Point2D):\n            raise<\/span> ValueError('The other must be an instance of the Point2D'<\/span>)\n\n        return<\/span> Point2D(self.x + point.x, self.y + point.y)\n\n    def<\/span> __sub__<\/span>(self, other)<\/span>:<\/span>\n        if<\/span> not<\/span> isinstance(other, Point2D):\n            raise<\/span> ValueError('The other must be an instance of the Point2D'<\/span>)\n\n        return<\/span> Point2D(self.x - other.x, self.y - other.y)\n\n\nif<\/span> __name__ == '__main__'<\/span>:\n    a = Point2D(10<\/span>, 20<\/span>)\n    b = Point2D(15<\/span>, 25<\/span>)\n    c = b - a\n    print(c)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Overloading inplace operators #<\/a><\/h2>\n\n\n\n
Some operators have the inplace version. For example, the inplace version of + is +=.<\/p>\n\n\n\n
For the immutable type like a tuple<\/a>, a string, a number, the inplace operators perform calculations and don’t assign the result back to the input object.<\/p>\n\n\n\n
For the mutable type, the inplace operator performs the updates on the original objects directly. The assignment is not necessary.<\/p>\n\n\n\n
Python also provides you with a list of special methods that allows you to overload the inplace operator:<\/p>\n\n\n\n
Operator<\/th>Special Method<\/th><\/tr><\/thead>
+=<\/td>__iadd__(self, other)<\/td><\/tr>
-=<\/td>__isub__(self, other)<\/td><\/tr>
*=<\/td> __imul__(self, other) <\/td><\/tr>
\/=<\/td> __itruediv__(self, other) <\/td><\/tr>
\/\/=<\/td> __ifloordiv__(self, other) <\/td><\/tr>
%=<\/td> __imod__(self, other) <\/td><\/tr>
**=<\/td> __ipow__(self, other) <\/td><\/tr>
>>=<\/td> __irshift__(self, other) <\/td><\/tr>
<<=<\/td> __ilshift__(self, other) <\/td><\/tr>
&=<\/td>  __iand__(self, other) <\/td><\/tr>
|=<\/td> __ior__(self, other) <\/td><\/tr>
^=<\/td> __ixor__(self, other) <\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Let’s take an example of overloading the +=<\/code> operator.<\/p>\n\n\n\n
Suppose you have a cart object and you want to add an item to the cart. To do you, you can define an add()<\/code> method to the Cart<\/code> class and use it like this:<\/p>\n\n\n
cart.add(item)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Alternatively, you can implement the +=<\/code> operator in the Cart<\/code> class. It allows you to add an item to the cart as follows:<\/p>\n\n\n
cart += item<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To support the += operator, you need to implement the __iadd__<\/code> special method in the Cart<\/code> class.<\/p>\n\n\n\n
First, define the Item<\/code> class that has three attributes name, quantity, and price. Also, it has an amount property that returns the subtotal of the item:<\/p>\n\n\n
class<\/span> Item<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, name, qty, price)<\/span>:<\/span>\n        self.name = name\n        self.qty = qty\n        self.price = price\n\n    @property<\/span>\n    def<\/span> amount<\/span>(self)<\/span>:<\/span>\n        return<\/span> self.qty * self.price\n\n    def<\/span> __str__<\/span>(self)<\/span>:<\/span>\n        return<\/span> f'{self.name}<\/span> {self.qty}<\/span> ${self.price}<\/span> ${self.amount}<\/span>'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, define the Cart<\/code> class that implements the __iadd__<\/code> method:<\/p>\n\n\n
class<\/span> Cart<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self)<\/span>:<\/span>\n        self.items = []\n\n    def<\/span> __iadd__<\/span>(self, item)<\/span>:<\/span>\n        if<\/span> not<\/span> isinstance(item, Item):\n            raise<\/span> ValueError('The item must be an instance of Item'<\/span>)\n\n        self.items.append(item)\n        return<\/span> self\n\n    @property<\/span>\n    def<\/span> total<\/span>(self)<\/span>:<\/span>\n        return<\/span> sum([item.amount for<\/span> item in<\/span> self.items])\n\n    def<\/span> __str__<\/span>(self)<\/span>:<\/span>\n        if<\/span> not<\/span> self.items:\n            return<\/span> 'The cart is empty'<\/span>\n\n        return<\/span> '\\n'<\/span>.join([str(item) for<\/span> item in<\/span> self.items])<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In the __iadd__<\/code> method, we raise a ValueError<\/code> if the item is not an instance of the Item<\/code> class. Otherwise, we add the item to the items list attribute.<\/p>\n\n\n\n
The total property returns the sum of all items.<\/p>\n\n\n\n
The __str__<\/code> method returns the string 'The cart is empty'<\/code> if the cart has no item. Otherwise, it returns a string that contains all items separated by a newline.<\/p>\n\n\n\n
Third, use the +=<\/code> operator to add an item to the cart:<\/p>\n\n\n
class<\/span> Item<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, name, qty, price)<\/span>:<\/span>\n        self.name = name\n        self.qty = qty\n        self.price = price\n\n    @property<\/span>\n    def<\/span> amount<\/span>(self)<\/span>:<\/span>\n        return<\/span> self.qty * self.price\n\n    def<\/span> __str__<\/span>(self)<\/span>:<\/span>\n        return<\/span> f'{self.name}<\/span> {self.qty}<\/span> ${self.price}<\/span> ${self.amount}<\/span>'<\/span>\n    \nclass<\/span> Cart<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self)<\/span>:<\/span>\n        self.items = []\n\n    def<\/span> __iadd__<\/span>(self, item)<\/span>:<\/span>\n        if<\/span> not<\/span> isinstance(item, Item):\n            raise<\/span> ValueError('The item must be an instance of Item'<\/span>)\n\n        self.items.append(item)\n        return<\/span> self\n\n    @property<\/span>\n    def<\/span> total<\/span>(self)<\/span>:<\/span>\n        return<\/span> sum([item.amount for<\/span> item in<\/span> self.items])\n\n    def<\/span> __str__<\/span>(self)<\/span>:<\/span>\n        if<\/span> not<\/span> self.items:\n            return<\/span> 'The cart is empty'<\/span>\n\n        return<\/span> '\\n'<\/span>.join([str(item) for<\/span> item in<\/span> self.items])\n\ncart = Cart()\n\ncart += Item('Apple'<\/span>, 5<\/span>, 2<\/span>)\ncart += Item('Banana'<\/span>, 20<\/span>, 1<\/span>)\ncart += Item('Orange'<\/span>, 10<\/span>, 1.5<\/span>)\n\nprint(cart)\n# print the total line<\/span>\nprint('-'<\/span> * 30<\/span>)\nprint('Total: $'<\/span>, cart.total)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Try it<\/a><\/p>\n\n\n\n
Output:<\/p>\n\n\n
Apple   5<\/span>       $2<\/span>      $10<\/span>\nBanana  20<\/span>      $1<\/span>      $20<\/span>\nOrange  10<\/span>      $1.5<\/span>    $15.0<\/span>\n------------------------------\nTotal: $ 45.0<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
    \n
  • Operator overloading allows a class to use built-in operators.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n