Python Dataclasses – Clean Data Container Classes

Basic Dataclass

Decorate a class with @dataclass and annotate fields. Python generates __init__, __repr__, and __eq__ automatically.

from dataclasses import dataclass

# Without @dataclass (verbose)
class PersonManual:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"Person(name={self.name!r}, age={self.age!r})"

# With @dataclass (clean!)
@dataclass
class Person:
    name: str
    age: int

p = Person("Alice", 30)
print(p)            # Person(name='Alice', age=30)
print(p.name)       # Alice
print(Person("Bob", 25) == Person("Bob", 25))  # True

Default Values and field()

Use field() for mutable defaults (lists, dicts). Never use mutable defaults directly.

from dataclasses import dataclass, field

@dataclass
class Student:
    name: str
    grade: float = 0.0
    courses: list = field(default_factory=list)  # Correct!
    # courses: list = []  ← WRONG — shared across instances!

s1 = Student("Alice")
s2 = Student("Bob")

s1.courses.append("Python")
print(s1.courses)  # ['Python']
print(s2.courses)  # []  — independent list!

__post_init__ – Computed Fields

Run code after __init__ for validation or computed attributes.

from dataclasses import dataclass, field

@dataclass
class Rectangle:
    width: float
    height: float
    area: float = field(init=False)  # Not a constructor param

    def __post_init__(self):
        if self.width <= 0 or self.height <= 0:
            raise ValueError("Dimensions must be positive")
        self.area = self.width * self.height

r = Rectangle(5, 3)
print(r)        # Rectangle(width=5, height=3, area=15)
print(r.area)   # 15

Frozen Dataclasses – Immutable Objects

frozen=True makes all fields read-only and the object hashable (usable as dict key).

from dataclasses import dataclass

@dataclass(frozen=True)
class Point:
    x: float
    y: float

p = Point(3.0, 4.0)
print(p)          # Point(x=3.0, y=4.0)

try:
    p.x = 10     # AttributeError!
except Exception as e:
    print(e)

# Hashable — can be dict key or set member
locations = {p: "Home"}
print(locations[Point(3.0, 4.0)])  # Home

@dataclass: Kill the Boilerplate

A @dataclass auto-generates __init__, __repr__, and __eq__ from your field annotations. It turns a 15-line class into 4 — the pythonic way to write a "just holds data" class.

from dataclasses import dataclass, field

@dataclass
class Point:
    x: int
    y: int = 0                       # default value
    tags: list = field(default_factory=list)   # ⚠️ NOT tags=[]

p = Point(1, 2)
print(p)              # Point(x=1, y=2, tags=[])  ← free __repr__
Point(1, 2) == Point(1, 2)   # True — free __eq__

The mutable-default trap (again): you can't write tags: list = [] — that shares one list across all instances, and dataclasses actually raise an error to stop you. Use field(default_factory=list) to build a fresh one per instance.

Reach for a dataclass over a plain class when the object is mostly fields; over a NamedTuple when you need mutability or methods.

Interview Questions on Dataclasses

• What is a dataclass and what boilerplate does it remove?
• Which dunder methods does @dataclass generate automatically?
• Why must mutable defaults use field(default_factory=...)?
• What is __post_init__ used for?
• What does frozen=True do?
• How do dataclasses compare to named tuples and regular classes?
• What does the order=True parameter add?

Related Topics