Dunder (Magic) Methods: The Cheat Codes

1. The Big Idea (ELI5)

2. String Representation: `__str__` vs `__repr__`

When you catach a Pokemon and look at it in your Pokedex, you want to see a nice name, not a serial number.

class Pokemon:
    def __init__(self, name, level):
        self.name = name
        self.level = level

    def __str__(self):
        # Friendly for players
        return f"{self.name} (Lvl {self.level})"

    def __repr__(self):
        # Precise for debugging
        return f"Pokemon(name='{self.name}', level={self.level})"

p = Pokemon("Charizard", 36)

print(p)       # Charizard (Lvl 36) -> Automatically calls __str__
print([p])     # [Pokemon(name='Charizard', level=36)] -> Lists use __repr__

3. Operator Overloading: The Math Protocol

Why does `1 + 2 = 3` but `"a" + "b" = "ab"`? It's because `int` and `str` have defined their own `__add__` spell! Let's teach our Pokemon how to fight using math symbols.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # The '+' Spell
    def __add__(self, other):
        # Triggered by: v1 + v2
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, scalar):
        # Triggered by: v1 * 3
        return Vector(self.x * scalar, self.y * scalar)

    def __eq__(self, other):
        # Triggered by: v1 == v2
        return self.x == other.x and self.y == other.y

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 4)
v2 = Vector(1, 1)

v3 = v1 + v2       # Vector(3, 5)
print(v3 == Vector(3, 5)) # True

Power with Responsibility: Overloading allows expressive code (e.g., `path / "file.txt"` in standard library's `pathlib`). However, don't abuse it. If `Player + Player` breeds a new child, that makes sense. If `Player + Player` kills both players, that is confusing. Keep the semantics intuitive.

4. The Container Protocol: `__len__`, `__getitem__`

Want your object to act like a List or Dictionary? You just need two spells:

• `__len__`: Tells Python "How many items do I have?"
• `__getitem__`: Tells Python "Give me the item at this slot."

class Backpack:
    def __init__(self):
        self.items = []

    def add(self, item):
        self.items.append(item)

    # 1. Allow 'len(backpack)'
    def __len__(self):
        return len(self.items)

    # 2. Allow 'backpack[0]'
    def __getitem__(self, index):
        return self.items[index]

my_bag = Backpack()
my_bag.add("Potion")
my_bag.add("Map")

print(len(my_bag)) # 2
print(my_bag[0])   # Potion

# Magic: Because we have getitem, we can loop!
for item in my_bag:
    print(item) # Prints Potion, then Map

Why the Container Protocol matters

By implementing just these two methods, your object becomes "Duck Typed" as a sequence. You can use it in `for` loops, list comprehensions, and even pass it to functions that expect lists. This is polymorphism in action—Python doesn't check if it is a list, only if it behaves like one.

5. Context Managers: `__enter__` & `__exit__`

The `with` statement is like entering a Safe Room. When you enter (`__enter__`), the lights turn on. When you leave (`__exit__`), the lights turn off automatically, even if you trip and fall (raise an error) inside. This is known as Resource Management. It is essential for:

• File Operations: Closing the file handle.
• Network Connections: Disconnecting from a database.
• Locks: Releasing a thread lock to prevent deadlocks.

import time

class Timer:
    def __enter__(self):
        self.start = time.time()
        return self 

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.end = time.time()
        print(f"⏱ Execution Time: {self.end - self.start:.4f} seconds")
        # Return False to let exceptions propagate
        return False

with Timer():
    # Run some heavy code
    sum([i**2 for i in range(100000)])
    
# Output: ⏱ Execution Time: 0.0345 seconds

6. Making Objects Callable: `__call__`

Normally, you call functions `my_func()` and objects are just things `my_obj`. But with `__call__`, you can make an object pretend to be a function!

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, number):
        return number * self.factor

double = Multiplier(2)
triple = Multiplier(3)

print(double(10)) # 20 (It looks like a function!)
print(triple(10)) # 30

7. Iterators: `__iter__` vs `__next__`

While `__getitem__` allows simple iteration, powerful iteration requires the Iterator Protocol.

class CountDown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        
        num = self.current
        self.current -= 1
        return num

for n in CountDown(3):
    print(n) # 3, 2, 1

9. Extended Technical Reference

Operator Overloading: Python vs The World

Python's "Dunder" (Double Underscore) system is often cited as one of its most powerful features.

Deep Dive: `NotImplemented`

What happens if you try to add `Circle + Square`? Inside `Circle.__add__`, if you don't know how to handle a `Square`, you should return `NotImplemented` (not raise an Error!). This gives Python a chance to ask the `Square` via `__radd__` (Right-Side Add) if it knows how to handle the Circle. If both return `NotImplemented`, then Python raises a `TypeError`.

Common Dunder Cheat Sheet

• `__new__`: Use for immutable types (Metaclass magic).
• `__del__`: Destructor (Don't rely on it!).
• `__contains__`: For `in` operator (e.g., `if x in collection`).
• `__bool__`: For boolean context (e.g., `if obj:`).