Real-world examples on how actively using special methods can simplify coding and improve readability.<\/h4>\n
Dunder methods, though possibly a basic topic in Python, are something I have often noticed being understood only superficially, even by people who have been coding for quite some\u00a0time.<\/p>\n
Disclaimer: <\/strong>This is a forgivable gap, as in most cases, actively using dunder methods \u201csimply\u201d speeds up and standardize tasks that can be done differently. Even when their use is essential, programmers are often unaware that they are writing special methods that belong to the broader category of dunder\u00a0methods.<\/p>\n Anyway, if you code in Python and are not familiar with this topic, or if you happen to be a code geek intrigued by the more native aspects of a programming language like I am, this article might just be what you\u2019re looking\u00a0for.<\/p>\n If there is one thing I learned in my life is that not everything is what it seems like at a first look, and Python is no exception.<\/p>\n Let us consider a seemingly simple\u00a0example:<\/p>\n This is the \u201cemptiest\u201d custom class we can define in Python, as we did not define attributes or methods. It is so empty you would think you can do nothing with\u00a0it.<\/p>\n However, this is not the case. For example, Python will not complain if you try to create an instance of this class or even compare two instances for equality:<\/p>\n Of course, this is not magic. Simply, leveraging a standard object <\/em><\/strong>interface, any object in Python inherits some default attributes and methods that allow the user to always have a minimal set of possible interactions with\u00a0it.<\/p>\n While these methods may seem hidden, they are not invisible. To access the available methods, including the ones assigned by Python itself, just use the dir()<\/em><\/strong> built-in function. For our empty class, we\u00a0get:<\/p>\n It is these methods that can explain the behaviour we observed earlier. For example, since the class actually has an __init__ <\/em><\/strong>method we should not be surprised that we can instantiate an object of the\u00a0class.<\/p>\n All the methods shown in the last output belongs to the special group of\u200a\u2014\u200aguess what\u200a\u2014\u200adunder methods. The term \u201cdunder\u201d is short for double underscore, referring to the double underscores at the beginning and end of these method\u00a0names.<\/p>\n They are special for several\u00a0reasons:<\/p>\n For most Python developers, the first dunder they encounter is __init__<\/em><\/strong>, the constructor method. This method is automatically called when you create an instance of a class, using the familiar syntax MyClass(*args, **kwargs)<\/em><\/strong> as a shortcut for explicitly calling MyClass.__init__(*args, **kwargs).<\/em><\/strong><\/p>\n Despite being the most commonly used, __init__<\/em><\/strong> is also one of the most specialized dunder methods. It does not fully showcase the flexibility and power of dunder methods, which can allow you to redefine how your objects interact with native Python features.<\/p>\n Let us define a class representing an item for sale in a shop and create an instance of it by specifying the name and\u00a0price.<\/p>\n What happens if we try to display the content of the item <\/em>variable? Right now, the best Python can do is tell us what type of object it is and where it is allocated in\u00a0memory:<\/p>\n Let\u2019s try to get a more informative and pretty\u00a0output!<\/p>\n To do that, we can override the __repr__ <\/em><\/strong>dunder, which output will be exactly what gets printed when typing a class instance in the interactive Python console but also\u200a\u2014\u200aas soon as the other dunder method __str__<\/em><\/strong> is not override\u200a\u2014\u200awhen attempting a print()<\/em><\/strong>\u00a0call.<\/p>\n Note<\/strong>: it is a common practice to have __repr__<\/em><\/strong> provide the necessary syntax to recreate the printed instance. So in that latter case we expect the output to be Item(name=\u201dMilk (1L)\u201d, price=0.99).<\/em><\/p>\n Nothing special, right? And you would be right: we could have implemented the same method and named it my_custom_repr <\/em>without getting indo dunder methods. However, while anyone immediately understands what we mean with print(item) <\/em><\/strong>or just item<\/em><\/strong>, can we say the same for something like item.my_custom_repr()<\/em><\/strong>?<\/p>\n Define interaction between an object and Python\u2019s native operators<\/strong><\/p>\n Imagine we want to create a new class, Grocery<\/em>, that allows us to build a collection of Item <\/em>along with their quantities.<\/p>\n In this case, we can use dunder methods for allowing some standard operations like:<\/p>\n To achieve this, we will define (<\/strong>we already see that <\/strong>a generic class do not have these methods by default) the dunder methods __add__<\/em><\/strong>, __iter__<\/em><\/strong> and __getitem__<\/em><\/strong> respectively.<\/p>\n Let us initialize a Grocery <\/em>instance and print the content of its main attribute, items.<\/em><\/p>\n Then, we use the +<\/em><\/strong> operator to add a new Item and verify the changes have taken\u00a0effect.<\/p>\n Friendly and explicit, right?<\/p>\n The __iter__ <\/em><\/strong>method allows us to loop through a Grocery <\/em>object following the logic implemented in the method (i.e., implicitly the loop will iterate over the elements contained in the iterable attribute items<\/em>).<\/p>\n Similarly, accessing elements is handled by defining the __getitem__<\/em><\/strong> dunder:<\/p>\n In essence, we assigned some standard dictionary-like behaviours to our Grocery class while also allowing some operations that would not be natively available for this data\u00a0type.<\/p>\n Enhance functionality: make classes callable for simplicity and\u00a0power.<\/strong><\/p>\n Let us wrap up this deep-dive on dunder methods with a final eample showcasing how they can be a powerful tool in our\u00a0arsenal.<\/p>\n Imagine we have implemented a function that performs deterministic and slow calculations based on a certain input. To keep things simple, as an example we will use an identity function with a built-in time.sleep<\/em><\/strong> of some\u00a0seconds.<\/p>\n What happens if we run the function twice on the same input? Well, right now calculation would be executed twice, meaning that we twice get the same output waiting two time for the whole execution time (i.e., a total of 10 seconds).<\/p>\n Does this make sense? Why should we do the same calculation (which leads to the same output) for the same input, especially if it\u2019s a slow\u00a0process?<\/p>\n One possible solution is to \u201cwrap\u201d the execution of this function inside the __call__<\/em><\/strong> dunder method of a\u00a0class.<\/p>\n This makes instances of the class callable just like functions\u200a\u2014\u200ameaning we can use the straightforward syntax my_class_instance(*args, **kwargs)<\/em><\/strong>\u200a\u2014\u200awhile also allowing us to use attributes as a cache to cut computation time.<\/p>\n With this approach we also have the flexibility to create multiple process (i.e., class instances), each with its own local\u00a0cache.<\/p>\n As expected, the function is cached after the first run, eliminating the need for the second computation and thus cutting the overall time in\u00a0half.<\/p>\n As above mentioned, we can even create separate instances of the class, each with its own cache, if\u00a0needed.<\/p>\n Here we are! A simple yet powerful optimization trick made possible by dunder methods that not only reduces redundant calculations but also offers flexibility by allowing local, instance-specific caching.<\/p>\n Dunder methods are a broad and ever-evolving topic, and this writing does not aim to be an exhaustive resource on the subject (for this purpose, you can refer to the 3. Data model\u200a\u2014\u200aPython 3.12.3 documentation<\/a>).<\/p>\n My goal here was rather to explain clearly what they are and how they can be used effectively to handle some common use\u00a0cases.<\/p>\n While they may not be mandatory for all programmers all the time, once I got a good grasp of how they work they have made a ton of difference for me and hopefully they may work for you as\u00a0well.<\/p>\n Dunder methods indeed are a way to avoid reinventing the wheel. They also align closely with Python\u2019s philosophy, leading to a more concise, readable and convention-friendly code. And that never hurts,\u00a0right?<\/p>\n Dunder Methods: The Hidden Gems of Python<\/a> was originally published in Towards Data Science<\/a> on Medium, where people are continuing the conversation by highlighting and responding to this story.<\/p>\n<\/div>\nAppearances can deceive\u2026 even in\u00a0Python!<\/strong><\/h4>\n
class EmptyClass:
pass<\/pre>\nempty_instance = EmptyClass()
another_empty_instance = EmptyClass()
>>> empty_instance == another_empty_instance
False<\/pre>\n>>> dir(EmptyClass)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__']<\/pre>\nMeet the Dunder\u00a0Methods<\/strong><\/h4>\n
\n
Make an object\u00a0pretty<\/h4>\n
class Item:
def __init__(self, name: str, price: float) -> None:
self.name = name
self.price = price
item = Item(name=\"Milk (1L)\", price=0.99)<\/pre>\n>>> item
<__main__.Item at 0x00000226C614E870><\/pre>\nclass Item:
def __init__(self, name: str, price: float) -> None:
self.name = name
self.price = price
def __repr__(self) -> str:
return f\"{self.__class__.__name__}('{self.name}', {self.price})\"
item = Item(name=\"Milk (1L)\", price=0.99)
>>> item # In this example it is equivalent also to the command: print(item)
Item('Milk (1L)', 0.99)<\/pre>\n\n
from typing import Optional, Iterator
from typing_extensions import Self
class Grocery:
def __init__(self, items: Optional[dict[Item, int]] = None):
self.items = items or dict()
def __add__(self, new_items: dict[Item, int]) -> Self:
new_grocery = Grocery(items=self.items)
for new_item, quantity in new_items.items():
if new_item in new_grocery.items:
new_grocery.items[new_item] += quantity
else:
new_grocery.items[new_item] = quantity
return new_grocery
def __iter__(self) -> Iterator[Item]:
return iter(self.items)
def __getitem__(self, item: Item) -> int:
if self.items.get(item):
return self.items.get(item)
else:
raise KeyError(f\"Item {item} not in the grocery\")<\/pre>\nitem = Item(name=\"Milk (1L)\", price=0.99)
grocery = Grocery(items={item: 3})
>>> print(grocery.items)
{Item('Milk (1L)', 0.99): 3}<\/pre>\nnew_item = Item(name=\"Soy Sauce (0.375L)\", price=1.99)
grocery = grocery + {new_item: 1} + {item: 2}
>>> print(grocery.items)
{Item('Milk (1L)', 0.99): 5, Item('Soy Sauce (0.375L)', 1.99): 1}<\/pre>\n>>> print([item for item in grocery])
[Item('Milk (1L)', 0.99), Item('Soy Sauce (0.375L)', 1.99)]<\/pre>\n>>> grocery[new_item]
1
fake_item = Item(\"Creamy Cheese (500g)\", 2.99)
>>> grocery[fake_item]
KeyError: \"Item Item('Creamy Cheese (500g)', 2.99) not in the grocery\"<\/pre>\nimport time
def expensive_function(input):
time.sleep(5)
return input<\/pre>\nstart_time = time.time()
>>> print(expensive_function(2))
>>> print(expensive_function(2))
>>> print(f\"Time for computation: {round(time.time()-start_time, 1)} seconds\")
2
2
Time for computation: 10.0 seconds<\/pre>\nclass CachedExpensiveFunction:
def __init__(self) -> None:
self.cache = dict()
def __call__(self, input):
if input not in self.cache:
output = expensive_function(input=input)
self.cache[input] = output
return output
else:
return self.cache.get(input)
start_time = time.time()
cached_exp_func = CachedExpensiveFunction()
>>> print(cached_exp_func(2))
>>> print(cached_exp_func(2))
>>> print(f\"Time for computation: {round(time.time()-start_time, 1)} seconds\")
2
2
Time for computation: 5.0 seconds<\/pre>\nstart_time = time.time()
another_cached_exp_func = CachedExpensiveFunction()
>>> print(cached_exp_func(3))
>>> print(another_cached_exp_func (3))
>>> print(f\"Time for computation: {round(time.time()-start_time, 1)} seconds\")
3
3
Time for computation: 10.0 seconds<\/pre>\nMy final considerations<\/h4>\n
<\/p>\n
\n