Special Methods, Overloading and Overriding

class Box:
    def __init__(self, contents):
        self.contents = contents

    def __str__(self):
        return f"Box({self.contents!r})"

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

b = Box([1, 2, 3])
print(b)          # Box([1, 2, 3]) -> print() called __str__() automatically
print(len(b))   # 3 -> len() called __len__() automatically

Box([1, 2, 3])
3

class Box:
    def __init__(self, contents):
        self.contents = contents

    def __str__(self):
        return f"Box with {len(self.contents)} item(s)"   # readable, user-facing

    def __repr__(self):
        return f"Box({self.contents!r})"                       # unambiguous, developer-facing

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

b = Box([1, 2, 3])
print(b)          # Box with 3 item(s)   -> print() calls __str__
print(repr(b))   # Box([1, 2, 3])          -> repr() calls __repr__, ignores __str__ entirely
print([b])         # [Box([1, 2, 3])]        -> a list prints repr() of its elements, even though __str__ exists

Box with 3 item(s)
Box([1, 2, 3])
[Box([1, 2, 3])]

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

    def __eq__(self, other):
        return self.amount == other.amount   # compare values, not identity

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

a = Money(10)
b = Money(10)
c = Money(20)

print(a == b)   # True -> calls a.__eq__(b), compares amounts
print(a is b)     # False -> still two separate objects (2.4)
print(a < c)      # True -> calls a.__lt__(c)

True
False
True

print(a > c)   # False -> no __gt__ defined, so Python tries c.__lt__(a) instead: 20 < 10 is False

try:
    a <= c   # <= has nothing to do with __lt__ - it needs __le__ (or __ge__ on the other side)
except TypeError as e:
    print("TypeError:", e)   # '<=' not supported between instances of 'Money' and 'Money'

print(a != c)   # True -> __ne__ wasn't defined either, but Python auto-inverts __eq__ for it

False
TypeError: '<=' not supported between instances of 'Money' and 'Money'
True

try:
    hash(a)   # a = Money(10), from above - __eq__ was defined, so Python set Money.__hash__ = None
except TypeError as e:
    print("TypeError:", e)   # unhashable type: 'Money'

try:
    {a}   # a set needs to hash its members too
except TypeError as e:
    print("TypeError:", e)   # unhashable type: 'Money'

TypeError: unhashable type: 'Money'
TypeError: unhashable type: 'Money'

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

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

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

    def __hash__(self):             # must be re-defined explicitly - not inherited automatically
        return hash(self.amount)     # equal Money objects now hash identically too

m1 = Money(10)
m2 = Money(10)
print(m1 == m2, hash(m1) == hash(m2))   # True True -> equal objects, equal hashes, as hashing requires
print(len({m1, m2}))                            # 1 -> the set correctly treats them as duplicates

True True
1

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})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)   # Vector(4, 6) -> calls v1.__add__(v2)

Vector(4, 6)

try:
    5 + v1   # int.__add__(5, v1) -> NotImplemented, and Vector has no __radd__ either
except TypeError as e:
    print("TypeError:", e)   # unsupported operand type(s) for +: 'int' and 'Vector'

TypeError: unsupported operand type(s) for +: 'int' and 'Vector'

vectors = [Vector(1, 1), Vector(2, 2), Vector(3, 3)]

try:
    total = sum(vectors)   # internally: 0 + Vector(1,1) + Vector(2,2) + Vector(3,3)
except TypeError as e:
    print("TypeError:", e)   # unsupported operand type(s) for +: 'int' and 'Vector'

TypeError: unsupported operand type(s) for +: 'int' and 'Vector'

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 __radd__(self, other):   # called for "other + self" when other's __add__ gave up
        if other == 0:                 # handles sum()'s implicit "0 + first_item" start
            return self
        return NotImplemented

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

vectors = [Vector(1, 1), Vector(2, 2), Vector(3, 3)]
print(sum(vectors))   # Vector(6, 6) -> works now

Vector(6, 6)

class Oops:
    def __add__(self, other):
        return NotImplementedError   # BUG: the EXCEPTION CLASS, not the NotImplemented sentinel

o = Oops()
print(o + 1)   # <class 'NotImplementedError'> -> no error at all, just garbage output instead of a clean TypeError

try:
    raise NotImplemented   # BUG: NotImplemented is a plain object, not an exception - it can't be raised
except TypeError as e:
    print("TypeError:", e)   # exceptions must derive from BaseException

<class 'NotImplementedError'>
TypeError: exceptions must derive from BaseException

class Basket:
    def __init__(self, items):
        self.items = items

    def __iadd__(self, other):
        self.items.extend(other)   # mutate in place...
        return self                       # ...and return self, instead of a new object

    def __repr__(self):
        return f"Basket({self.items})"

basket = Basket([1, 2])
original_id = id(basket)
basket += [3, 4]   # calls basket.__iadd__([3, 4])
print(basket)                             # Basket([1, 2, 3, 4])
print(id(basket) == original_id)   # True -> same object, mutated in place

Basket([1, 2, 3, 4])
True

class NoInPlace:
    def __init__(self, items):
        self.items = items

    def __add__(self, other):
        return NoInPlace(self.items + other)   # always builds a NEW object

    def __repr__(self):
        return f"NoInPlace({self.items})"

n = NoInPlace([1, 2])
original_id = id(n)
n += [3, 4]   # no __iadd__ -> falls back to n = n + [3, 4]
print(n)                             # NoInPlace([1, 2, 3, 4])
print(id(n) == original_id)   # False -> a different object now

NoInPlace([1, 2, 3, 4])
False

class Greeter:
    def greet(self):                # this definition...
        return "Hello!"

    def greet(self, name):        # ...is completely replaced by this one
        return f"Hello, {name}!"

g = Greeter()
print(g.greet("Ada"))   # Hello, Ada! -> only the one-argument version exists at all now

try:
    g.greet()   # the zero-argument version is simply gone
except TypeError as e:
    print("TypeError:", e)   # Greeter.greet() missing 1 required positional argument: 'name'

Hello, Ada!
TypeError: Greeter.greet() missing 1 required positional argument: 'name'

class Point:
    def __init__(self, x):          # this constructor...
        self.x = x
        self.y = 0

    def __init__(self, x, y):     # ...is completely replaced by this one
        self.x = x
        self.y = y

p = Point(1, 2)
print(p.x, p.y)   # 1 2 -> only the two-argument version exists at all

try:
    Point(1)   # the one-argument version is simply gone
except TypeError as e:
    print("TypeError:", e)   # Point.__init__() missing 1 required positional argument: 'y'

1 2
TypeError: Point.__init__() missing 1 required positional argument: 'y'

class Greeter:
    def greet(self, name=None):   # one method, optional parameter, instead of two overloads
        if name is None:
            return "Hello!"
        return f"Hello, {name}!"

g = Greeter()
print(g.greet())          # Hello!
print(g.greet("Ada"))   # Hello, Ada!

Hello!
Hello, Ada!

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "some sound"

class Dog(Animal):
    def __init__(self, name, breed):   # overriding __init__ - a DIFFERENT class, allowed
        super().__init__(name)
        self.breed = breed

    def speak(self):                       # overriding speak() - allowed
        return "Woof!"

d = Dog("Rex", "Labrador")
print(d.name, d.breed, d.speak())   # Rex Labrador Woof!

Rex Labrador Woof!

class Person:
    def __init__(self, name):
        self._name = name

    def get_name(self):             # traditional getter method
        return self._name

    def set_name(self, value):   # traditional setter method
        if not value:
            raise ValueError("name cannot be empty")
        self._name = value

p = Person("Ada")
print(p.get_name())      # Ada
p.set_name("Grace")
print(p.get_name())      # Grace

try:
    p.set_name("")
except ValueError as e:
    print("ValueError:", e)   # name cannot be empty

Ada
Grace
ValueError: name cannot be empty

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def __getattr__(self, name):
        # only called when normal lookup FAILS - "radius" itself never reaches here
        if name == "area":
            return 3.14159 * self.radius ** 2
        raise AttributeError(f"'Circle' object has no attribute {name!r}")

c = Circle(2)
print(c.radius)   # 2 -> found normally, __getattr__ never even runs
print(c.area)      # 12.56636 -> "area" lookup failed, __getattr__ computed it on the fly

try:
    c.diameter
except AttributeError as e:
    print("AttributeError:", e)   # 'Circle' object has no attribute 'diameter'

2
12.56636
AttributeError: 'Circle' object has no attribute 'diameter'

class Logged:
    def __setattr__(self, name, value):
        print(f"setting {name} = {value!r}")
        super().__setattr__(name, value)   # delegate to the real assignment

l = Logged()
l.x = 10        # setting x = 10
l.y = "hello"   # setting y = 'hello'
print(vars(l))   # {'x': 10, 'y': 'hello'}

setting x = 10
setting y = 'hello'
{'x': 10, 'y': 'hello'}

import sys
sys.setrecursionlimit(50)   # fail fast for this demo, instead of hanging

class Broken:
    def __setattr__(self, name, value):
        self.name = value   # BUG: this assignment calls __setattr__ again -> infinite recursion

try:
    broken = Broken()
    broken.x = 1
except RecursionError as e:
    print("RecursionError:", e)   # maximum recursion depth exceeded

RecursionError: maximum recursion depth exceeded

class LoggedDelete:
    def __delattr__(self, name):
        print(f"deleting {name}")
        super().__delattr__(name)

ld = LoggedDelete()
ld.x = 10
del ld.x   # deleting x
print(vars(ld))   # {}

deleting x
{}

class Watched:
    def __init__(self, x):
        self.x = x

    def __getattribute__(self, name):
        print(f"accessing {name!r}")
        return super().__getattribute__(name)   # delegate to the real lookup, avoid recursion

w = Watched(5)
print(w.x)
# accessing 'x'   -> printed even though x already exists - __getattribute__ runs for EVERY access
# 5

accessing 'x'
5

class Box:
    def __init__(self, contents):
        self.contents = list(contents)

    def __str__(self):
        return f"Box({self.contents!r})"

    def __len__(self):
        return len(self.contents)          # len(box)

    def __getitem__(self, index):
        return self.contents[index]         # box[i]

    def __setitem__(self, index, value):
        self.contents[index] = value        # box[i] = value

    def __delitem__(self, index):
        del self.contents[index]            # del box[i]

    def __contains__(self, item):
        return item in self.contents        # item in box

box = Box([1, 2, 3])
print(len(box))              # 3           -> __len__
print(box[1])                  # 2           -> __getitem__
box[1] = 99                   # __setitem__
print(box[1])                  # 99
del box[0]                     # __delitem__
print(box.contents)          # [99, 3]
print(99 in box, 5 in box)   # True False  -> __contains__

3
2
99
[99, 3]
True False

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

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

double = Multiplier(2)
print(double(5))          # 10 -> double(5) is really double.__call__(5)
print(callable(double))   # True -> callable() checks whether __call__ exists

10
True