Dataclass là gì và __slots__ giúp ích như thế nào?

Question

IT Interview Practice · Accepted Answer

**Dataclass** (`@dataclass`, Python 3.7+) tự động sinh các method boilerplate cho các class chủ yếu giữ dữ liệu. **`__slots__`** là một tối ưu giảm bộ nhớ và tăng tốc truy cập thuộc tính bằng cách tránh `__dict__` cho mỗi instance.

## Dataclass — loại bỏ boilerplate

```python
from dataclasses import dataclass

# ❌ không có dataclass — rất nhiều boilerplate lặp đi lặp lại
class Point:
    def __init__(self, x, y):
        self.x = x; self.y = y
    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"
    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

# ✅ với @dataclass — tất cả ở trên được sinh tự động
@dataclass
class Point:
    x: int
    y: int

p = Point(1, 2)
p                 # Point(x=1, y=2) — __repr__ được sinh
p == Point(1, 2)  # True — __eq__ được sinh
```

`@dataclass` sinh `__init__`, `__repr__`, `__eq__` (và tùy chọn cả ordering/hashing) từ các field được chú thích — loại bỏ boilerplate phiền phức, dễ lỗi.

## Các tính năng của dataclass

```python
from dataclasses import dataclass, field

@dataclass(frozen=True)          # frozen → immutable (hashable, dùng được làm key của dict)
class Config:
    name: str
    tags: list = field(default_factory=list)   # giá trị mặc định mutable làm một cách an toàn
    timeout: int = 30                           # giá trị mặc định
```

`frozen=True` khiến các instance immutable; `field(default_factory=list)` cung cấp giá trị mặc định mutable một cách an toàn (tránh cạm bẫy giá trị-mặc-định-mutable-chia-sẻ).

## __slots__ — tối ưu bộ nhớ và tốc độ

```python
# bình thường, mỗi instance có một __dict__ để lưu thuộc tính (linh hoạt nhưng tốn bộ nhớ)
class Regular:
    def __init__(self, x, y): self.x, self.y = x, y

# __slots__ → tập thuộc tính cố định, KHÔNG có __dict__ mỗi instance
class Slotted:
    __slots__ = ("x", "y")        # chỉ các thuộc tính này được phép
    def __init__(self, x, y): self.x, self.y = x, y

s = Slotted(1, 2)
s.z = 3   # ❌ AttributeError — không thể thêm thuộc tính không có trong __slots__
```

Bình thường mỗi instance lưu các thuộc tính trong một `__dict__` động. `__slots__` khai báo một tập thuộc tính cố định được lưu trong một cấu trúc gọn gàng, cố định thay thế — tiết kiệm bộ nhớ đáng kể và tăng tốc truy cập, với cái giá là tính linh hoạt (không thêm được các thuộc tính tùy ý).

## Kết hợp chúng

```python
@dataclass(slots=True)    # Python 3.10+ — dataclass CÓ __slots__
class Point:
    x: int
    y: int
```

## Khi nào mỗi cái quan trọng

```text
@dataclass → bất kỳ class nào chủ yếu là dữ liệu (DTO, config, bản ghi) — sạch hơn, ít code hơn
__slots__  → khi bạn tạo NHIỀU instance (hàng triệu) và bộ nhớ/tốc độ quan trọng
             (ví dụ các node trong một cấu trúc dữ liệu lớn, các mô phỏng lớn)
```

## Tại sao điều này quan trọng

Dataclass là một tính năng hiện đại được dùng rộng rãi, loại bỏ boilerplate lặp đi lặp lại cho các class giữ dữ liệu — khiến code sạch hơn, ít lỗi hơn và dễ đọc hơn (`__init__`/`__repr__`/`__eq__` được sinh tự động, cộng với tính immutable và giá trị mặc định an toàn).

Chúng là lựa chọn thay thế hiện đại đúng phong cách cho việc tự viết tay các class như vậy hoặc dùng `namedtuple` khi bạn cần tính mutable/method. `__slots__` là một tối ưu hiệu năng có mục tiêu, giảm bộ nhớ đáng kể và tăng tốc truy cập thuộc tính khi bạn khởi tạo số lượng khổng lồ các đối tượng.

Biết cả hai — `@dataclass` cho mô hình hóa dữ liệu sạch hằng ngày và `__slots__` (giờ có thể kết hợp qua `slots=True`) cho các hot path quan trọng về bộ nhớ — phản ánh các thực hành tốt nhất hiện tại để viết các class Python hiệu quả, dễ bảo trì.

Dataclass là gì và slots giúp ích như thế nào?

Dataclass — loại bỏ boilerplate

Các tính năng của dataclass

slots — tối ưu bộ nhớ và tốc độ

Kết hợp chúng

Khi nào mỗi cái quan trọng

Tại sao điều này quan trọng

Câu hỏi liên quan