Academy — Sanjib Sikder

The Secret Behind Built-in Behaviour

When you write len([1, 2, 3]), Python calls list.__len__(). When you write "abc" + "def", Python calls str.__add__(). When you write 10 > 5, Python calls int.__gt__().

Every operator, every built-in function, every piece of syntax you've been using is backed by a dunder method — a method with double underscores on both sides. You've already seen two: __init__ and __str__. There are dozens more.

By implementing them in your own classes, you make your objects feel native to the language. They work with len(), with +, with <, with in, with indexing — exactly like built-in types.

`repr` and `str`

You already know __str__ controls what print() shows. __repr__ is its complement — it provides an unambiguous, developer-facing representation, used in the REPL and for debugging.

Python

Ctrl+Enter to run

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

    def __repr__(self):
        return f#22c55e">"Point({self.x}, {self.y})"

    def __str__(self):
        return f#22c55e">"({self.x}, {self.y})"

p = Point(3, 7)
print(str(p)) # Uses **str**
print(repr(p)) # Uses **repr**
print([p]) # Inside a list, uses **repr**

The rule of thumb: __repr__ should ideally be a string that, if pasted into Python, recreates the object. __str__ is for human display. If you only define one, define __repr__ — Python falls back to it for __str__ when __str__ is absent.

`len` and `bool`

Python

Ctrl+Enter to run

class Playlist:
    def __init__(self, name):
        self.name  = name
        self.songs = []

    def add(self, song):
        self.songs.append(song)

    def __len__(self):
        return len(self.songs)

    def __bool__(self):
        return len(self.songs) > 0

    def __repr__(self):
        return f#22c55e">"Playlist({self.name!r}, {len(self)} songs)"

p = Playlist(#22c55e">"Morning Mix")
print(len(p))
print(bool(p))

p.add(#22c55e">"Song A")
p.add(#22c55e">"Song B")
print(len(p))
print(bool(p))
print(p)

Once __len__ is defined, len(playlist) works naturally. Once __bool__ is defined, if playlist: works — truthy when non-empty, falsy when empty. If __bool__ is not defined but __len__ is, Python uses len(obj) != 0 as the boolean value automatically.

Comparison Operators

Define these to make your objects comparable with ==, <, >, and so on:

Dunder	Operator
`__eq__`	`==`
`__ne__`	`!=`
`__lt__`	`<`
`__le__`	`<=`
`__gt__`	`>`
`__ge__`	`>=`

Python

Ctrl+Enter to run

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

    def __repr__(self):
        return f#22c55e">"Temperature({self.celsius}°C)"

    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(20)
t2 = Temperature(35)
t3 = Temperature(20)

print(t1 == t3)
print(t1 < t2)
print(t2 > t1)

readings = [Temperature(35), Temperature(12), Temperature(28), Temperature(20)]
print(sorted(readings))

Defining __lt__ and __eq__ is enough to make sorted() work on your objects. Python's sort uses __lt__ for comparisons.

A shortcut: from functools import total_ordering lets you define only __eq__ and one comparison method, and Python fills in the rest automatically.

Arithmetic Operators

Python

Ctrl+Enter to run

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

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

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

    def __abs__(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5

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

print(v1 + v2)
print(v1 - v2)
print(v1 * 3)
print(abs(v1))

v1 + v2 calls v1.__add__(v2). abs(v1) calls v1.__abs__(). Your Vector class now behaves like a native numeric type for these operations.

`getitem`, `setitem`, `contains`

These give your objects indexing (obj[key]), index assignment (obj[key] = value), and in support:

Python

Ctrl+Enter to run

class NumberGrid:
    def __init__(self, rows, cols):
        self.data = [[0] * cols for _ in range(rows)]
        self.rows = rows
        self.cols = cols

    def __getitem__(self, pos):
        row, col = pos
        return self.data[row][col]

    def __setitem__(self, pos, value):
        row, col = pos
        self.data[row][col] = value

    def __contains__(self, value):
        return any(value in row for row in self.data)

    def __repr__(self):
        return #22c55e">"\n".join(str(row) for row in self.data)

grid = NumberGrid(3, 3)
grid[0, 0] = 5
grid[1, 2] = 9
grid[2, 1] = 3

print(grid)
print(grid[1, 2])
print(9 in grid)
print(7 in grid)

grid[0, 0] = 5 calls grid.__setitem__((0, 0), 5) — the tuple (0, 0) is passed as pos. 9 in grid calls grid.__contains__(9). Your class now supports natural Python syntax.

`call` — Making Objects Callable

Adding __call__ makes an instance callable like a function:

Python

Ctrl+Enter to run

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

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

    def __repr__(self):
        return f#22c55e">"Multiplier(×{self.factor})"

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

print(double(10))
print(triple(10))
print(double(triple(4)))

double(10) calls double.__call__(10). The object behaves exactly like a function — but carries its own state. This is the foundation of callable objects and, in machine learning, of the layer objects in frameworks like PyTorch.

What You Have Learned

Dunder methods are Python's interface for making objects feel native to the language — not special cases, but full participants in its syntax.

The key ideas:

Dunders power all operators and built-in functions behind the scenes
__repr__ — developer representation; __str__ — human display; define __repr__ first
__len__ and __bool__ enable len() and truthiness checks
Comparison dunders (__eq__, __lt__, etc.) enable operators and sorted()
Arithmetic dunders (__add__, __mul__, etc.) enable operators on custom types
__getitem__, __setitem__, __contains__ enable indexing and in
__call__ makes an instance callable like a function

In the next lesson, you'll go deeper into comprehensions — dict and set comprehensions, nested comprehensions, and the powerful zip and enumerate tools.

Dunder Methods

The Secret Behind Built-in Behaviour

__repr__ and __str__

__len__ and __bool__

Comparison Operators

Arithmetic Operators

__getitem__, __setitem__, __contains__

__call__ — Making Objects Callable

What You Have Learned

`repr` and `str`

`len` and `bool`

`getitem`, `setitem`, `contains`

`call` — Making Objects Callable