Dunder Methods Part 3 — __add__ & __len__

By the end of this lesson you can:

• Define __add__(self, other) so a + b works.
• Define __len__(self) so len(obj) works.
• Define __contains__(self, item) so x in obj works.
• Get a taste of __iter__ for for x in obj:.

Every Python operator is secretly a dunder call:

a + b      a.__add__(b)
a - b      a.__sub__(b)
a * b      a.__mul__(b)
a / b      a.__truediv__(b)
a // b     a.__floordiv__(b)
a % b      a.__mod__(b)
a ** b     a.__pow__(b)

len(x)     x.__len__()
bool(x)    x.__bool__()
x in y     y.__contains__(x)
for x in y y.__iter__()

You've been using these on built-in types (1 + 2, len("hi")) for two levels. Today you teach them to your classes.

__add__ — the + operator

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

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

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

print(Vector(1, 2) + Vector(3, 4))   # → Vector(4, 6)

Returns a new Vector — never modifies self. That's the "immutable + returns new" convention. Same way 1 + 2 doesn't change 1; it gives back 3.

The full arithmetic family

class Vector:
    def __init__(self, x, y):
        self.x = x; self.y = 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)

Notice __mul__ takes a number, not another Vector — there are two reasonable interpretations of vector multiplication, and scalar multiplication is the simple one.

__len__ — the len() builtin

class Inventory:
    def __init__(self):
        self.items = []
    def add(self, item):
        self.items.append(item)
    def __len__(self):
        return len(self.items)

inv = Inventory()
inv.add("sword"); inv.add("potion")
print(len(inv))    # → 2

__len__ must return a non-negative integer. Once defined, bool(inv) also works — an inventory with zero items is falsy.

__contains__ — the in operator

class Inventory:
    # ... existing ...
    def __contains__(self, item):
        return item in self.items

inv = Inventory()
inv.add("sword")
print("sword" in inv)      # → True
print("dragon" in inv)     # → False

__iter__ — the for loop

Make your class iterable by returning an iterator from __iter__. The easiest way: delegate to an existing iterable.

class Inventory:
    # ... existing ...
    def __iter__(self):
        return iter(self.items)

inv = Inventory()
inv.add("sword"); inv.add("potion"); inv.add("scroll")

for item in inv:
    print("  ", item)
# sword
# potion
# scroll

Now Inventory behaves like a list: len, in, for x in all work. Plus list(inv), sum(inv), max(inv), comprehensions — anything that iterates.

The reverse · __radd__

If you do 3 + my_vector instead of my_vector + 3, Python first asks int.__add__(3, my_vector). If that returns NotImplemented, Python tries my_vector.__radd__(3) — the "reflected" add.

class Vector:
    # ... existing ...
    def __radd__(self, other):
        # other is the left operand. e.g. sum([v1, v2, v3]) starts at 0
        if other == 0:
            return self
        return self.__add__(other)

The if other == 0 trick lets sum([v1, v2]) work — sum starts from 0 and tries to add a Vector. Without __radd__, you'd get TypeError: unsupported operand type(s) for +: 'int' and 'Vector'.

A practical use case: a Money class that prevents accidental currency mixing. Save as money.py:

# money.py — Money with arithmetic, comparison, length-like ops

from functools import total_ordering

@total_ordering
class Money:
    def __init__(self, amount, currency="RM"):
        self.amount   = round(float(amount), 2)
        self.currency = currency

    def __repr__(self):
        return f"Money({self.amount}, {self.currency!r})"

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

    def _check(self, other):
        if self.currency != other.currency:
            raise ValueError(
                f"Currency mismatch: {self.currency} vs {other.currency}")

    def __add__(self, other):
        self._check(other)
        return Money(self.amount + other.amount, self.currency)

    def __sub__(self, other):
        self._check(other)
        return Money(self.amount - other.amount, self.currency)

    def __mul__(self, n):
        return Money(self.amount * n, self.currency)

    def __radd__(self, other):
        if other == 0:
            return self
        raise TypeError("Can only add Money to Money or 0")

    def __eq__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        return (self.amount, self.currency) == (other.amount, other.currency)

    def __lt__(self, other):
        self._check(other)
        return self.amount < other.amount

    def __hash__(self):
        return hash((self.amount, self.currency))


a = Money(8, "RM")
b = Money(3.50, "RM")

print(a + b)                          # → RM 11.50
print(b * 3)                          # → RM 10.50
print(a > b)                          # → True

# sum() works because of __radd__
basket = [Money(5), Money(3), Money(2.50)]
print("Total:", sum(basket))          # → RM 10.50

# Currency safety
gbp = Money(10, "GBP")
try:
    a + gbp
except ValueError as e:
    print(f"Refused: {e}")

Output

RM 11.50
RM 10.50
True
Total: RM 10.50
Refused: Currency mismatch: RM vs GBP

Read the diff

Money supports +, -, * (by a number), comparison, and is sum-able. Currency mismatch raises an error — exactly the kind of invariant from PY-L3-10. The __radd__ exists solely to make sum([...]) work. _check is a private helper used by every arithmetic operator that requires matching currencies.

Operator dunders make your class feel native. __add__ wires up +; __len__ wires up len(); __contains__ wires up in; __iter__ wires up for. __radd__ handles the reverse direction so sum([a, b]) works. Arithmetic dunders should return a new instance — never mutate self or other. The whole Python language is built on this pattern: define the right dunder and your class plugs into the rest.