⭐ Python Developer · Chặng 4Bài 2/5Bài học~60 phút

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.

Phương thức đặc biệt (dunder) và @property trong Python

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
  1. 1. __repr__ và __str__: in ra cho dễ đọc
  2. 2. So sánh: __eq__ và __lt__
  3. 3. Toán tử số học: __add__, __mul__
  4. 4. Dùng như một dãy: __len__, __iter__, __getitem__, __contains__
  5. 5. @property: thuộc tính có kiểm soát
  6. Tóm tắt
  7. Bài tập

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ả NotImplemented khi 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

  1. Viết lớp PhanSo hỗ trợ +, ==, < và in ra dạng 3/4, tự rút gọn.
  2. 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.

Bài tiếp theo
Ban biên tập HocFree

Chúng tôi viết những bài hướng dẫn dễ hiểu, thực tế để ai cũng có thể tự học lập trình và AI, hoàn toàn miễn phí.