Python Dataclasses Explained — Less Boilerplate, More Power

from dataclasses import dataclass, field
from typing import List

# @dataclass reads the annotated class variables below and generates
# __init__, __repr__, and __eq__ automatically at class definition time.
@dataclass
class Product:
    name: str                          # Required field — no default, must be supplied
    price: float                       # Required field
    category: str = "Uncategorized"    # Optional field with a simple default value
    tags: List[str] = field(default_factory=list)  # Mutable default — MUST use field()

# Python calls the generated __init__ under the hood here
laptop = Product(name="ThinkPad X1", price=1299.99, category="Electronics", tags=["work", "portable"])
coffee = Product(name="Arabica Blend", price=14.50)  # category and tags get their defaults

# The generated __repr__ makes this print something actually useful
print(laptop)
print(coffee)

# The generated __eq__ compares field-by-field
identical_laptop = Product(name="ThinkPad X1", price=1299.99, category="Electronics", tags=["work", "portable"])
print(f"Same product? {laptop == identical_laptop}")   # True — field values match
print(f"Different products? {laptop == coffee}")        # False — fields differ

# You can still add your own methods — dataclass doesn't restrict this
def discounted_price(self, percent: float) -> float:
    return self.price * (1 - percent / 100)

Product.discounted_price = discounted_price  # Attaching for demo; normally define inside class
print(f"Laptop at 10% off: ${laptop.discounted_price(10):.2f}")

from dataclasses import dataclass, field
from typing import List

@dataclass
class LineItem:
    product_name: str
    unit_price: float
    quantity: int

    # init=False means this field is NOT part of the constructor signature —
    # callers never pass it. repr=True means it shows up in print() output.
    subtotal: float = field(init=False, repr=True)

    def __post_init__(self):
        # __post_init__ runs right after __init__ completes.
        # All fields (name, unit_price, quantity) are already set when this runs.
        if self.unit_price < 0:
            raise ValueError(f"unit_price cannot be negative, got {self.unit_price}")
        if self.quantity < 1:
            raise ValueError(f"quantity must be at least 1, got {self.quantity}")
        # Compute and store the subtotal — callers never need to calculate this themselves
        self.subtotal = round(self.unit_price * self.quantity, 2)


# frozen=True makes the whole object immutable after construction.
# It also enables __hash__, so Order instances can be used as dict keys or in sets.
@dataclass(frozen=True)
class Order:
    order_id: str
    customer_email: str
    items: tuple  # Use tuple, not list — lists are mutable and incompatible with frozen

    # This computed field summarises the order total
    total: float = field(init=False, repr=True)

    def __post_init__(self):
        if not self.customer_email or "@" not in self.customer_email:
            raise ValueError(f"Invalid customer email: '{self.customer_email}'")
        # With frozen=True, self.field = value raises FrozenInstanceError.
        # object.__setattr__ is the approved workaround inside __post_init__.
        object.__setattr__(self, "total", round(sum(item.subtotal for item in self.items), 2))


# --- Build a realistic order ---
item1 = LineItem(product_name="Mechanical Keyboard", unit_price=89.99, quantity=1)
item2 = LineItem(product_name="USB-C Hub", unit_price=34.50, quantity=2)
print(item1)
print(item2)

order = Order(order_id="ORD-001", customer_email="alex@example.com", items=(item1, item2))
print(order)
print(f"Order total: ${order.total}")

# Confirm immutability
try:
    order.order_id = "ORD-999"   # This should blow up
except Exception as err:
    print(f"Caught expected error: {err}")

# Confirm frozen dataclasses are hashable
processed_orders = {order}  # Can be added to a set
print(f"Order in set: {order in processed_orders}")

# Confirm validation fires
try:
    bad_item = LineItem(product_name="Ghost Product", unit_price=-5.00, quantity=1)
except ValueError as err:
    print(f"Validation caught: {err}")

from dataclasses import dataclass, asdict, astuple
from typing import NamedTuple

# --- Option 1: Plain Class ---
# You write everything yourself. Maximum control, maximum boilerplate.
class PlainPoint:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

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

    def __eq__(self, other):
        if not isinstance(other, PlainPoint):
            return NotImplemented
        return self.x == other.x and self.y == other.y


# --- Option 2: NamedTuple ---
# Immutable, tuple-compatible, fast, but no post-init or mutable defaults.
class NamedPoint(NamedTuple):
    x: float
    y: float


# --- Option 3: Dataclass ---
# Generated boilerplate + full class features + serialization helpers.
@dataclass
class DataPoint:
    x: float
    y: float

    def distance_from_origin(self) -> float:
        return (self.x ** 2 + self.y ** 2) ** 0.5


# -- Demonstrate the differences --

plain = PlainPoint(3.0, 4.0)
named = NamedPoint(3.0, 4.0)
data  = DataPoint(3.0, 4.0)

print("--- Repr ---")
print(plain)  # Our hand-rolled repr
print(named)  # NamedTuple gives this for free
print(data)   # Dataclass gives this for free

print("\n--- Equality ---")
print(PlainPoint(1, 2) == PlainPoint(1, 2))  # True — we wrote __eq__
print(NamedPoint(1, 2) == NamedPoint(1, 2))  # True — tuple equality
print(DataPoint(1, 2) == DataPoint(1, 2))    # True — generated __eq__

print("\n--- Tuple unpacking (NamedTuple only) ---")
x_coord, y_coord = named          # Works because NamedTuple IS a tuple
print(f"Unpacked: x={x_coord}, y={y_coord}")
# x_coord, y_coord = data         # Would raise: cannot unpack dataclass directly

print("\n--- Dataclass serialization helpers ---")
print(asdict(data))    # {'x': 3.0, 'y': 4.0} — perfect for JSON serialization
print(astuple(data))   # (3.0, 4.0)

print("\n--- Custom method on dataclass ---")
print(f"Distance from origin: {data.distance_from_origin():.2f}")

print("\n--- Mutability ---")
data.x = 10.0          # Works fine — dataclasses are mutable by default
print(f"Mutated DataPoint: {data}")
try:
    named = named._replace(x=10.0)  # NamedTuple 'mutation' returns a new instance
    print(f"New NamedPoint: {named}")
except Exception as err:
    print(err)