Image by Author
In Python, magic methods help you emulate the behavior of built-in functions in your Python classes. These methods have leading and trailing double underscores (__), and hence are also called dunder methods.
These magic methods also help you implement operator overloading in Python. You’ve probably seen examples of this. Like using the multiplication operator * with two integers gives the product. While using it with a string and an integer k gives the string repeated k times:
>>> 3 * 4
12
>>> 'code' * 3
'codecodecode'
In this article, we’ll explore magic methods in Python by creating a simple two-dimensional vector Vector2D class.
We’ll start with methods you’re likely familiar with and gradually build up to more helpful magic methods.
Let’s start writing some magic methods!
Consider the following Vector2D class:
Once you create a class and instantiate an object, you can add attributes like so: obj_name.attribute_name = value.
However, instead of manually adding attributes to every instance that you create (not interesting at all, of course!), you need a way to initialize these attributes when you instantiate an object.
To do so you can define the __init__ method. Let’s define the define the __init__ method for our Vector2D class:
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
v = Vector2D(3, 5)
When you try to inspect or print out the object you instantiated, you’ll see that you don’t get any helpful information.
v = Vector2D(3, 5)
print(v)
Output >>> <__main__.Vector2D object at 0x7d2fcfaf0ac0>
This is why you should add a representation string, a string representation of the object. To do so, add a __repr__ method like so:
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vector2D(x={self.x}, y={self.y})"
v = Vector2D(3, 5)
print(v)
Output >>> Vector2D(x=3, y=5)
The __repr__ should include all the attributes and information needed to create an instance of the class. The __repr__ method is typically used for the purpose of debugging.
The __str__ is also used to add a string representation of the object. In general, the __str__ method is used to provide info to the end users of the class.
Let’s add a __str__ method to our class:
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"Vector2D(x={self.x}, y={self.y})"
v = Vector2D(3, 5)
print(v)
Output >>> Vector2D(x=3, y=5)
If there is no implementation of __str__, it falls back to __repr__. So for every class that you create, you should—at the minimum—add a __repr__ method.
Next, let’s add a method to check for equality of any two objects of the Vector2D class. Two vector objects are equal if they have identical x and y coordinates.
Now create two Vector2D objects with equal values for both x and y and compare them for equality:
v1 = Vector2D(3, 5)
v2 = Vector2D(3, 5)
print(v1 == v2)
The result is False. Because by default the comparison checks for equality of the object IDs in memory.
Let’s add the __eq__ method to check for equality:
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vector2D(x={self.x}, y={self.y})"
def __eq__(self, other):
return self.x == other.x and self.y == other.y
The equality checks should now work as expected:
v1 = Vector2D(3, 5)
v2 = Vector2D(3, 5)
print(v1 == v2)
Python’s built-in len() function helps you compute the length of built-in iterables. Let’s say, for a vector, length should return the number of elements that the vector contains.
So let’s add a __len__ method for the Vector2D class:
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vector2D(x={self.x}, y={self.y})"
def __len__(self):
return 2
v = Vector2D(3, 5)
print(len(v))
All objects of the Vector2D class are of length 2:
Now let’s think of common operations we’d perform on vectors. Let’s add magic methods to add and subtract any two vectors.
If you directly try to add two vector objects, you’ll run into errors. So you should add an __add__ method:
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vector2D(x={self.x}, y={self.y})"
def __add__(self, other):
return Vector2D(self.x + other.x, self.y + other.y)
You can now add any two vectors like so:
v1 = Vector2D(3, 5)
v2 = Vector2D(1, 2)
result = v1 + v2
print(result)
Output >>> Vector2D(x=4, y=7)
Next, let’s add a __sub__ method to calculate the difference between any two objects of the Vector2D class:
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vector2D(x={self.x}, y={self.y})"
def __sub__(self, other):
return Vector2D(self.x - other.x, self.y - other.y)
v1 = Vector2D(3, 5)
v2 = Vector2D(1, 2)
result = v1 - v2
print(result)
Output >>> Vector2D(x=2, y=3)
We can also define a __mul__ method to define multiplication between objects.
Let’s implement let’s handle
- Scalar multiplication: the multiplication of a vector by scalar and
- Inner product: the dot product of two vectors
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vector2D(x={self.x}, y={self.y})"
def __mul__(self, other):
# Scalar multiplication
if isinstance(other, (int, float)):
return Vector2D(self.x * other, self.y * other)
# Dot product
elif isinstance(other, Vector2D):
return self.x * other.x + self.y * other.y
else:
raise TypeError("Unsupported operand type for *")
Now we’ll take a couple of examples to see the __mul__ method in action.
v1 = Vector2D(3, 5)
v2 = Vector2D(1, 2)
# Scalar multiplication
result1 = v1 * 2
print(result1)
# Dot product
result2 = v1 * v2
print(result2)
Output >>>
Vector2D(x=6, y=10)
13
The __getitem__ magic method allows you to index into the objects and access attributes or slice of attributes using the familiar square-bracket [ ] syntax.
For an object v of the Vector2D class:
v[0]: x coordinatev[1]: y coordinate
If you try accessing by index, you’ll run into errors:
v = Vector2D(3, 5)
print(v[0],v[1])
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in | ()
----> 1 print(v[0],v[1])
TypeError: 'Vector2D' object is not subscriptable |
Let’s implement the __getitem__ method:
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vector2D(x={self.x}, y={self.y})"
def __getitem__(self, key):
if key == 0:
return self.x
elif key == 1:
return self.y
else:
raise IndexError("Index out of range")
You can now access the elements using their indexes as shown:
v = Vector2D(3, 5)
print(v[0])
print(v[1])
With an implementation of the __call__ method, you can call objects as if they were functions.
In the Vector2D class, we can implement a __call__ to scale a vector by a given factor:
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vector2D(x={self.x}, y={self.y})"
def __call__(self, scalar):
return Vector2D(self.x * scalar, self.y * scalar)
So if you now call 3, you’ll get the vector scaled by factor of 3:
v = Vector2D(3, 5)
result = v(3)
print(result)
Output >>> Vector2D(x=9, y=15)
The __getattr__ method is used to get the values of specific attributes of the objects.
For this example, we can add a __getattr__ dunder method that gets called to compute the magnitude (L2-norm) of the vector:
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vector2D(x={self.x}, y={self.y})"
def __getattr__(self, name):
if name == "magnitude":
return (self.x ** 2 + self.y ** 2) ** 0.5
else:
raise AttributeError(f"'Vector2D' object has no attribute '{name}'")
Let’s verify if this works as expected:
v = Vector2D(3, 4)
print(v.magnitude)
That’s all for this tutorial! I hope you learned how to add magic methods to your class to emulate the behavior of built-in functions.
We’ve covered some of the most useful magic methods. But this is not this is not an exhaustive list. To further your understanding, create a Python class of your choice and add magic methods depending on the functionality required. Keep coding!
Bala Priya C is a developer and technical writer from India. She likes working at the intersection of math, programming, data science, and content creation. Her areas of interest and expertise include DevOps, data science, and natural language processing. She enjoys reading, writing, coding, and coffee! Currently, she’s working on learning and sharing her knowledge with the developer community by authoring tutorials, how-to guides, opinion pieces, and more.
