Some operators and other elements of the Python programming language can show overloading. Here is all you need to know about Python Overloading.
Python overloading: Operator overloading
Below are the operators that can be overloaded in classes, along with the method definitions that are required, and an example of the operator in use within an expression.
N.B. The use of other as a variable name is not mandatory, but is considered the norm.
Operator Method Expression Addition
add(self, other) a1 + a2
Subtraction
sub(self, other) a1 – a2
Multiplication
mul(self, other) a1 * a2
Matrix Multiplication (Python 3.5)
@ matmul(self, other)
a1 @ a2
Division (Python 2 only)
/ div(self, other)
a1 / a2
Division (Python 3)
/ truediv(self, other)
a1 / a2
Floor Division
// floordiv(self, other) a1 // a2
Modulo/Remainder
% mod(self, other) a1 % a2
Power
** pow(self, other[, modulo]) a1 ** a2
Bitwise Left Shift
<< lshift(self, other) a1 << a2
Bitwise Right Shift
__rshift__(self, other) a1 >> a2 Bitwise AND
& and(self, other) a1 & a2
Bitwise XOR
^ xor(self, other) a1 ^ a2
(Bitwise OR)
| or(self, other) a1 | a2
Negation (Arithmetic)
neg(self) -a1
Positive
pos(self) +a1
Bitwise NOT
~ invert(self) ~a1
Less than
< lt(self, other) a1 < a2 Less than or Equal to <= le(self, other) a1 <= a2 Equal to == eq(self, other) a1 == a2 Not Equal to != ne(self, other) a1 != a2 Greater than gt(self, other) a1 > a2
Greater than or Equal to
= ge(self, other) a1 >= a2
Index operator
[index] getitem(self, index) a1[index]
In operator
in contains(self, other) a2 in a1
Calling
(*args, …) call(self, *args, *kwargs) a1(args, **kwargs)
The optional parameter modulo for pow is only used by the pow built-in function.
Each of the methods corresponding to a binary operator has a corresponding “right” method which start with r, for example __radd:
class A: def init(self, a): self.a = a def add(self, other): return self.a + other def radd(self, other): print("radd")
return other + self.a
A(1) + 2 # Out: 3
2 + A(1) # prints radd. Out: 3
as well as a corresponding inplace version, starting with __i:
class B:
def init(self, b):
self.b = b
def iadd(self, other):
self.b += other
print("iadd")
return self
b = B(2)
Out: 2
b += 1 # prints iadd
Out: 3
Since there’s nothing special about these methods, many other parts of the language, parts of the standard library, and even third-party modules add magic methods on their own, like methods to cast an object to a type or checking properties of the object. For example, the builtin str() function calls the object’s str method, if it exists. Some of these uses are listed below.
Function Method Expression
Casting to
int int(self) int(a1)
Absolute function
abs(self) abs(a1)
Casting to
str str(self) str(a1)
Casting to (Python 2 only)
unicode(self)
unicode unicode(a1)
String representation
repr(self) repr(a1)
Casting to
bool nonzero(self) bool(a1)
String formatting
format(self, formatstr) "Hi {:abc}".format(a1)
Hashing
hash(self) hash(a1)
Length
len(self) len(a1)
Reversed
reversed(self) reversed(a1)
Floor
floor(self) math.floor(a1)
Ceiling
ceil(self) math.ceil(a1)
There are also the special methods enter and exit for context managers, and many more.
Python overloading: Magic/Dunder Methods
Magic (also called dunder as an abbreviation for double-underscore) methods in Python serve a similar purpose to operator overloading in other languages. They allow a class to define its behavior when it is used as an operand in unary or binary operator expressions. They also serve as implementations called by some built-in functions.
Consider this implementation of two-dimensional vectors.
import math
class Vector(object):
instantiation
def init(self, x, y):
self.x = x
self.y = y
unary negation (-v) def neg(self):
return Vector(-self.x, -self.y)
addition (v + u)
def add(self, other):
return Vector(self.x + other.x, self.y + other.y)
subtraction (v – u)
def sub(self, other):
return self + (-other)
equality (v == u)
def eq(self, other):
return self.x == other.x and self.y == other.y
abs(v)
def abs(self):
return math.hypot(self.x, self.y)
str(v)
def str(self):
return '<{0.x}, {0.y}>'.format(self)
repr(v)
def repr(self):
return 'Vector({0.x}, {0.y})'.format(self)
Now it is possible to naturally use instances of the Vector class in various expressions.
v = Vector(1, 4)
u = Vector(2, 0)
u + v # Vector(3, 4)
print(u + v) # "<3, 4>" (implicit string conversion)
u - v # Vector(1, -4)
u == v # False
u + v == v + u # True
abs(u + v) # 5.0
Python overloading: Container and sequence types
It is possible to emulate container types, which support accessing values by key or index.
Consider this naive implementation of a sparse list, which stores only its non-zero elements to conserve memory.
class sparselist(object):
def init(self, size):
self.size = size
self.data = {}
l[index]
def getitem(self, index): if index < 0: index += self.size if index >= self.size: raise IndexError(index)
try:
return self.data[index]
except KeyError:
return 0.0
l[index] = value
def setitem(self, index, value):
self.data[index] = value
del l[index]
def delitem(self, index):
if index in self.data:
del self.data[index]
value in l
def contains(self, value):
return value == 0.0 or value in self.data.values()
len(l)
def len(self):
return self.size
for value in l: …
def iter(self):
return (self[i] for i in range(self.size)) # use xrange for python2
Then, we can use a sparselist much like a regular list.
l = sparselist(10 ** 6) # list with 1 million elements
0 in l # True
10 in l # False
l[12345] = 10
10 in l # True
l[12345] # 10
for v in l:
pass # 0, 0, 0, … 10, 0, 0 … 0
Callable types
class adder(object):
def init(self, first):
self.first = first
a(…)
def call(self, second):
return self.first + second
add2 = adder(2)
add2(1) # 3
add2(2) # 4
Python overloading: Handling unimplemented behaviour
If your class doesn’t implement a specific overloaded operator for the argument types provided, it should return NotImplemented (note that this is a special constant, not the same as NotImplementedError). This will allow Python to fall back to trying other methods to make the operation work:
When NotImplemented is returned, the interpreter will then try the reflected operation on the other type, or some other fallback, depending on the operator. If all attempted operations return NotImplemented, the interpreter will raise an appropriate exception.
For example, given x + y, if x.add(y) returns unimplemented, y.radd(x) is attempted instead.
class NotAddable(object):
def init(self, value):
self.value = value
def add(self, other):
return NotImplemented
class Addable(NotAddable):
def add(self, other):
return Addable(self.value + other.value)
radd = add
As this is the reflected method we have to implement add and radd to get the expected behaviour in all cases; fortunately, as they are both doing the same thing in this simple example, we can take a shortcut.
In use:
x = NotAddable(1)
y = Addable(2)
x + x
Traceback (most recent call last):
File "", line 1, in
TypeError: unsupported operand type(s) for +: 'NotAddable' and 'NotAddable'
y + y
z = x + y
z
z.value
3