Dataclasses and properties: Python Programming (Expert)

The boring part of classes

Many classes just hold data: a student, a product, a train ticket. For each one you write __init__ that copies every argument to self, a __repr__ for printing, and an __eq__ for comparing. That is a lot of repeated typing. The dataclasses module writes it for you.

Think of it like this: A dataclass is like a printed bill book at a shop. The columns (item, quantity, price) are already printed; the shopkeeper only fills in the values. You only list the fields; Python prints the rest of the form for you.

python

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: int
    qty: int = 1          # a default value

p = Product("Rice 5kg", 320, 2)
print(p)                               # Product(name='Rice 5kg', price=320, qty=2)
print(p == Product("Rice 5kg", 320, 2))  # True
print(Product("Salt", 25))             # qty defaults to 1

Fields are written as name: type. You get __init__, __repr__ and __eq__ for free.

@dataclass is a decorator: a line starting with @ placed above a class or function that adds extra behaviour to it. The types after the colons (str, int) are type hints. Python does not check them at run time, but they document your intent and help your editor find mistakes.

Careful: Fields with defaults must come after fields without defaults. Writing qty: int = 1 before price: int raises TypeError: non-default argument follows default argument.

Lists as defaults: field(default_factory=list)

python

from dataclasses import dataclass, field

@dataclass
class Cart:
    owner: str
    items: list = field(default_factory=list)   # a NEW list for every cart

    def add(self, item):
        self.items.append(item)

a = Cart("Asha")
b = Cart("Ravi")
a.add("Milk")
print(a.items, b.items)   # ['Milk'] []

default_factory is a function called to make a fresh default for each object.

Why not items: list = []? A default value is created once and would be shared by every object, the same trap you saw with class attributes. Dataclasses protect you: writing = [] raises ValueError and tells you to use default_factory.

frozen=True and order=True

python

from dataclasses import dataclass

@dataclass(frozen=True)
class Station:
    code: str
    name: str

ndls = Station("NDLS", "New Delhi")
try:
    ndls.code = "BCT"
except Exception as e:
    print(type(e).__name__)      # FrozenInstanceError
print({ndls})                    # frozen dataclasses can go in a set

@dataclass(order=True)
class Rank:
    score: int
    name: str

print(sorted([Rank(88, "Om"), Rank(95, "Ira"), Rank(88, "Ali")]))

order=True compares fields in order: score first, then name.

Option	What it does	Use it when
frozen=True	Fields cannot be changed after creation; objects become hashable	Values that should never change: a station code, a date range
order=True	Adds <, <=, >, >= comparing fields like a tuple	You want to sort objects by their fields
field(default_factory=list)	A fresh list (or dict) for each object	A field that starts empty and grows

@property: computed values and validation

A property looks like an attribute but runs a method. Use it for a value that is calculated from other fields, so it is never out of date. A property can also have a setter, which runs when you assign to it, so you can check the new value before storing it.

python

from dataclasses import dataclass

@dataclass
class CartItem:
    name: str
    price: int
    qty: int

    @property
    def total(self):           # computed every time, never stale
        return self.price * self.qty

item = CartItem("Atta 10kg", 450, 2)
print(item.total)   # 900 (no brackets)
item.qty = 3
print(item.total)   # 1350

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price     # goes through the setter below

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("Price cannot be negative")
        self._price = value

p = Product("Soap", 40)
try:
    p.price = -5
except ValueError as e:
    print(e)

The real value lives in self._price; the underscore means "internal, do not touch".

Tip: In a dataclass, you can check values in a method named __post_init__(self). The generated __init__ calls it right after setting the fields, so it is a good place to raise ValueError for bad data.

When to use a dataclass

Use a dataclass when the class is mainly a bundle of named values, with maybe a few small methods.
Use a normal class when the object is mostly behaviour with careful rules, like a bank account.
Use a plain dictionary for quick, one-off data, such as a row you just read from a CSV file.

Dataclasses and properties

Explanation

The boring part of classes

Lists as defaults: field(default_factory=list)

frozen=True and order=True

@property: computed values and validation

When to use a dataclass

Watch the lesson

In real life: Train tickets in a booking app

Practice (0/3 done)

Quick quiz

Read more (free)