S009 · Classes & Objects — the OOP Mental Model

"""s009_classes.py — the Python class, end to end."""
from __future__ import annotations
from typing import Iterable, Iterator, Self
import json
 
# =========================
# Part 1 · The smallest useful class
# =========================
print("--- Part 1 ---")
 
class Point:
    """A 2D point with value semantics."""
 
    def __init__(self, x: float, y: float) -> None:
        self.x = x
        self.y = y
 
    def __repr__(self) -> str:
        return f"Point(x={self.x!r}, y={self.y!r})"
 
    def __eq__(self, other: object) -> bool:
        return isinstance(other, Point) and (self.x, self.y) == (other.x, other.y)
 
    def __hash__(self) -> int:
        return hash((self.x, self.y))
 
    def distance_to(self, other: Point) -> float:
        return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5
 
p, q = Point(3, 4), Point(3, 4)
print(p, q, p == q, p is q)              # equal by value, not identity
print({p, q})                            # only one — same hash
print(p.distance_to(Point(0, 0)))
 
# =========================
# Part 2 · Class attr vs instance attr — and the trap
# =========================
print("\n--- Part 2 ---")
 
class Config:
    debug: bool = False              # class attribute — safe (immutable)
    plugins: list[str] = []          # class attribute — MUTABLE, will be shared 😱
 
c1, c2 = Config(), Config()
c1.plugins.append("logger")          # mutates the shared class-level list
print(c2.plugins)                    # ['logger'] — surprise
 
# Fix — always initialise mutables in __init__
class ConfigFixed:
    debug: bool
    plugins: list[str]
 
    def __init__(self, debug: bool = False, plugins: list[str] | None = None) -> None:
        self.debug = debug
        self.plugins = list(plugins) if plugins else []
 
c1, c2 = ConfigFixed(), ConfigFixed()
c1.plugins.append("logger")
print(c2.plugins)                    # []
 
# =========================
# Part 3 · The three method flavours
# =========================
print("\n--- Part 3 ---")
 
class Temperature:
    """Value type with alternate constructors."""
 
    def __init__(self, celsius: float) -> None:
        self._c = celsius
 
    @classmethod
    def from_fahrenheit(cls, f: float) -> Self:
        return cls((f - 32) * 5 / 9)
 
    @classmethod
    def from_json(cls, s: str) -> Self:
        data = json.loads(s)
        return cls(data["celsius"])
 
    @staticmethod
    def is_valid(c: float) -> bool:
        # Doesn't need self or cls — pure function that belongs in this namespace.
        return -273.15 <= c <= 1e6
 
    @property
    def fahrenheit(self) -> float:
        return self._c * 9 / 5 + 32
 
    def __repr__(self) -> str:
        return f"Temperature({self._c}°C / {self.fahrenheit:.1f}°F)"
 
t = Temperature.from_fahrenheit(212)
print(t)
print(t.fahrenheit)                  # looks like an attribute; runs a method
print(Temperature.is_valid(-300))
print(Temperature.from_json('{"celsius": 100}'))
 
# =========================
# Part 4 · Make your class iterable
# =========================
print("\n--- Part 4 ---")
 
class Words:
    """A little collection that pretends to be a list of words."""
 
    def __init__(self, text: str) -> None:
        self._words = text.split()
 
    def __len__(self) -> int:
        return len(self._words)
 
    def __iter__(self) -> Iterator[str]:
        yield from self._words
 
    def __getitem__(self, i: int) -> str:
        return self._words[i]
 
    def __repr__(self) -> str:
        return f"Words({len(self)} words)"
 
w = Words("the quick brown fox jumps")
print(w, len(w), w[0], list(w))
print("brown" in w)                  # True — iteration is enough for `in`
 
# =========================
# Part 5 · Context manager the hard way (dunder) and the easy way (contextlib)
# =========================
print("\n--- Part 5 ---")
 
class Timer:
    """Prints elapsed time when used in a with-block."""
 
    def __enter__(self) -> Self:
        import time
        self.t0 = time.perf_counter()
        return self
 
    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
        import time
        elapsed = (time.perf_counter() - self.t0) * 1000
        print(f"  Timer: {elapsed:.2f} ms")
 
with Timer():
    _ = sum(i * i for i in range(10_000))
 
# =========================
# Part 6 · When NOT to use a class
# =========================
print("\n--- Part 6 ---")
 
# BAD — a class with __init__ + one method is a function
class GreetingBuilder:
    def __init__(self, greeting: str) -> None:
        self.greeting = greeting
    def build(self, name: str) -> str:
        return f"{self.greeting}, {name}!"
 
# GOOD — closure or partial
def make_greeter(greeting: str):
    def greeter(name: str) -> str:
        return f"{greeting}, {name}!"
    return greeter
 
print(GreetingBuilder("hi").build("ada"))
print(make_greeter("hi")("ada"))
 
# Rule of thumb: if the class has one meaningful method + __init__,
# and no dunder hooks are needed, use a closure or a partial.