OOP & mô hình dữ liệu

Một class là bản thiết kế; mỗi object gói dữ liệu (thuộc tính) và hành vi (phương thức). __init__ chạy khi tạo object; self là chính object đó:

class BoDem:
    def __init__(self, batdau=0):   # chay khi tao object
        self.so = batdau            # thuoc tinh cua THUC THE

    def tang(self):                 # self = chinh object
        self.so += 1

d = BoDem()
d.tang(); d.tang()                  # BoDem.tang(d)
print(d.so)

2

• ▸__init__ khởi tạo trạng thái; self là object đang được thao tác.
• ▸d.tang() thực chất là BoDem.tang(d) - Python tự truyền d vào self.
• ▸Thuộc tính của thực thể (self.so) là RIÊNG mỗi object.

Cú pháp quen thuộc - print(p), p1 == p2, p1 + p2 - thực ra gọi các dunder của object. Bật/tắt định nghĩa dunder để thấy khác biệt:

class Diem:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):                 # repr(p), và print khi thiếu __str__
        return f"Diem({self.x}, {self.y})"

    def __eq__(self, other):            # p1 == p2
        return (self.x, self.y) == (other.x, other.y)

    def __add__(self, other):           # p1 + p2
        return Diem(self.x + other.x, self.y + other.y)

• ▸len(x) → x.__len__(); a + b → a.__add__(b); print(x) → x.__str__() (thiếu thì __repr__).
• ▸Định nghĩa dunder = dạy object của bạn cư xử như kiểu dựng sẵn.
• ▸Không định nghĩa → hành vi mặc định (in khó đọc, == theo danh tính, + báo lỗi).

Mô hình dữ liệu mạnh nhất khi object của bạn hành xử như kiểu dựng sẵn. Viết vài dunder là len(), [], in, vòng for đều chạy:

class Tui:
    def __init__(self, *items):
        self._xs = list(items)
    def __len__(self):              # len(t)
        return len(self._xs)
    def __getitem__(self, i):       # t[i]  (va for tu suy ra neu thieu __iter__)
        return self._xs[i]
    def __contains__(self, x):      # x in t
        return x in self._xs

t = Tui("a", "b", "c")
print(len(t), t[0], "b" in t, [x.upper() for x in t])

3 a True ['A', 'B', 'C']

• ▸__len__ → len(); __getitem__ → t[i]; __contains__ → “x in t”.
• ▸Thiếu __iter__, vòng for vẫn chạy bằng cách gọi __getitem__ với 0,1,2… - nhưng nên thêm __iter__ cho rõ & nhanh.
• ▸Viết đủ giao thức → object “của bạn” dùng y như list/dict dựng sẵn.

@property cho truy cập như thuộc tính nhưng chạy hàm bên dưới - để tính toán hoặc kiểm soát khi gán (validate):

class TaiKhoan:
    def __init__(self, sodu):
        self._sodu = sodu

    @property
    def sodu(self):             # doc: tk.sodu
        return self._sodu

    @sodu.setter
    def sodu(self, v):          # ghi: tk.sodu = ...
        if v < 0:
            raise ValueError("so du am!")   # validate khi gan
        self._sodu = v

tk = TaiKhoan(100)
tk.sodu = 50; print(tk.sodu)
tk.sodu = -1                    # -> ValueError

50
ValueError: so du am!

• ▸@property = getter (đọc như thuộc tính); @ten.setter = ghi có kiểm soát.
• ▸Chỉ getter → thuộc tính “chỉ đọc”; thêm setter để validate/chuẩn hoá khi gán.
• ▸Lợi: thêm logic mà KHÔNG đổi mã nơi dùng (tk.sodu vẫn như trước).

Ngoài việc bớt boilerplate, @dataclass còn nhiều tuỳ chọn mạnh:

from dataclasses import dataclass, field

@dataclass(frozen=True, order=True)     # bat bien + so sanh duoc
class Diem:
    x: int
    y: int
    tags: list = field(default_factory=list)   # moi object mot list MOI
    def __post_init__(self):
        if not self.tags:
            object.__setattr__(self, "tags", ["mac-dinh"])  # frozen -> dung cach nay

a, b = Diem(1, 2), Diem(1, 3)
print(a < b, a.tags)            # order=True -> so sanh theo (x, y, tags)
a.x = 9                         # frozen -> loi

True ['mac-dinh']
FrozenInstanceError

• ▸frozen=True: object bất biến (gán lại → FrozenInstanceError) và hashable.
• ▸order=True: tự sinh __lt__… → so sánh & sorted được.
• ▸field(default_factory=list): MỖI object một list mới - tránh bẫy mặc định mutable.
• ▸__post_init__: chạy sau __init__ để validate/tính phái sinh.

Thuộc tính của một object thường sống trong một dict ẩn (__dict__) - linh hoạt nhưng tốn bộ nhớ. Với class tạo rất nhiều object nhỏ, __slots__ cố định danh sách thuộc tính, bỏ __dict__:

class KhongSlots:
    def __init__(self, x): self.x = x

class CoSlots:
    __slots__ = ("x",)          # co dinh thuoc tinh; bo __dict__
    def __init__(self, x): self.x = x

a = KhongSlots(1); print(hasattr(a, "__dict__"))   # True  (luu trong dict)
b = CoSlots(1);    print(hasattr(b, "__dict__"))   # False (tiet kiem hon)
b.y = 2            # AttributeError: khong co trong __slots__

True
False
AttributeError

• ▸Mặc định thuộc tính ở __dict__ → đổi/thêm tuỳ ý nhưng tốn bộ nhớ.
• ▸__slots__: ít bộ nhớ & truy cập nhanh hơn, nhưng cố định danh sách thuộc tính.
• ▸Dùng __slots__ khi tạo HÀNG TRIỆU object nhỏ; bình thường không cần.