Python Magic Methods – Dunder Methods Explained

__str__ and __repr__

__str__: human-readable string (for print). __repr__: developer representation (unambiguous, for debugging).

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

    def __str__(self):
        return f"Point({self.x}, {self.y})"

    def __repr__(self):
        return f"Point(x={self.x!r}, y={self.y!r})"

p = Point(3, 4)
print(str(p))   # Point(3, 4)      — uses __str__
print(repr(p))  # Point(x=3, y=4)  — uses __repr__
print(p)        # Point(3, 4)      — print uses __str__

Comparison Methods

Define how objects are compared with ==, <, >, <=, >= operators.

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    def __eq__(self, other):
        return self.celsius == other.celsius

    def __lt__(self, other):
        return self.celsius < other.celsius

    def __le__(self, other):
        return self.celsius <= other.celsius

t1 = Temperature(25)
t2 = Temperature(30)

print(t1 == t2)   # False
print(t1 < t2)    # True
temps = [Temperature(30), Temperature(10), Temperature(20)]
print([t.celsius for t in sorted(temps)])  # [10, 20, 30]

Arithmetic Methods

Make + - * / work on your objects.

class Money:
    def __init__(self, amount, currency="USD"):
        self.amount = amount
        self.currency = currency

    def __add__(self, other):
        if self.currency != other.currency:
            raise ValueError("Cannot add different currencies")
        return Money(self.amount + other.amount, self.currency)

    def __str__(self):
        return f"{self.currency} {self.amount:.2f}"

wallet = Money(50) + Money(30)
print(wallet)   # USD 80.00

Container Methods

__len__, __getitem__, __contains__ make custom objects behave like sequences.

class Library:
    def __init__(self):
        self._books = []

    def add(self, book): self._books.append(book)
    def __len__(self): return len(self._books)
    def __getitem__(self, idx): return self._books[idx]
    def __contains__(self, book): return book in self._books

lib = Library()
lib.add("Python Crash Course")
lib.add("Fluent Python")

print(len(lib))                    # 2
print(lib[0])                      # Python Crash Course
print("Fluent Python" in lib)      # True

Dunder Methods: Making Your Objects Feel Built-in

"Magic" (dunder) methods let your class hook into Python's syntax. Define __add__ and + works on your objects; define __len__ and len() works. You're not calling them directly — the interpreter does.

class Money:
    def __init__(self, amt): self.amt = amt
    def __repr__(self): return f"Money({self.amt})"    # for developers
    def __str__(self):  return f"${self.amt:.2f}"      # for users
    def __add__(self, other): return Money(self.amt + other.amt)
    def __eq__(self, other):  return self.amt == other.amt

print(Money(5) + Money(3))   # $8.00 — uses __add__ then __str__

Two pairings people get wrong

• __str__ vs __repr__: str()/print use __str__ (readable); the REPL and containers use __repr__ (unambiguous, ideally reconstructable). Define __repr__ at minimum — it's the fallback for both.
• __eq__ + __hash__: define __eq__ and Python sets __hash__ to None, making instances unhashable (can't go in sets/dict keys). If two equal objects should hash the same, define __hash__ too.

Interview Questions on Magic Methods

• What are magic (dunder) methods in Python?
• What is the difference between __str__ and __repr__?
• Which magic methods let you use the + and == operators on your objects?
• How do you make a custom object work with len() and the in operator?
• What magic methods make an object iterable?
• What does __call__ do?
• Why is implementing __repr__ considered good practice?

Related Topics