Sự khác biệt giữa đối tượng mutable và immutable là gì?

Question

Accepted Answer

Một đối tượng **immutable** không thể thay đổi sau khi tạo; một đối tượng **mutable** thì có thể. Sự phân biệt này là trung tâm của Python và ảnh hưởng đến aliasing, key của dict, đối số hàm, và cả một lớp lỗi tinh vi.

## Hai nhóm

```text
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable:   list, dict, set, bytearray, và hầu hết các đối tượng tùy chỉnh
```

## Immutable: "thay đổi" tạo ra một đối tượng mới

```python
x = "hello"
x.upper()       # trả về một chuỗi MỚI "HELLO" — x không thay đổi
x += " world"   # gán lại x cho một chuỗi MỚI; "hello" gốc không bị đụng tới

n = 5
n += 1          # tạo một int mới 6; không sửa đổi đối tượng int 5
```

Với immutable, các thao tác có vẻ "thay đổi" giá trị thực ra tạo ra một đối tượng mới và gán lại biến. Đối tượng gốc không bao giờ bị thay đổi.

## Mutable: sửa đổi tại chỗ

```python
lst = [1, 2, 3]
lst.append(4)   # sửa đổi CÙNG đối tượng list → [1, 2, 3, 4]
lst[0] = 99     # thay đổi tại chỗ
```

## Cạm bẫy aliasing (mối nguy thực tế)

```python
# mutable — hai tên trỏ tới CÙNG một đối tượng
a = [1, 2, 3]
b = a            # b KHÔNG phải bản sao — nó là cùng một list
b.append(4)
print(a)         # [1, 2, 3, 4] ← a cũng thay đổi! (chúng là alias)

# để thực sự sao chép:
b = a.copy()     # hoặc list(a), hoặc a[:]
```

Gán một đối tượng mutable không sao chép nó — cả hai tên tham chiếu tới cùng một đối tượng, nên thay đổi qua một tên sẽ ảnh hưởng tên kia. Điều này khiến nhiều người bất ngờ và gây ra lỗi thực sự.

## Tại sao immutable có thể làm key của dict / phần tử của set

```python
d = {(1, 2): "point"}   # ✅ key tuple — immutable, hashable
d = {[1, 2]: "x"}       # ❌ TypeError — list không hashable (mutable)
```

Key của dict và phần tử của set phải **hashable**, điều này đòi hỏi tính immutable (một key mutable có thể thay đổi và làm hỏng bảng băm).

## Đối số hàm

```python
def modify(lst): lst.append(99)   # thay đổi list của bên gọi (truyền theo tham chiếu)
def rebind(n): n += 1             # gán lại cục bộ; int của bên gọi không thay đổi
```

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

Tính mutable là một khái niệm Python nền tảng giải thích một loạt hành vi và lỗi: cạm bẫy aliasing (gán không sao chép đối tượng mutable), tại sao hàm có thể sửa đổi một list được truyền vào nhưng không sửa được một int, tại sao chỉ đối tượng immutable mới có thể làm key của dict/phần tử của set, và cạm bẫy đối số mặc định mutable.

Hiểu kiểu nào mutable so với immutable — và rằng việc thay đổi một đối tượng được chia sẻ ảnh hưởng đến mọi tham chiếu tới nó — là điều thiết yếu để viết Python đúng và tránh một số bất ngờ phổ biến nhất của nó.