В чем разница между dataclass и namedtuple?

dataclass vs namedtuple: полное сравнение

Оба используются для создания простых структур данных с именованными полями, но они очень разные.

1. namedtuple — неизменяемый кортеж с именами

Что это:

• Подкласс tuple
• Неизменяемый (immutable)
• Легкий и быстрый
• Хешируемый (можно использовать как ключ dict)

from collections import namedtuple

# Создание
Point = namedtuple('Point', ['x', 'y'])
point = Point(10, 20)

# Доступ к полям
print(point.x)  # 10
print(point.y)  # 20
print(point[0])  # 10 (как обычный tuple)
print(point)   # Point(x=10, y=20)

# Неизменяемость
point.x = 30  # AttributeError: can't set attribute

Альтернативные синтаксисы:

# Способ 1: список строк
Person = namedtuple('Person', ['name', 'age'])

# Способ 2: одна строка с пробелами
Person = namedtuple('Person', 'name age')

# Способ 3: одна строка с запятыми
Person = namedtuple('Person', 'name, age')

# Способ 4: ключевое слово rename для недопустимых имён
Person = namedtuple('Person', 'name age class', rename=True)
# 'class' переименуется в '_2' (недопустимое имя для переменной)

2. dataclass — изменяемая структура данных

Что это:

• Обычный класс с автогенерируемыми методами
• Изменяемый (mutable) по умолчанию
• Более гибкий и мощный
• НЕ хешируемый (по умолчанию)

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

point = Point(10, 20)

# Доступ к полям
print(point.x)  # 10
print(point.y)  # 20
print(point)   # Point(x=10, y=20)

# Изменяемость
point.x = 30  # ✓ Работает
print(point.x)  # 30

# Хеширование
try:
    my_dict = {point: "value"}
except TypeError as e:
    print(e)  # unhashable type: 'Point'

3. Основные различия

4. namedtuple — примеры использования

from collections import namedtuple

# Простая структура
User = namedtuple('User', ['id', 'name', 'email'])
user = User(1, 'Alice', 'alice@example.com')

# Распаковка
user_id, name, email = user
print(name)  # Alice

# Итерация
for field_value in user:
    print(field_value)

# Методы namedtuple
print(user._fields)      # ('id', 'name', 'email')
print(user._asdict())    # {'id': 1, 'name': 'Alice', 'email': 'alice@example.com'}

# Замена поля (создаёт новый namedtuple)
new_user = user._replace(name='Bob')
print(new_user)  # User(id=1, name='Bob', email='alice@example.com')
print(user)      # User(id=1, name='Alice', email='alice@example.com') (исходный не изменился)

# Хеширование
users_set = {user, User(2, 'Bob', 'bob@example.com')}
print(len(users_set))  # 2

Добавление методов к namedtuple:

from collections import namedtuple

class Person(namedtuple('Person', ['name', 'age'])):
    def greeting(self):
        return f"Привет, я {self.name}"
    
    @property
    def is_adult(self):
        return self.age >= 18

person = Person('Alice', 30)
print(person.greeting())  # Привет, я Alice
print(person.is_adult)    # True
print(person.age)         # 30 (immutable)
person.age = 31           # AttributeError

5. dataclass — примеры использования

from dataclasses import dataclass, field
from typing import List

# Базовый dataclass
@dataclass
class User:
    id: int
    name: str
    email: str

user = User(1, 'Alice', 'alice@example.com')
print(user)  # User(id=1, name='Alice', email='alice@example.com')

# Значения по умолчанию
@dataclass
class Product:
    name: str
    price: float
    currency: str = "USD"  # Значение по умолчанию
    quantity: int = 1

product = Product("Laptop", 999.99)
print(product)  # Product(name='Laptop', price=999.99, currency='USD', quantity=1)

# field() для сложных значений
@dataclass
class Team:
    name: str
    members: List[str] = field(default_factory=list)  # Новый список для каждого объекта

team1 = Team("Team A")
team1.members.append("Alice")

team2 = Team("Team B")
print(team2.members)  # [] — свой список, не разделяется

6. frozen dataclass — неизменяемый dataclass

from dataclasses import dataclass

@dataclass(frozen=True)
class ImmutablePoint:
    x: int
    y: int

point = ImmutablePoint(10, 20)

# Теперь неизменяемый как namedtuple
point.x = 30  # FrozenInstanceError

# И хешируемый!
points_set = {point, ImmutablePoint(5, 5)}
print(len(points_set))  # 2 ✓

7. Производительность

import timeit
from collections import namedtuple
from dataclasses import dataclass

# namedtuple
Point_NT = namedtuple('Point', ['x', 'y'])
nt_time = timeit.timeit(lambda: Point_NT(10, 20), number=100000)

# dataclass
@dataclass
class Point_DC:
    x: int
    y: int

dc_time = timeit.timeit(lambda: Point_DC(10, 20), number=100000)

print(f"namedtuple: {nt_time:.4f}s")
print(f"dataclass: {dc_time:.4f}s")
# namedtuple быстрее примерно в 2 раза

# Размер памяти
import sys
nt = Point_NT(10, 20)
dc = Point_DC(10, 20)

print(f"namedtuple size: {sys.getsizeof(nt)} bytes")
print(f"dataclass size: {sys.getsizeof(dc)} bytes")
# namedtuple занимает меньше

8. Когда использовать что

Используй namedtuple:

• Простые неизменяемые структуры
• Когда нужна максимальная производительность
• Когда нужна хешируемость
• Когда структура никогда не будет меняться
• Для возвращения нескольких значений из функции

from collections import namedtuple

Result = namedtuple('Result', ['success', 'data', 'error'])

def fetch_data(url):
    try:
        # ...
        return Result(True, data, None)
    except Exception as e:
        return Result(False, None, str(e))

result = fetch_data("https://api.example.com")
if result.success:
    print(result.data)
else:
    print(result.error)

Используй dataclass:

• Сложные структуры с методами
• Когда нужна изменяемость
• Когда нужны type hints
• Когда структура может быть расширена
• Для работы с сериализацией (JSON, DB)

from dataclasses import dataclass, asdict
import json

@dataclass
class User:
    id: int
    name: str
    email: str
    tags: list = None
    
    def add_tag(self, tag):
        if self.tags is None:
            self.tags = []
        self.tags.append(tag)
    
    def to_json(self):
        return json.dumps(asdict(self))

user = User(1, 'Alice', 'alice@example.com')
user.add_tag('admin')
print(user.to_json())

9. Гибридный подход: namedtuple + методы

from collections import namedtuple

_Point = namedtuple('Point', ['x', 'y'])

class Point(_Point):
    def distance_from_origin(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5
    
    def move(self, dx, dy):
        # Возвращаем новый Point (immutability)
        return Point(self.x + dx, self.y + dy)

point = Point(3, 4)
print(point.distance_from_origin())  # 5.0
print(point.move(1, 1))              # Point(x=4, y=5)
print(point)                         # Point(x=3, y=4) (исходный не изменился)

10. Сравнение на практике

from collections import namedtuple
from dataclasses import dataclass

# namedtuple версия
UserNT = namedtuple('User', ['id', 'name', 'age'])

# dataclass версия
@dataclass
class UserDC:
    id: int
    name: str
    age: int

# Создание
user_nt = UserNT(1, 'Alice', 30)
user_dc = UserDC(1, 'Alice', 30)

print(user_nt == user_dc)  # False (разные типы)
print(user_nt[0] == user_dc.id)  # True

# Изменение
user_nt = user_nt._replace(age=31)  # Новый объект
user_dc.age = 31  # Изменение на месте

# Хеширование
users_set = {user_nt}  # ✓ Работает
try:
    users_set = {user_dc}  # ✗ TypeError
except TypeError:
    pass

# В словаре
users_dict = {user_nt: "data"}  # ✓ namedtuple ключ
users_dict = {}  # dataclass не подходит как ключ

Итоги

• namedtuple — неизменяемый, быстрый, хешируемый (tuple с именами)
• dataclass — изменяемый, гибкий, с type hints (обычный класс)
• frozen=True в dataclass делает его похожим на namedtuple
• Выбирай namedtuple для простых неизменяемых структур
• Выбирай dataclass для сложных структур с методами и типизацией
• Комбинируй подходы — наследуй namedtuple для методов