If you've spent any time coding in Python, you've likely come across strange-looking method names surrounded by double underscores—__init__, __str__, or __len__, to name a few. These are known as dunder methods (short for double underscore), or more formally, magic methods. They are one of the most powerful and elegant features of Python, enabling you to define and customize how your objects behave with built-in operations.

In this article, we'll explore what these methods are, how they work behind the scenes, and how you can leverage them to make your classes more Pythonic and intuitive.

🧠 What Are Dunder Methods?

Dunder methods are special methods in Python that allow you to define or override the behavior of objects in response to built-in operations. These methods start and end with double underscores (e.g., __init__, __add__, __len__, etc.).

They are used implicitly by Python’s syntax. For example:

x = 10 + 5   # Under the hood, this is x = 10.__add__(5)
len("hello") # Internally calls "hello".__len__()

Almost every operation in Python (arithmetic, string formatting, comparison, indexing, iteration, etc.) is powered by one or more dunder methods.

🧱 Everything in Python Is an Object

This concept is key to understanding dunder methods. In Python, everything—integers, strings, functions, classes—is an instance of some class. For instance:

print(type(5))           # <class 'int'>
print(type("hello"))     # <class 'str'>
print(type(len))         # <class 'builtin_function_or_method'>

All of these types define dunder methods that determine how they behave with operators and functions.

✨ Commonly Used Dunder Methods

Here are some widely used dunder methods, categorized by functionality:

Initialization and Representation

__init__(self, ...): Constructor. Called when a new instance is created.
__str__(self): Human-readable string representation. Used by print().
__repr__(self): Developer-friendly representation. Used in interactive console or when debugging.

Arithmetic Operators

__add__(self, other): +
__sub__(self, other): -
__mul__(self, other): *
__truediv__(self, other): /
__floordiv__(self, other): //
__mod__(self, other): %
__pow__(self, other): **

Comparison Operators

__eq__(self, other): ==
__ne__(self, other): !=
__lt__(self, other): <
__le__(self, other): <=
__gt__(self, other): >
__ge__(self, other): >=

Container Methods

__len__(self): Length using len()
__getitem__(self, index): Indexing: obj[index]
__setitem__(self, index, value): Assigning: obj[index] = value
__delitem__(self, index): Deleting: del obj[index]
__contains__(self, item): Membership: item in obj

Context Managers

__enter__(self): Enter a context block (used with with)
__exit__(self, exc_type, exc_value, traceback): Exit a context block

📦 Custom Example: Counter Class

class Counter:
    def __init__(self, value=0):
        self.value = value

    def __str__(self):
        return f"Count: {self.value}"

    def __add__(self, other):
        if isinstance(other, Counter):
            return Counter(self.value + other.value)
        raise TypeError("Operand must be of type Counter")

This class now supports:

c1 = Counter(2)
c2 = Counter(3)
print(c1 + c2)  # Count: 5

And you’ll get a readable output when printing:

print(c1)       # Count: 2

🛠️ Richer Behavior With More Methods

Let’s say you're building a class for InventoryItem. You could implement:

def __eq__(self, other): ...
def __lt__(self, other): ...
def __add__(self, other): ...

This would let you compare and combine inventory items naturally using ==, <, and +.

You could also allow slicing and item assignment in custom container-like classes by implementing:

def __getitem__(self, index): ...
def __setitem__(self, index, value): ...
def __contains__(self, item): ...

💡 Pro Tips

Always implement both __str__ and __repr__ for user-friendly and developer-friendly outputs.
When using arithmetic dunder methods, validate types using isinstance().
Use __contains__ to allow your class to support the in keyword.
Implement context management (__enter__, __exit__) to handle resource management cleanly.

🔚 Wrapping Up

Python’s dunder methods unlock the full power of object-oriented programming. They allow your classes to feel like native Python types, making them easier to use, integrate, and extend. Once you understand and start using them, you'll see Python in a whole new light—and write much cleaner, more expressive code.

📘 Further Exploration

If you're eager to go deeper, try implementing:

A custom linked list using __getitem__ and __len__.
A vector class that supports addition, dot product, and scalar multiplication.
A context manager for file or resource handling.

Understanding Python's Dunder (Magic) Methods: Unlocking Hidden Power

Table of contents