Inheritance, Composition, dataclasses & Value Objects

Object-oriented design in Python balances code reuse against architectural coupling. While inheritance establishes “Is-A” relationships, excessive inheritance creates fragile base class problems. Modern Python engineering favors Composition (“Has-A”) and immutable Value Objects created via dataclasses (PEP 557).

This chapter details Inheritance vs Composition trade-offs, Value Object immutability, dataclass code generation mechanics, and __post_init__ validation hooks.

1. Inheritance vs. Composition Architectural Invariants

Inheritance (“Is-A”): Subclasses inherit behavior and state from a base class. Use inheritance strictly when the child class is a specialized subtype of the parent class, fulfilling the Liskov Substitution Principle (LSP).
Composition (“Has-A”): A class delegates responsibility by referencing component objects. Composition decouples components, making software easier to test, extend, and refactor.

Inheritance vs Composition Architecture:

Inheritance (Tight Coupling):
[ BaseWorker ]
      |
      v
[ ProcessingWorker ] (Changes in BaseWorker risk breaking ProcessingWorker!)

Composition (Decoupled Wiring):
[ ProcessingWorker ] ──> Uses ──> [ StrategyInterface ]
                                            ├── [ KafkaPublisher ]
                                            └── [ PostgresLogger ]

2. Standard Data Containers: `dataclasses` (PEP 557)

Prior to Python 3.7, creating data container classes required writing repetitive boilerplate (__init__, __repr__, __eq__, __hash__).

The @dataclass decorator inspects class type annotations and generates C-optimized dunder methods automatically at class definition time:

from dataclasses import dataclass, field
from datetime import datetime

@dataclass(frozen=True, slots=True)
class UserProfile:
    user_id: int
    email: str
    created_at: datetime = field(default_factory=datetime.now)

Generated Methods:

__init__(): Assigns typed fields.
__repr__(): Formats explicit string representation (UserProfile(user_id=1, ...)).
__eq__(): Evaluates value equality across all fields.
__hash__(): Generates hash code (enabled when frozen=True).
slots=True (Python 3.10+): Generates __slots__ automatically for memory optimization.

3. Immutability & Value Objects (`frozen=True`)

In Domain-Driven Design (DDD), a Value Object is defined entirely by its attributes (e.g. Money(amount=100, currency="USD")) rather than an identity key. Value Objects must be immutable.

Setting frozen=True on a @dataclass enforces immutability by intercepting attribute writes:

@dataclass(frozen=True)
class Money:
    amount: Decimal
    currency: str

m = Money(Decimal("50.00"), "USD")
m.amount = Decimal("100.00") # RAISES FrozenInstanceError!

4. Custom Initialization & Validation (`__post_init__`)

When a @dataclass generates __init__(), it calls __post_init__() immediately after assigning fields. Use __post_init__ for domain validation and derived field computation:

@dataclass
class Order:
    items: list[str]
    total_price: Decimal

    def __post_init__(self):
        # Validation Hook
        if self.total_price < 0:
            raise ValueError("Total price cannot be negative")
        if not self.items:
            raise ValueError("Order must contain at least one item")

⚡

Revision Mode Active Condensed for 5-minute review. Focused on 30-second pitches, mental anchors, and high-frequency interview traps.

⚡ 30-Second Elevator Pitch

“Favor Composition (“Has-A”) over Inheritance (“Is-A”) to prevent fragile base class coupling. Use @dataclass to generate boilerplate __init__, __eq__, and __repr__ methods automatically from type hints. Use frozen=True to create immutable Value Objects, slots=True for 60% memory savings, and __post_init__ for domain validation.”

🧠 Under The Hood & Mental Model

Dataclass Code Generation: @dataclass inspects class __annotations__ at definition time and generates optimized Python dunder methods.
frozen=True Invariant: Overrides __setattr__ and __delattr__ to raise FrozenInstanceError on attribute mutations.
slots=True (3.10+): Instructs dataclass code generation to add __slots__, bypassing __dict__ memory allocation.
__post_init__ Hook: Called automatically by the generated __init__ method after assigning field variables.

💻 High-Yield Code & Gotcha

# ❌ ANTI-PATTERN: Manual Boilerplate & Fragile Inheritance
class BaseEntity:
    def __init__(self, id):
        self.id = id

class User(BaseEntity):
    def __init__(self, id, name):
        super().__init__(id)
        self.name = name  # Verbose boilerplate! Needs manual __eq__ and __repr__!

# ✅ PRODUCTION PATTERN: Immutable Slotted Dataclass
from dataclasses import dataclass, field

@dataclass(frozen=True, slots=True)
class User:
    id: int
    name: str

    def __post_init__(self):
        if not self.name:
            raise ValueError("Name cannot be empty")

⚠️ GOTCHA: Mutable Default Arguments in Dataclasses

Writing items: list = [] inside a dataclass definition raises a runtime ValueError: mutable default <class 'list'> for field items is not allowed. Always use field(default_factory=list).

⚖️ Trade-Offs & Comparison

+ @dataclass: Eliminates hundreds of lines of dunder boilerplate; integrated with static type checkers.
- @dataclass: Performs no runtime type enforcement on instantiation (unlike Pydantic). Use __post_init__ or Pydantic if runtime validation is required.

🌟 My Experience (STAR Anchor)

“A core domain service suffered bugs caused by mutable state mutations in order payloads across processing threads. I refactored the domain objects into frozen, slotted dataclasses (@dataclass(frozen=True, slots=True)); state mutation bugs were eliminated and memory consumption dropped by 55%.”

Python Interview Handbook

Inheritance, Composition, dataclasses & Value Objects

1. Inheritance vs. Composition Architectural Invariants

2. Standard Data Containers: `dataclasses` (PEP 557)

Generated Methods:

3. Immutability & Value Objects (`frozen=True`)

4. Custom Initialization & Validation (`__post_init__`)

⚡ 30-Second Elevator Pitch

🧠 Under The Hood & Mental Model

💻 High-Yield Code & Gotcha

⚠️ GOTCHA: Mutable Default Arguments in Dataclasses

⚖️ Trade-Offs & Comparison

🌟 My Experience (STAR Anchor)

Why is Composition ('Has-A') generally preferred over Deep Inheritance ('Is-A') in system design?

No Interactive Questions Yet

Inheritance, Composition, dataclasses & Value Objects

1. Inheritance vs. Composition Architectural Invariants

2. Standard Data Containers: dataclasses (PEP 557)

Generated Methods:

3. Immutability & Value Objects (frozen=True)

4. Custom Initialization & Validation (__post_init__)

⚡ 30-Second Elevator Pitch

🧠 Under The Hood & Mental Model

💻 High-Yield Code & Gotcha

⚠️ GOTCHA: Mutable Default Arguments in Dataclasses

⚖️ Trade-Offs & Comparison

🌟 My Experience (STAR Anchor)

Why is Composition ('Has-A') generally preferred over Deep Inheritance ('Is-A') in system design?

No Interactive Questions Yet

2. Standard Data Containers: `dataclasses` (PEP 557)

3. Immutability & Value Objects (`frozen=True`)

4. Custom Initialization & Validation (`__post_init__`)