The object model & metaclasses

dunder.py# Dunders let your objects plug into built-in syntax and protocols.
from functools import total_ordering

@total_ordering
class Money:
    def __init__(self, cents): self.cents = cents
    def __repr__(self): return f"Money({self.cents})"          # repr()
    def __eq__(self, o): return isinstance(o, Money) and self.cents == o.cents
    def __lt__(self, o): return self.cents < o.cents            # + total_ordering => <=,>,>=
    def __add__(self, o): return Money(self.cents + o.cents)    # a + b
    def __hash__(self): return hash(self.cents)                 # usable in set/dict

a, b = Money(150), Money(99)
print(a + b)                 # Money(249)  via __add__
print(a > b, a == Money(150))# True True   via __lt__/@total_ordering and __eq__
print(sorted([a, b]))        # [Money(99), Money(150)]  via __lt__
print(len({a, Money(150)}))  # 1  via __hash__/__eq__ (deduped)

lookup.py# Attribute lookup: __getattribute__ runs for EVERY access; __getattr__ is the
# fallback that runs ONLY when normal lookup fails.
class Config:
    def __init__(self): self.host = "localhost"
    def __getattr__(self, name):
        # only reached when 'name' is not found the normal way
        return f"<default:{name}>"

c = Config()
print(c.host)        # localhost   -> found normally, __getattr__ NOT called
print(c.port)        # <default:port> -> missing, so __getattr__ handles it

# __getattribute__ intercepts everything (use with care -> easy infinite loops)
class Logged:
    def __getattribute__(self, name):
        # MUST delegate via super() to avoid recursing forever
        val = super().__getattribute__(name)
        print(f"  access {name!r}")
        return val
    def __init__(self): self.x = 1

obj = Logged()
_ = obj.x            # prints the access line, then returns 1

descriptor.py# A descriptor is any object defining __get__/__set__/__delete__ that lives on a
# CLASS. It controls attribute access for instances. @property and methods are
# descriptors under the hood.
class Positive:
    def __set_name__(self, owner, name):        # remember the attribute's name
        self.store = "_" + name
    def __get__(self, obj, objtype=None):
        if obj is None: return self             # accessed on the class
        return getattr(obj, self.store)
    def __set__(self, obj, value):
        if value < 0:
            raise ValueError(f"{self.store[1:]} must be >= 0")
        setattr(obj, self.store, value)

class Account:
    balance = Positive()                        # a data descriptor on the class
    def __init__(self, b): self.balance = b     # goes through __set__ -> validated

acct = Account(100)
print("balance:", acct.balance)                 # via __get__
try:
    acct.balance = -5                           # via __set__ -> guard trips
except ValueError as e:
    print("rejected:", e)

# Proof that @property and methods ARE descriptors:
class Demo:
    @property
    def p(self): return 1
    def m(self): return 2
print("property is descriptor:", hasattr(Demo.__dict__["p"], "__get__"))
print("function is descriptor:", hasattr(Demo.__dict__["m"], "__get__"))

mro.py# The MRO (method resolution order) is the single, linear order Python searches
# for attributes. It is computed by the C3 linearization algorithm.
class A:
    def who(self): return "A"
class B(A):
    def who(self): return "B"
class C(A):
    def who(self): return "C"
class D(B, C):        # the classic diamond
    pass

print([cls.__name__ for cls in D.__mro__])   # D, B, C, A, object
print(D().who())                             # 'B' -> first match along the MRO

# super() follows the MRO, NOT the literal base — cooperative multiple inheritance
class Base:
    def __init__(self): self.log = ["Base"]
class L(Base):
    def __init__(self): super().__init__(); self.log.append("L")
class R(Base):
    def __init__(self): super().__init__(); self.log.append("R")
class LR(L, R):
    def __init__(self): super().__init__(); self.log.append("LR")

print(LR().log)                              # ['Base', 'R', 'L', 'LR']

slots.py# __slots__ replaces the per-instance __dict__ with fixed storage: less memory,
# slightly faster attribute access, and no arbitrary new attributes.
import sys, tracemalloc

class WithDict:
    def __init__(self, a, b, c): self.a, self.b, self.c = a, b, c

class WithSlots:
    __slots__ = ("a", "b", "c")
    def __init__(self, a, b, c): self.a, self.b, self.c = a, b, c

d, s = WithDict(1, 2, 3), WithSlots(1, 2, 3)
print("dict instance has __dict__ :", hasattr(d, "__dict__"))   # True
print("slots instance has __dict__:", hasattr(s, "__dict__"))   # False

try:
    s.d = 4                       # not in __slots__
except AttributeError as e:
    print("slots blocks new attr :", type(e).__name__)

def footprint(cls, n=100_000):
    tracemalloc.start()
    keep = [cls(1, 2, 3) for _ in range(n)]
    used, _ = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    return used

md, ms = footprint(WithDict), footprint(WithSlots)
print(f"100k objs -> dict {md/1e6:.1f} MB  slots {ms/1e6:.1f} MB")

metaclass.py# A class is an OBJECT whose type is `type`. type is the default metaclass.
class Plain: pass
print(type(Plain))          # <class 'type'>
print(type(type))           # <class 'type'>  (type is its own type)

# type(name, bases, namespace) builds a class dynamically — same as `class`.
Dyn = type("Dyn", (), {"greet": lambda self: "hi"})
print(Dyn().greet())        # hi

# A real metaclass: auto-register every subclass in a plugin registry.
class PluginMeta(type):
    registry = {}
    def __new__(mcls, name, bases, ns, **kw):
        cls = super().__new__(mcls, name, bases, ns)
        if bases:                                   # skip the base itself
            PluginMeta.registry[name.lower()] = cls
        return cls

class Plugin(metaclass=PluginMeta): pass
class CsvLoader(Plugin): pass
class JsonLoader(Plugin): pass

print(sorted(PluginMeta.registry))                  # ['csvloader', 'jsonloader']
print(type(CsvLoader).__name__)                     # PluginMeta

init_subclass.py# __init_subclass__ hooks subclass creation WITHOUT a metaclass — usually the
# right tool. It runs on the PARENT each time a subclass is defined.
class Tool:
    registry = {}
    def __init_subclass__(cls, /, name=None, **kw):
        super().__init_subclass__(**kw)
        cls.tool_name = name or cls.__name__.lower()
        Tool.registry[cls.tool_name] = cls

class Search(Tool, name="search"): pass
class Calc(Tool): pass

print(sorted(Tool.registry))     # ['calc', 'search']
print(Search.tool_name)          # search