Types and Data

Classes and dataclasses

Define a class with class. The __init__ method initializes new instances, and every method receives the instance itself as its first parameter, conventionally named self.

class Account:
    def __init__(self, owner: str, balance: int = 0) -> None:
        self.owner = owner
        self.balance = balance

    def deposit(self, amount: int) -> None:
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount

    def __repr__(self) -> str:
        return f"Account({self.owner!r}, {self.balance})"


acc = Account("mina")
acc.deposit(100)
print(acc)   # Account('mina', 100)

When a class mostly exists to hold data, the standard dataclasses module removes the boilerplate. List the fields with type hints and you get __init__, __repr__ and __eq__ generated for you. Pass frozen=True to make instances immutable.

from dataclasses import dataclass, field


@dataclass
class Order:
    id: int
    customer: str
    items: list[str] = field(default_factory=list)
    paid: bool = False


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


order = Order(1, "mina")
order.items.append("book")
print(order)                       # Order(id=1, customer='mina', items=['book'], paid=False)
Point(1, 2) == Point(1, 2)         # True

Type hints

Python is dynamically typed, but you can annotate variables, parameters and return values. The interpreter does not enforce these hints at runtime; instead editors use them for completion, and static checkers such as mypy and Pyright use them to catch mistakes before the code ever runs. The payoff grows with the size of the codebase.

from typing import Optional


def find_user(users: dict[str, int], name: str) -> int | None:
    return users.get(name)


def average(values: list[float]) -> float:
    return sum(values) / len(values) if values else 0.0


scores: list[int] = [90, 85]
lookup: dict[str, tuple[int, int]] = {"origin": (0, 0)}
maybe: Optional[str] = None   # same as str | None

python -m pip install mypy
mypy app.py

Summary

• The core types are int, float, str, bool and None; test for None with is.
• Pick list for changing sequences, tuple for fixed groups, dict for lookups and set for uniqueness.
• Use classes for objects with behavior and @dataclass for plain data containers.
• Type hints do not change runtime behavior, but editors and checkers turn them into early bug detection.