В чем разница между @dataclass и обычным классом в Python?

# В чем разница между @dataclass и обычным классом в Python?

Быстрый ответ

@dataclass — это decorator, который автоматически генерирует специальные методы (__init__, __repr__, __eq__ и др.) на основе type hints. Это избавляет от написания boilerplate кода.

Сравнение

Обычный класс (долго писать)

class Person:
    def __init__(self, name: str, age: int, email: str):
        self.name = name
        self.age = age
        self.email = email
    
    def __repr__(self) -> str:
        return f"Person(name={self.name!r}, age={self.age!r}, email={self.email!r})"
    
    def __eq__(self, other) -> bool:
        if not isinstance(other, Person):
            return NotImplemented
        return (self.name, self.age, self.email) == (other.name, other.age, other.email)
    
    def __hash__(self) -> int:
        return hash((self.name, self.age, self.email))
    
    def __lt__(self, other) -> bool:
        if not isinstance(other, Person):
            return NotImplemented
        return (self.name, self.age) < (other.name, other.age)

# Использование
person = Person("Alice", 30, "alice@example.com")
print(person)  # Person(name='Alice', age=30, email='alice@example.com')
print(person == Person("Alice", 30, "alice@example.com"))  # True

То же самое с @dataclass (коротко)

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int
    email: str

# Всё то же самое, но на 50% меньше кода!
person = Person("Alice", 30, "alice@example.com")
print(person)  # Person(name='Alice', age=30, email='alice@example.com')
print(person == Person("Alice", 30, "alice@example.com"))  # True

Что генерирует @dataclass

1. init (инициализатор)

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int
    email: str = "no-email"  # Значение по умолчанию

# Это генерирует:
# def __init__(self, name: str, age: int, email: str = "no-email"):
#     self.name = name
#     self.age = age
#     self.email = email

person1 = Person("Alice", 30)  # email будет "no-email"
person2 = Person("Bob", 25, "bob@example.com")

2. repr (строковое представление)

@dataclass
class Product:
    name: str
    price: float
    quantity: int = 0

product = Product("Laptop", 999.99, 5)
print(product)  # Product(name='Laptop', price=999.99, quantity=5)
print(repr(product))  # Product(name='Laptop', price=999.99, quantity=5)

3. eq (сравнение равенства)

@dataclass
class Point:
    x: float
    y: float

p1 = Point(10.0, 20.0)
p2 = Point(10.0, 20.0)
p3 = Point(20.0, 30.0)

print(p1 == p2)  # True (значения одинаковые)
print(p1 == p3)  # False (значения разные)
print(p1 is p2)  # False (разные объекты)

4. Сравнение порядка (опционально)

from dataclasses import dataclass

@dataclass(order=True)  # Генерирует __lt__, __le__, __gt__, __ge__
class Student:
    name: str
    gpa: float

s1 = Student("Alice", 3.9)
s2 = Student("Bob", 3.5)

print(s1 > s2)  # True (3.9 > 3.5)
print(s1 < s2)  # False

# Сортировка
students = [s2, s1, Student("Charlie", 3.7)]
print(sorted(students))  # Сортирует по gpa

5. hash (опционально)

from dataclasses import dataclass

@dataclass(frozen=True)  # frozen=True делает класс неизменяемым и hashable
class Config:
    host: str
    port: int

config1 = Config("localhost", 8000)
config2 = Config("localhost", 8000)

# Можем использовать как ключи в словаре
configs = {config1: "prod", config2: "dev"}  # config1 и config2 — один ключ

# Можем добавить в множество
config_set = {config1, config2}  # Будет один элемент (они равны)
print(len(config_set))  # 1

Параметры @dataclass

1. init=True (по умолчанию)

@dataclass(init=True)  # Генерирует __init__
class Person:
    name: str
    age: int

man = Person("John", 30)  # Работает

# С init=False
@dataclass(init=False)
class Robot:
    name: str
    power: int

robot = Robot()  # TypeError: missing required positional arguments

# Нужно определить свой __init__
@dataclass(init=False)
class CustomRobot:
    name: str
    power: int
    
    def __init__(self, name: str):
        self.name = name
        self.power = 100

robot = CustomRobot("T-800")  # Работает

2. repr=True (по умолчанию)

@dataclass(repr=True)  # Генерирует __repr__
class Book:
    title: str
    author: str

book = Book("1984", "Orwell")
print(book)  # Book(title='1984', author='Orwell')

# С repr=False
@dataclass(repr=False)
class Secret:
    password: str

secret = Secret("mypassword")
print(secret)  # <__main__.Secret object at 0x...> (как обычный класс)

3. eq=True (по умолчанию)

@dataclass(eq=True)  # Генерирует __eq__
class Item:
    name: str
    value: int

i1 = Item("sword", 100)
i2 = Item("sword", 100)
print(i1 == i2)  # True

# С eq=False
@dataclass(eq=False)
class Unique:
    value: str

u1 = Unique("same")
u2 = Unique("same")
print(u1 == u2)  # False (сравнивает по id)

4. order=False (по умолчанию)

@dataclass(order=True)  # Генерирует __lt__, __le__, __gt__, __ge__
class Rank:
    name: str
    score: int

r1 = Rank("Alice", 100)
r2 = Rank("Bob", 50)
print(r1 > r2)  # True
print(sorted([r2, r1]))  # Сортирует по score

# С order=False (по умолчанию)
@dataclass
class NoOrder:
    value: int

n1 = NoOrder(10)
n2 = NoOrder(5)
print(n1 > n2)  # TypeError: '>' not supported between NoOrder and NoOrder

5. frozen=False (по умолчанию)

@dataclass  # По умолчанию можно менять
class Config:
    host: str
    port: int

config = Config("localhost", 8000)
config.port = 9000  # Можем менять

# frozen=True: неизменяемый класс
@dataclass(frozen=True)
class ImmutableConfig:
    host: str
    port: int

config = ImmutableConfig("localhost", 8000)
config.port = 9000  # FrozenInstanceError

# Frozen классы автоматически hashable
configs = {config}  # Работает

Практические примеры

API Response моделирование

from dataclasses import dataclass
from typing import Optional
from datetime import datetime

@dataclass
class User:
    id: int
    name: str
    email: str
    is_active: bool = True
    created_at: Optional[datetime] = None

# Из JSON API
json_data = {"id": 1, "name": "John", "email": "john@example.com"}
user = User(**json_data)  # Легко создавать из JSON
print(user)  # User(id=1, name='John', email='john@example.com', is_active=True, created_at=None)

Конфигурация приложения

from dataclasses import dataclass, field
from typing import List

@dataclass
class DatabaseConfig:
    host: str
    port: int
    username: str
    password: str
    database: str
    pool_size: int = 10
    timeout: int = 30

@dataclass
class AppConfig:
    debug: bool
    database: DatabaseConfig
    allowed_hosts: List[str] = field(default_factory=list)
    secret_key: str = "change-me"

# Использование
db_config = DatabaseConfig("localhost", 5432, "user", "pass", "mydb")
app_config = AppConfig(debug=True, database=db_config)
print(app_config)

Валидация с постинициализацией

from dataclasses import dataclass, field

@dataclass
class BankAccount:
    owner: str
    balance: float
    
    def __post_init__(self):  # Вызывается ПОСЛЕ __init__
        if self.balance < 0:
            raise ValueError("Balance cannot be negative")
        if not self.owner:
            raise ValueError("Owner name required")

account = BankAccount("Alice", 1000)  # OK
account = BankAccount("Bob", -100)  # ValueError

Обычный класс vs @dataclass: сравнение

# ОБЫЧНЫЙ КЛАСС (много кода)
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __repr__(self):
        return f"Point({self.x}, {self.y})"
    
    def __eq__(self, other):
        return isinstance(other, Point) and self.x == other.x and self.y == other.y
    
    def __hash__(self):
        return hash((self.x, self.y))
    
    def __lt__(self, other):
        return (self.x, self.y) < (other.x, other.y)

# DATACLASS (читаемо и коротко)
from dataclasses import dataclass

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

# Одинаковая функциональность, но dataclass — половина кода!

Когда использовать dataclass

✅ Используй @dataclass:

• Простые data-holding классы
• DTO (Data Transfer Objects)
• API models
• Конфиги
• Когда нужны встроенные методы (init, repr, eq)

❌ Не используй @dataclass:

• Сложная логика в методах
• Наследование (работает, но может быть странно)
• Когда нужна полная кастомизация
• Очень старый Python (< 3.7)

Вывод

@dataclass — это синтаксический сахар для создания классов-контейнеров данных.

Основные преимущества:

1. Меньше boilerplate кода
2. Автоматические методы (init, repr, eq)
3. Поддержка type hints
4. Читаемый и понятный код
5. Легко расширяется параметрами (frozen, order, eq и т.д.)

Разница в одном слове:

• Обычный класс = максимальный контроль, много кода
• @dataclass = минимум кода, достаточно для большинства случаев