Что такое класс данных объекта?

Класс данных (dataclass) в Python

Класс данных (dataclass) — это встроенный в Python декоратор из модуля dataclasses (введён в Python 3.7), который автоматически генерирует специальные методы для классов, предназначенных в основном для хранения данных. Он избавляет от необходимости писать стандартный код для инициализации, представления и сравнения объектов.

Проблема, которую решает dataclass

# ❌ Старый способ — много шаблонного кода
class User:
    def __init__(self, id, name, email):
        self.id = id
        self.name = name
        self.email = email
    
    def __repr__(self):
        return f"User(id={self.id}, name={self.name}, email={self.email})"
    
    def __eq__(self, other):
        if not isinstance(other, User):
            return False
        return self.id == other.id and self.name == other.name and self.email == other.email
    
    def __hash__(self):
        return hash((self.id, self.name, self.email))

# ✅ С dataclass — просто и чисто
from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str

Базовое использование

from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str

# Создание экземпляра
user = User(id=1, name="Alice", email="alice@example.com")

# __repr__ генерируется автоматически
print(user)
# User(id=1, name='Alice', email='alice@example.com')

# __eq__ и __ne__ генерируются автоматически
user2 = User(id=1, name="Alice", email="alice@example.com")
print(user == user2)  # True

# Доступ к полям как обычно
print(user.name)  # Alice
user.email = "newemail@example.com"
print(user.email)  # newemail@example.com

Параметры dataclass

from dataclasses import dataclass, field
from typing import List, Optional

# init=True (по умолчанию)
@dataclass(init=True)
class Point:
    x: float
    y: float

point = Point(10, 20)  # __init__ существует

# init=False — свой __init__
@dataclass(init=False)
class CustomInit:
    value: int
    
    def __init__(self, val):
        self.value = val * 2

obj = CustomInit(5)
print(obj.value)  # 10

# repr=True (по умолчанию) — красиво выводит объект
@dataclass(repr=True)
class User:
    name: str
    age: int

print(User("Bob", 30))  # User(name='Bob', age=30)

# eq=True (по умолчанию) — генерирует __eq__ и другие операторы сравнения
@dataclass(eq=True)
class Product:
    id: int
    name: str

a = Product(1, "Apple")
b = Product(1, "Apple")
print(a == b)  # True

# order=True — генерирует <, <=, >, >= (требует eq=True)
@dataclass(order=True)
class Version:
    major: int
    minor: int
    patch: int = 0

v1 = Version(1, 2, 0)
v2 = Version(1, 3, 0)
print(v1 < v2)  # True

# frozen=True — делает объект неизменяемым
@dataclass(frozen=True)
class ImmutableUser:
    id: int
    name: str

user = ImmutableUser(1, "Alice")
# user.name = "Bob"  # FrozenInstanceError

# slots=True — использует __slots__ для экономии памяти (Python 3.10+)
@dataclass(slots=True)
class Memory:
    x: int
    y: int

Значения по умолчанию

from dataclasses import dataclass, field
from datetime import datetime
from typing import List

# Простые значения по умолчанию
@dataclass
class Config:
    host: str = "localhost"
    port: int = 8000
    debug: bool = False

config1 = Config()
print(config1)  # Config(host='localhost', port=8000, debug=False)

config2 = Config(host="example.com")
print(config2)  # Config(host='example.com', port=8000, debug=False)

# field() для сложных значений (списки, словари, функции)
@dataclass
class Team:
    name: str
    members: List[str] = field(default_factory=list)
    created_at: datetime = field(default_factory=datetime.now)

team1 = Team("Developers")
team2 = Team("Testers")

# Списки независимые благодаря default_factory
team1.members.append("Alice")
print(team1.members)  # ['Alice']
print(team2.members)  # [] — не содержит 'Alice'

# ❌ Плохо — все экземпляры делят один список
@dataclass
class BadTeam:
    name: str
    members: List[str] = []

bad1 = BadTeam("A")
bad2 = BadTeam("B")
bad1.members.append("Alice")
print(bad2.members)  # ['Alice'] — нежелательное поведение!

Field параметры

from dataclasses import dataclass, field

@dataclass
class Product:
    # default — значение по умолчанию
    name: str
    price: float = 0.0
    
    # repr=False — не включать в __repr__
    internal_id: int = field(default=0, repr=False)
    
    # compare=False — не включать в сравнение
    description: str = field(default="", compare=False)
    
    # hash=True — включить в хеш (для frozen классов)
    category: str = field(default="general", hash=True)
    
    # init=False — не принимать в __init__, требует default
    created_at: str = field(default="unknown", init=False)
    
    # metadata — дополнительная информация о поле
    quantity: int = field(default=0, metadata={"unit": "pcs"})

product = Product(name="Apple", price=1.5)
print(product)
# Product(name='Apple', price=1.5, category='general')
# internal_id и description не в repr

# Доступ к метаданным
from dataclasses import fields
for f in fields(Product):
    if f.metadata:
        print(f"{f.name}: {f.metadata}")
    # quantity: {'unit': 'pcs'}

Наследование

from dataclasses import dataclass

@dataclass
class Animal:
    name: str
    age: int

@dataclass
class Dog(Animal):
    breed: str = "Mixed"

dog = Dog(name="Buddy", age=3, breed="Golden Retriever")
print(dog)
# Dog(name='Buddy', age=3, breed='Golden Retriever')

# Порядок важен — поля с значениями по умолчанию идут в конце
@dataclass
class Cat(Animal):
    color: str = "Black"

cat = Cat("Whiskers", 2)  # color примет значение по умолчанию
print(cat)  # Cat(name='Whiskers', age=2, color='Black')

Post-init обработка

from dataclasses import dataclass
from datetime import datetime

@dataclass
class User:
    email: str
    password: str
    created_at: datetime = None
    
    def __post_init__(self):
        # __post_init__ вызывается после __init__
        if self.created_at is None:
            self.created_at = datetime.now()
        
        # Валидация
        if "@" not in self.email:
            raise ValueError("Invalid email")
        
        # Трансформация
        self.email = self.email.lower()

user = User("Alice@Example.com", "secret123")
print(user.email)  # alice@example.com
print(user.created_at)  # текущее время

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

Пример 1: API Request/Response

from dataclasses import dataclass
from typing import Optional, List

@dataclass
class Author:
    id: int
    name: str
    email: str

@dataclass
class Post:
    id: int
    title: str
    content: str
    author: Author
    likes: int = 0
    comments: List[str] = field(default_factory=list)

post_data = Post(
    id=1,
    title="Python Tips",
    content="10 tips for Python developers",
    author=Author(1, "Alice", "alice@example.com")
)

print(post_data)

Пример 2: Конвертирование в JSON

from dataclasses import dataclass, asdict
import json

@dataclass
class User:
    id: int
    name: str
    email: str

user = User(1, "Bob", "bob@example.com")

# Конвертирование в словарь
user_dict = asdict(user)
print(user_dict)  # {'id': 1, 'name': 'Bob', 'email': 'bob@example.com'}

# Конвертирование в JSON
json_string = json.dumps(user_dict)
print(json_string)

# Конвертирование из JSON
data = json.loads(json_string)
user2 = User(**data)
print(user2)

Пример 3: Сравнение производительности

# dataclass существенно быстрее и содержит меньше кода

# Старый способ: ~15 строк кода, медленнее
class OldUser:
    def __init__(self, id, name, email):
        self.id = id
        self.name = name
        self.email = email
    def __repr__(self): return f"OldUser(id={self.id}, name={self.name}, email={self.email})"
    def __eq__(self, other): return isinstance(other, OldUser) and self.id == other.id

# dataclass: 3 строки кода, быстрее
@dataclass
class NewUser:
    id: int
    name: str
    email: str

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

1. DTO (Data Transfer Objects) — для передачи данных между слоями
2. Configuration — для объектов конфигурации
3. Simple data holders — для простого хранения данных
4. ORM Models — альтернатива базовым моделям ORM

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

1. Сложная логика — если нужны методы и поведение
2. Высокопроизводительные критичные места — namedtuple может быть быстрее
3. Когда нужна гибкость — обычные классы гибче

dataclass — это мощный инструмент для написания чистого и эффективного Python кода с минимумом шаблонного кода.