Do you know about the Magic Methods in Python?
In my last post , I talked about Object-Oriented Programming(OOP). And I specifically talked about a single magic method __init__ which is also called as a constructor method in the OOP terminology.
The magic part of __init__ is that it gets called whenever an object is created automatically. But it is not the only one in any sense. Python provides us with many other magic methods that we end up using without even knowing about them. Ever used len(), print() or the [] operator on a list? You have been using Dunder methods.
In this post, I would talk about five of the most used magic functions or “Dunder” methods.
1. Operator Magic methods: __add__, __sub__, __mul__, __truediv__, __lt__,__gt__
In my last post, I talked about how everything ranging from int,str ,float in Python is an object. We also learned how we could call methods on an object like
Fname = "Rahul"
# Now, we can use various methods defined in the string class using the below syntax
Fname.lower()
But, as we know, we can also use the + operator to concatenate multiple strings.
Lname = "Agarwal"
print(Fname + Lname)
------------------------------------------------------------------
RahulAgarwal
So, Why does the addition operator work? I mean how does the String object knows what to do when it encounters the plus sign? How do you write it in the str class? And the same + operation happens differently in the case of integer objects. Thus the operator + behaves differently in the case of String and Integer(Fancy people call this — operator overloading).
So, can we add any two objects? Let’s try to add two objects from our elementary Account class.
It fails as expected since the operand + is not supported for an object of type Account. But we can add the support of + to our Account class using our magic method __add__
class Account:
def __init__(self, account_name, balance=0):
self.account_name = account_name
self.balance = balance
def __add__(self,acc):
if isinstance(acc,Account):
return self.balance + acc.balance
raise Exception(f"{acc} is not of class Account")
Here we add a magic method __add__ to our class which takes two arguments — self and acc. We first check if acc is of class account and if it is, we return the sum of balances when we add these accounts. If we add anything else to an account other than an object from the Account class, we would be shown a descriptive error. Let us try it:
So, we can add any two objects. In fact, we also have different magic methods for a variety of other operators.
__sub__for subtraction(-)__mul__for multiplication(*)__truediv__for division(/)__eq__for equality (==)__lt__for less than(<)__gt__for greater than(>)__le__for less than or equal to (≤)__ge__for greater than or equal to (≥)
As a running example, I will try to explain all these concepts by creating a class called Complex to handle complex numbers. Don’t worry Complex would just be the class’s name, and I would try to keep it as simple as possible.
So below, I create a simple method __add__ that adds two Complex numbers, or a complex number and an int/float. It first checks if the number being added is of type int or float or Complex. Based on the type of number being added, we do the required addition. We also use the isinstance function to check the type of the other object. Do read the comments.
import math
class Complex:
def __init__(self, re=0, im=0):
self.re = re
self.im = im
def __add__(self, other):
# If Int or Float Added, return a Complex number where float/int is added to the real part
if isinstance(other, int) or isinstance(other, float):
return Complex(self.re + other,self.im)
# If Complex Number added return a new complex number having a real and complex part
elif isinstance(other, Complex):
return Complex(self.re + other.re , self.im + other.im)
else:
raise TypeError
It can be used as:
a = Complex(3,4)
b = Complex(4,5)
print(a+b)
You would now be able to understand the below code which allows us to add, subtract, multiply and divide complex numbers with themselves as well as scalars(float, int etc.). See how these methods, in turn, return a complex number. The below code also provides the functionality to compare two complex numbers using __eq__,__lt__,__gt__
You really don’t need to understand all of the complex number maths, but I have tried to use most of these magic methods in this particular class. Maybe read through __add__ and __eq__ one.
import math
class Complex:
def __init__(self, re=0, im=0):
self.re = re
self.im = im
def __add__(self, other):
if isinstance(other, int) or isinstance(other, float):
return Complex(self.re + other,self.im)
elif isinstance(other, Complex):
return Complex(self.re + other.re , self.im + other.im)
else:
raise TypeError
def __sub__(self, other):
if isinstance(other, int) or isinstance(other, float):
return Complex(self.re - other,self.im)
elif isinstance(other, Complex):
return Complex(self.re - other.re, self.im - other.im)
else:
raise TypeError
def __mul__(self, other):
if isinstance(other, int) or isinstance(other, float):
return Complex(self.re * other, self.im * other)
elif isinstance(other, Complex):
# (a+bi)*(c+di) = ac + adi +bic -bd
return Complex(self.re * other.re - self.im * other.im,
self.re * other.im + self.im * other.re)
else:
raise TypeError
def __truediv__(self, other):
if isinstance(other, int) or isinstance(other, float):
return Complex(self.re / other, self.im / other)
elif isinstance(other, Complex):
x = other.re
y = other.im
u = self.re
v = self.im
repart = 1/(x**2+y**2)*(u*x + v*y)
impart = 1/(x**2+y**2)*(v*x - u*y)
return Complex(repart,impart)
else:
raise TypeError
def value(self):
return math.sqrt(self.re**2 + self.im**2)
def __eq__(self, other):
if isinstance(other, int) or isinstance(other, float):
return self.value() == other
elif isinstance(other, Complex):
return self.value() == other.value()
else:
raise TypeError
def __lt__(self, other):
if isinstance(other, int) or isinstance(other, float):
return self.value() < other
elif isinstance(other, Complex):
return self.value() < other.value()
else:
raise TypeError
def __gt__(self, other):
if isinstance(other, int) or isinstance(other, float):
return self.value() > other
elif isinstance(other, Complex):
return self.value() > other.value()
else:
raise TypeError
Now we can use our Complex class as:
2. But why does the complex number print as this random string? — __str__ and __repr__
Ahh! You got me. This brings us to another dunder method which lets us use the print method on our object called __str__. The main idea again is that when we call print(object) it calls the __str__ method in the object. Here is how we can use that with our Complex class.
class Complex:
def __init__(self, re=0, im=0):
self.re = re
self.im = im
.....
.....
def __str__(self):
if self.im>=0:
return f"{self.re}+{self.im}i"
else:
return f"{self.re}{self.im}i"
We can now recheck the output:
So now, our object gets printed in a better way. But still, if we try to do the below in our notebook, the __str__ method is not called:
This is because we are not printing in the above code, and thus the __str__ method doesn’t get called. In this case, another magic method called __repr__ gets called. We can just add this in our class to get the same result as a print(we could also have implemented it differently). It’s a dunder method inside a dunder method. Pretty nice!!!
def __repr__(self):
return self.__str__()
3. I am getting you. So, Is that how the len method works too? __len__
len() is another function that works pretty much with strings, Lists and matrices, and whatnot. To use this function with our Complex numbers class, we can use the __len__ magic method though really not a valid use case for complex numbers in this case as the return type of __len__ needs to be an int as per the documentation.
class Complex:
def __init__(self, re=0, im=0):
self.re = re
self.im = im
......
......
def __len__(self):
# This function return type needs to be an int
return int(math.sqrt(self.re**2 + self.im**2))
Here is its usage:
4. But what about the Assignment operations?
We know how the + operator works with an object. But have you thought why does the below += work? For example
myStr = "This blog"
otherStr = " is awesome"
myStr+=otherStr
print(myStr)
This brings us to another set of dunder methods called assignment dunder methods which include __iadd__,__isub__,__imul__,__itruediv__ and many others.
So If we just add the following method __iadd__ to our class, we would be able to make assignment based additions too.
class Complex:
.....
def __iadd__(self, other):
if isinstance(other, int) or isinstance(other, float):
return Complex(self.re + other,self.im)
elif isinstance(other, Complex):
return Complex(self.re + other.re , self.im + other.im)
else:
raise TypeError
And use it as:
5. Can your class object support indexing?
Sometimes objects might contain lists, and we might need to index the object to get the value from the list. To understand this, let’s take a different example. Imagine you are a company that helps users trade stock. Each user will have a Daily Transaction Book that will contain information about the user’s trades/transactions over the course of the day. We can implement such a class by:
class TrasnsactionBook:
def __init__(self, user_id, shares=[]):
self.user_id = user_id
self.shares = shares
def add_trade(self, name , quantity, buySell):
self.shares.append([name,quantity,buySell])
def __getitem__(self, i):
return self.shares[i]
Do you notice the __getitem__ here? This actually allows us to use indexing on objects of this particular class using:
We can get the first trade done by the user or the second one based on the index we use. This is just a simple example, but you can set your object up to get a lot more information when you use indexing.
Conclusion
Python is a magical language, and there are many constructs in Python that even advanced users may not know about. Dunder methods might be very well one of them. I hope with this post, you get a good glimpse of various dunder methods that Python offers and also understand how to implement them yourself. If you want to know about even more dunder methods, do take a look at this blog from Rafe Kettler.
If you want to learn more about Python , I would like to call out an excellent course on Learn Intermediate level Python from the University of Michigan. Do check it out.
I am going to be writing more of such posts in the future too. Let me know what you think about the series. Follow me up at Medium or Subscribe to my blog to be informed about them. As always, I welcome feedback and constructive criticism and can be reached on Twitter @mlwhiz
Also, a small disclaimer — There might be some affiliate links in this post to relevant resources, as sharing knowledge is never a bad idea.