Kiểu bất biến trong Python (immutable): tuple, frozen
Bài 11/17 · Chương 15
OOP nâng cao
- 8 phút
- Trung cấp
- Python 3.14
- Cập nhật
Trong bài này · 13
Kiểu bất biến trong Python (immutable) là kiểu mà giá trị tạo xong không sửa tại chỗ được, như số, chuỗi, tuple, frozenset; kiểu khả biến (mutable) như list, dict, set thì sửa được. Phân biệt hai loại giúp bạn biết khi nào một đơn hàng đã chốt có thể bị đổi sau lưng, và giá trị nào dùng được làm khóa của dict.
Cần biết trước: sao chép list, tuple và frozenset.
Khả biến và bất biến khác nhau ở đâu
Hai tên cùng chỉ một giá trị, rồi bạn "sửa" qua một tên. Điều xảy ra với tên kia phụ thuộc vào kiểu của giá trị:
ten = "trà đào"
ten_cu = ten
ten += " size L"
print(ten_cu, "|", ten, "|", ten is ten_cu)
gio = ["trà đào"]
gio_cu = gio
gio += ["bạc xỉu"]
print(gio_cu, "|", gio is gio_cu)KẾT QUẢ
trà đào | trà đào size L | False
['trà đào', 'bạc xỉu'] | TrueChuỗi bất biến nên ten += " size L" tạo một chuỗi mới và gắn tên ten vào đó, còn ten_cu vẫn chỉ chuỗi cũ. List khả biến nên += thêm phần tử vào chính list đang có, và gio_cu thấy ngay. Phép is từ bài is và == cho thấy điều đó: sau khi sửa, ten là object khác, gio vẫn là object cũ. Hình dung chuỗi như tờ hóa đơn đã in: muốn đổi thì in tờ mới. List thì như tờ ghi món còn để trống, ai cầm nó cũng viết thêm được.
Đổi gio += ["bạc xỉu"] thành gio = gio + ["bạc xỉu"] rồi chạy lại: dòng thứ hai in ['trà đào'] | False, vì phép + luôn tạo list mới.
Bảng các kiểu bất biến và khả biến
Bất biến | Khả biến |
|---|---|
|
|
|
|
|
|
| object của class thường |
object của dataclass có | object của dataclass thường |
Khác biệt này lộ rõ khi bạn truyền giá trị vào hàm. Hàm nhận chính object của nơi gọi, nên sửa tại chỗ thì nơi gọi thấy, còn gán lại tham số thì không:
def them_phi(tong, gio):
tong += 30000
gio.append("phí giao")
tong = 250000
gio = ["trà đào", "bạc xỉu"]
them_phi(tong, gio)
print(tong)
print(gio)KẾT QUẢ
250000
['trà đào', 'bạc xỉu', 'phí giao']tong += 30000 trên một số chỉ gắn tham số tong vào số mới bên trong hàm, nên biến tong bên ngoài giữ 250000. gio.append() sửa chính list của nơi gọi. Vì vậy hàm nhận list, dict hay set mà không định sửa chúng thì phải làm việc trên bản sao hoặc trả về giá trị mới.
Tuple chứa list: bất biến nông
Tuple không cho gán, thêm hay xóa phần tử. Nhưng "phần tử" của tuple là các object nó chỉ tới, và một object trong đó có thể là list:
don = ("DH1024", ["trà đào", "bạc xỉu"])
don[1].append("sinh tố bơ")
print(don)
print(len(don), len(don[1]))KẾT QUẢ
('DH1024', ['trà đào', 'bạc xỉu', 'sinh tố bơ'])
2 3Tuple vẫn có đúng hai phần tử, và phần tử thứ hai vẫn là list cũ: tuple không đổi. List bên trong thì đổi, vì list khả biến. Kiểu này gọi là bất biến nông: chỉ lớp ngoài cùng bị khóa, giống bản sao nông ở bài sao chép list chỉ chép lớp ngoài. Gán don[1] = [] vẫn báo lỗi, còn don[1].append() thì không.
Hashable: giá trị làm được khóa dict
Một giá trị là hashable khi Python tính được cho nó một mã cố định suốt đời object, nhờ đó dict và set tìm ra nó nhanh; cơ chế này thuộc bài bảng băm. Với các kiểu dựng sẵn, giá trị bất biến là hashable khi mọi thứ bên trong cũng hashable, còn list, dict, set thì không. Tọa độ viết bằng tuple vì thế làm được khóa:
nhiet_do = {}
nhiet_do[(0, 0)] = 31.5
nhiet_do[(3, 4)] = 29.0
nhiet_do[frozenset({"Kho A", "Kho B"})] = 30.2
print(nhiet_do[(3, 4)])
print(nhiet_do[frozenset({"Kho B", "Kho A"})])KẾT QUẢ
29.0
30.2Khóa của dict phải hashable, như bài dictionary đã nói, và tuple (3, 4) là bất biến từ trong ra ngoài. Nếu một khóa đổi được sau khi đã vào dict, mã của nó sẽ đổi theo và dict không tìm lại được nó, nên Python từ chối list ngay từ đầu.
Class bất biến bằng frozen dataclass
Object của class thường sửa được thuộc tính. Muốn một object tạo xong là cố định, như một điểm trên bản đồ nhiệt, bạn viết @dataclass(frozen=True). Gán goc.x = 5 khi đó dừng với FrozenInstanceError, nên muốn "đổi" thì tạo object mới:
from dataclasses import dataclass
@dataclass(frozen=True)
class Diem:
x: int
y: int
goc = Diem(0, 0)
nhiet_do = {goc: 31.5, Diem(3, 4): 29.0}
print(nhiet_do[Diem(3, 4)])
doi = Diem(goc.x + 1, goc.y)
print(goc, doi)KẾT QUẢ
29.0
Diem(x=0, y=0) Diem(x=1, y=0)Object của dataclass frozen là hashable, và hai điểm bằng nhau tìm ra cùng một khóa. namedtuple cũng bất biến và làm khóa được vì nó là một tuple. Frozen vẫn chỉ là bất biến nông: một trường kiểu list vẫn sửa được bên trong, và object đó lại không làm khóa được.
Kiểm tra nhanh
Sau dòng
gia = 29000,gia_cu = giavàgia += 3000, lệnhprint(gia_cu, gia is gia_cu)in ra gì?29000 False32000 True32000 False
Những giá trị nào làm được khóa dict?
(3, 4)frozenset({"Kho A", "Kho B"})("trà đào", ["thêm đào"])["DH1024"]
Sau dòng
mon = ["trà đào"],don = ("DH1024", mon)vàmon.append("bạc xỉu"), lệnhprint(len(don[1]))in ra gì?- 1
- 2
- Báo lỗi TypeError
Class
Diemviết bằng@dataclasskhông cófrozen=True. Dòngnhiet_do = {Diem(0, 0): 31.5}cho kết quả gì?- Tạo dict có một cặp khóa và giá trị
- Báo lỗi FrozenInstanceError
- Báo lỗi TypeError, vì object không hashable
Bài tập
Chốt đơn hàng thành giá trị bất biến
Viết hàm chot_don(don). don là dict có ba khóa: "ma" (chuỗi mã đơn), "mon" (list tên món theo thứ tự gọi, có thể trùng) và "ghi_chu" (set các ghi chú). Hàm trả về đơn đã chốt, tuple (ma, cac_mon, cac_ghi_chu), bất biến từ trong ra ngoài:
cac_mon: tuple các món, giữ thứ tự và món trùng.cac_ghi_chu: frozenset các ghi chú.
Đơn đã chốt phải dùng được làm khóa dict, và không đổi khi list món hay set ghi chú gốc bị sửa sau đó. Hàm không sửa don.
Trả về: đơn đã chốt, một tuple.
def chot_don(don):
pass # Viết thân hàm thay cho dòng nàyTóm tắt
Bất biến:
int,float,bool,None,str,tuple,frozenset, dataclass frozen; khả biến:list,dict,set, object thường.+=trên số hay chuỗi tạo giá trị mới; trên list thì sửa chính list, mọi tên chỉ tới nó đều thấy.Tuple chỉ bất biến nông: list nằm trong tuple vẫn sửa được.
Khóa dict và phần tử set phải hashable: kiểu dựng sẵn bất biến từ trong ra ngoài.
Tuple chứa list và object của dataclass thường không làm khóa được; thêm
frozen=Truecho dataclass.Muốn chốt dữ liệu thì đổi list sang
tuple(), set sangfrozenset().
Câu hỏi thường gặp
Nên dùng frozen dataclass hay namedtuple cho dữ liệu bất biến?
Cả hai đều bất biến và làm khóa dict được. namedtuple là một tuple, nên còn đọc được theo chỉ số (sp[1]) và unpacking được, như bài namedtuple cho thấy. Frozen dataclass là class riêng, không đọc theo chỉ số được, nhưng có thêm field(default_factory=) và __post_init__ của dataclass.
Chọn mutable hay immutable trong Python cho dữ liệu của mình?
Chọn theo việc dữ liệu có cần đổi sau khi tạo hay không. Giỏ hàng đang thêm món thì dùng list. Đơn đã chốt, tọa độ, mã combo thì dùng tuple, frozenset hay dataclass frozen: chúng dùng chung an toàn giữa nhiều chỗ trong code và làm được khóa dict.
Làm sao biết một giá trị có làm khóa dict được không?
Nhìn từ ngoài vào trong: nếu bản thân nó và mọi thứ nó chứa đều thuộc cột bất biến của bảng trên, nó làm khóa được. Có một list, dict hay set ở bất kỳ tầng nào thì không. Object của class thường là ngoại lệ: dù khả biến, nó vẫn làm khóa được theo danh tính, trừ khi class viết __eq__ (bài dunder methods). Bài frozenset cho ví dụ dùng frozenset làm khóa khi thứ tự không quan trọng.
Kiểu bất biến trong Python có thật sự không sửa được không?
Bạn không sửa được chính object đó. Gán lại biến thì vẫn được: ten = ten + "!" tạo chuỗi mới và gắn tên vào đó, chuỗi cũ không đổi. Với tuple chứa list, phần list bên trong vẫn sửa được, nên "bất biến" chỉ chắc chắn khi mọi tầng đều bất biến.
Chủ đề
Bài này có hữu ích?
Hỏi đáp
Tham vấn chuyên môn
Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE
- Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
- Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
- Xây hệ thống AI cho doanh nghiệp tại VietPlatform.