Phương thức đặc biệt (dunder) và @property trong Python
Làm đối tượng dùng tự nhiên như kiểu có sẵn: __repr__, __str__, __eq__, __lt__, __add__, __len__, __iter__ và @property có setter.
Học xong bài này, bạn sẽ
- Viết __repr__, __str__ để in đối tượng dễ đọc
- Viết __eq__, __lt__, __len__, __iter__ để đối tượng dùng như kiểu có sẵn
- Kiểm soát thuộc tính bằng @property và setter
Nên học trước: Class và đối tượng
Nội dung bài viết
In một đối tượng tự viết ra thì được <__main__.PhanSo object at 0x7f...>, so sánh hai đối tượng giống hệt nhau thì == trả False, không sắp xếp được, không dùng được len(). Bài này dạy cách làm đối tượng của bạn "hòa nhập" với Python bằng các phương thức đặc biệt (tên có hai dấu gạch dưới hai bên, gọi tắt là dunder), và cách kiểm soát thuộc tính bằng @property.
1. __repr__ và __str__: in ra cho dễ đọc
class Diem:
def __init__(self, x: float, y: float):
self.x = x
self.y = y
def __repr__(self) -> str: # cho lập trình viên: rõ ràng, không mơ hồ
return f"Diem(x={self.x}, y={self.y})"
def __str__(self) -> str: # cho người dùng: thân thiện
return f"({self.x}, {self.y})"
p = Diem(3, 4)
print(p) # print gọi __str__
print(repr(p)) # repr gọi __repr__
print([p, Diem(0, 1)]) # list hiển thị các phần tử bằng __repr__
(3, 4)
Diem(x=3, y=4)
[Diem(x=3, y=4), Diem(x=0, y=1)]
Luôn viết __repr__ cho mọi class: nó hiện trong debugger, trong log, trong REPL. Quy ước tốt: __repr__ trông giống câu lệnh tạo lại đối tượng. Nếu chỉ có __repr__, print cũng dùng nó.
2. So sánh: __eq__ và __lt__
class Diem:
def __init__(self, x, y):
self.x, self.y = x, y
def __repr__(self):
return f"Diem({self.x}, {self.y})"
def __eq__(self, khac):
if not isinstance(khac, Diem):
return NotImplemented # để Python thử cách khác, cuối cùng trả False
return (self.x, self.y) == (khac.x, khac.y)
def __hash__(self): # định nghĩa __eq__ thì phải định nghĩa lại __hash__
return hash((self.x, self.y)) # nếu muốn dùng làm khóa dict, phần tử set
def __lt__(self, khac): # "nhỏ hơn": theo khoảng cách tới gốc tọa độ
return self.x ** 2 + self.y ** 2 < khac.x ** 2 + khac.y ** 2
print(Diem(1, 2) == Diem(1, 2), Diem(1, 2) == "abc")
print(sorted([Diem(3, 4), Diem(1, 1), Diem(0, 2)]))
print(len({Diem(1, 2), Diem(1, 2)}))
True False
[Diem(1, 1), Diem(0, 2), Diem(3, 4)]
1
Không có __eq__, == so sánh danh tính (có phải cùng một đối tượng trong bộ nhớ không), giống is. sorted và min, max chỉ cần __lt__. Cần đủ cả <=, >, >= thì dùng decorator functools.total_ordering, hoặc đơn giản hơn: dataclass(order=True) ở bài 4.
3. Toán tử số học: __add__, __mul__
from math import gcd
class PhanSo:
def __init__(self, tu: int, mau: int = 1):
if mau == 0:
raise ZeroDivisionError("Mẫu số bằng 0")
if mau < 0:
tu, mau = -tu, -mau
g = gcd(tu, mau)
self.tu, self.mau = tu // g, mau // g
def __repr__(self):
return f"PhanSo({self.tu}, {self.mau})"
def __str__(self):
return f"{self.tu}/{self.mau}" if self.mau != 1 else str(self.tu)
def __add__(self, khac):
if isinstance(khac, int):
khac = PhanSo(khac)
return PhanSo(self.tu * khac.mau + khac.tu * self.mau, self.mau * khac.mau)
__radd__ = __add__ # cho phép 1 + PhanSo(...)
def __mul__(self, khac):
return PhanSo(self.tu * khac.tu, self.mau * khac.mau)
def __eq__(self, khac):
return isinstance(khac, PhanSo) and (self.tu, self.mau) == (khac.tu, khac.mau)
a, b = PhanSo(1, 2), PhanSo(1, 3)
print(a + b, a * b, PhanSo(2, -4), 1 + a, PhanSo(6, 3))
print(sum([PhanSo(1, 2), PhanSo(1, 3), PhanSo(1, 6)]))
5/6 1/6 -1/2 3/2 2
1
sum() bắt đầu từ số 0 rồi cộng dần, tức là gọi 0 + PhanSo(1, 2): int không biết cộng với PhanSo nên Python thử PhanSo.__radd__. Đó là lý do cần __radd__. (Thư viện chuẩn đã có fractions.Fraction làm việc này đầy đủ; tự viết ở đây để hiểu cơ chế.)
4. Dùng như một dãy: __len__, __iter__, __getitem__, __contains__
class DanhSachPhat:
def __init__(self, ten: str, bai_hat: list[str]):
self.ten = ten
self._bai = list(bai_hat)
def __len__(self):
return len(self._bai)
def __iter__(self):
return iter(self._bai)
def __getitem__(self, i):
return self._bai[i]
def __contains__(self, bai):
return bai.casefold() in (b.casefold() for b in self._bai)
ds = DanhSachPhat("Chill", ["Lạc trôi", "Nơi này có anh", "Có chàng trai viết lên cây"])
print(len(ds), ds[0], ds[-1])
print("NƠI NÀY CÓ ANH" in ds)
for stt, bai in enumerate(ds, 1):
print(stt, bai)
3 Lạc trôi Có chàng trai viết lên cây
True
1 Lạc trôi
2 Nơi này có anh
3 Có chàng trai viết lên cây
Đây là sức mạnh của "duck typing" trong Python: đối tượng có __len__ thì dùng được len(), có __iter__ thì dùng được trong for, không cần kế thừa từ list.
5. @property: thuộc tính có kiểm soát
class NhietDo:
def __init__(self, do_c: float):
self.do_c = do_c # đi qua setter ngay từ đầu
@property
def do_c(self) -> float: # getter: đọc nhiet.do_c
return self._do_c
@do_c.setter
def do_c(self, gia_tri: float) -> None: # setter: gán nhiet.do_c = ...
if gia_tri < -273.15:
raise ValueError("Thấp hơn độ không tuyệt đối")
self._do_c = gia_tri
@property
def do_f(self) -> float: # thuộc tính tính toán, chỉ đọc
return self._do_c * 9 / 5 + 32
t = NhietDo(36.6)
print(t.do_c, round(t.do_f, 2))
t.do_c = 100
print(t.do_f)
try:
t.do_c = -300
except ValueError as loi:
print("Từ chối:", loi)
# t.do_f = 50 → AttributeError: không có setter nên chỉ đọc
36.6 97.88
212.0
Từ chối: Thấp hơn độ không tuyệt đối
Người dùng lớp viết t.do_c như thuộc tính thường, nhưng mỗi lần đọc, gán đều đi qua hàm của bạn. Lời khuyên kiểu Python: cứ bắt đầu bằng thuộc tính công khai thông thường; khi cần kiểm tra hay tính toán thì đổi sang @property, code bên ngoài không phải sửa gì. Không cần viết get_x(), set_x() như Java.
Tóm tắt
__repr__cho mọi class;__str__khi cần dạng thân thiện.__eq__(kèm__hash__),__lt__cho so sánh, sắp xếp; trảNotImplementedkhi khác kiểu.__add__,__radd__,__mul__cho toán tử;__len__,__iter__,__getitem__,__contains__cho dãy.@property+@x.setterđể kiểm soát đọc, gán; property không setter là chỉ đọc.
Bài tập
Bài 1. Phân số so sánh được
Thêm vào lớp PhanSo phép trừ và phép so sánh <, rồi sắp xếp [3/4, 1/2, 5/6, 2/3].
Xem đáp án
from math import gcd
class PhanSo:
def __init__(self, tu: int, mau: int = 1):
if mau == 0:
raise ZeroDivisionError("Mẫu số bằng 0")
if mau < 0:
tu, mau = -tu, -mau
g = gcd(tu, mau)
self.tu, self.mau = tu // g, mau // g
def __repr__(self):
return f"{self.tu}/{self.mau}"
def __sub__(self, khac):
return PhanSo(self.tu * khac.mau - khac.tu * self.mau, self.mau * khac.mau)
def __lt__(self, khac):
return self.tu * khac.mau < khac.tu * self.mau # nhân chéo, không dùng số thực
ds = [PhanSo(3, 4), PhanSo(1, 2), PhanSo(5, 6), PhanSo(2, 3)]
print(sorted(ds), PhanSo(3, 4) - PhanSo(1, 2))
[1/2, 2/3, 3/4, 5/6] 1/4
So sánh bằng nhân chéo (mẫu luôn dương nhờ __init__) cho kết quả chính xác tuyệt đối, không dính sai số làm tròn của số thực.
Bài 2. Sản phẩm có giá kiểm soát
Viết lớp SanPham với property gia (setter từ chối giá âm) và property chỉ đọc gia_sau_thue (VAT 8%, làm tròn).
Xem đáp án
class SanPham:
VAT = 0.08
def __init__(self, ten: str, gia: int):
self.ten = ten
self.gia = gia
@property
def gia(self) -> int:
return self._gia
@gia.setter
def gia(self, gia_moi: int) -> None:
if gia_moi < 0:
raise ValueError(f"Giá không được âm: {gia_moi}")
self._gia = gia_moi
@property
def gia_sau_thue(self) -> int:
return round(self._gia * (1 + self.VAT))
def __repr__(self):
return f"SanPham({self.ten!r}, {self._gia})"
sp = SanPham("Tai nghe", 590_000)
print(sp, sp.gia_sau_thue)
sp.gia = 490_000
print(sp.gia_sau_thue)
try:
SanPham("Lỗi", -1)
except ValueError as loi:
print(loi)
SanPham('Tai nghe', 590000) 637200
529200
Giá không được âm: -1
Nguồn tham khảo: Data model: Special method names; Built-in Functions: property; fractions.
Bài tập thực hành
- Viết lớp PhanSo hỗ trợ +, ==, < và in ra dạng 3/4, tự rút gọn.
- Thêm property nhiet_do_f cho lớp NhietDo lưu độ C; setter từ chối giá trị dưới -273,15.
Làm xong bài tập mới chuyển sang bài tiếp theo: tự viết code là cách duy nhất để nhớ lâu.


