Classes and Inheritance

A class is a blueprint for creating objects that bundle state (attributes) and behavior (methods). In Python, every class implicitly inherits from object:

class Signal:
    """A discrete-time signal with metadata."""

    def __init__(self, data: np.ndarray, sample_rate: float = 1.0):
        self.data = data
        self.sample_rate = sample_rate

    def duration(self) -> float:
        return len(self.data) / self.sample_rate

    def __repr__(self) -> str:
        return f"Signal(n={len(self.data)}, fs={self.sample_rate})"

The __init__ method initializes instance attributes; self refers to the instance being created.

A dataclass (from dataclasses) auto-generates __init__, __repr__, and __eq__ from annotated class attributes. This eliminates boilerplate for classes that are primarily data containers:

from dataclasses import dataclass, field

@dataclass
class SimulationConfig:
    """All parameters for a compressed sensing simulation."""
    n_measurements: int = 100
    n_features: int = 500
    sparsity: int = 10
    snr_db: float = 20.0
    algorithm: str = "lasso"
    max_iterations: int = 1000
    tolerance: float = 1e-6
    random_seed: int = 42
    tags: list[str] = field(default_factory=list)

The field(default_factory=list) avoids the mutable default argument trap. Dataclasses support frozen=True for immutable configs and slots=True (Python 3.10+) for memory-efficient storage.

Inheritance lets a child class reuse and extend a parent class. The child inherits all attributes and methods, and can override or extend them:

class Solver:
    """Base class for iterative solvers."""

    def __init__(self, config: SimulationConfig):
        self.config = config
        self.history: list[float] = []

    def solve(self, A: np.ndarray, y: np.ndarray) -> np.ndarray:
        raise NotImplementedError("Subclasses must implement solve()")

    def log_iteration(self, cost: float) -> None:
        self.history.append(cost)

class LASSOSolver(Solver):
    """LASSO via ISTA (Iterative Shrinkage-Thresholding)."""

    def solve(self, A: np.ndarray, y: np.ndarray) -> np.ndarray:
        x = np.zeros(A.shape[1])
        lam = 1.0 / self.config.snr_db
        for i in range(self.config.max_iterations):
            gradient = A.T @ (A @ x - y)
            x = self._soft_threshold(x - 0.01 * gradient, lam * 0.01)
            cost = 0.5 * np.linalg.norm(A @ x - y)**2 + lam * np.linalg.norm(x, 1)
            self.log_iteration(cost)
        return x

    @staticmethod
    def _soft_threshold(x: np.ndarray, threshold: float) -> np.ndarray:
        return np.sign(x) * np.maximum(np.abs(x) - threshold, 0)

LASSOSolver inherits __init__, log_iteration, and history from Solver, and provides its own solve implementation.

The Method Resolution Order is the sequence in which Python searches classes when looking up a method. Python uses the C3 linearization algorithm to compute a consistent ordering for multiple inheritance:

class A:
    def method(self): return "A"

class B(A):
    def method(self): return "B"

class C(A):
    def method(self): return "C"

class D(B, C):
    pass

print(D.__mro__)
# (D, B, C, A, object)
print(D().method())  # "B" — B comes before C in MRO

Use super() to delegate to the next class in the MRO, not just the parent. This ensures cooperative multiple inheritance works correctly.

super() returns a proxy object that delegates method calls to the next class in the MRO. It is essential for cooperative multiple inheritance:

class Solver:
    def __init__(self, config):
        self.config = config

class LoggingMixin:
    def __init__(self, *args, verbose=False, **kwargs):
        super().__init__(*args, **kwargs)
        self.verbose = verbose

class VerboseLASSOSolver(LoggingMixin, LASSOSolver):
    pass  # Gets both LoggingMixin.__init__ and LASSOSolver.solve

Always use super() instead of hardcoding the parent class name. This makes refactoring and mixin composition safe.