Class và dataclass: tổ chức code cho trạm kiểm tra
Gói dữ liệu và hàm thành class: __init__, property, dataclass có kiểm tra hợp lệ, Enum cho OK/NG/LOI, kế thừa vừa đủ để đổi camera giả sang thật.
Học xong bài này, bạn sẽ
- Viết class có __init__, phương thức, property
- Dùng dataclass, Enum cho dữ liệu và kết quả
- Dùng kế thừa để đổi nguồn ảnh không sửa chương trình
Nên học trước: Đọc ghi file, pathlib và xử lý lỗi
Nội dung bài viết
Đến bài trước, chương trình của bạn gồm các hàm và dữ liệu nằm rời nhau: một dict đếm OK/NG, một list kết quả, vài biến dung sai, và hàm nào cũng phải nhận đủ các thứ đó qua tham số. Khi chương trình lớn dần (một trạm kiểm tra thật có camera, cấu hình, bộ đếm ca, kết nối PLC), cách viết này rất dễ rối. Bài này dạy class: gói dữ liệu và các hàm làm việc với dữ liệu đó thành một khối. Bạn sẽ gặp class ở gần như mọi bài sau của lộ trình: Dataset của PyTorch, bộ cấu hình dùng @dataclass, lớp điều khiển camera, client Modbus.
1. Vì sao cần class?
Hãy xem một bộ đếm kết quả ca viết bằng dict và hàm:
bo_dem = {"ok": 0, "ng": 0}
def ghi(bo_dem, ket_qua):
bo_dem["ok" if ket_qua == "OK" else "ng"] += 1
for kq in ["OK", "OK", "NG", "Ok", "OK"]:
ghi(bo_dem, kq)
print(bo_dem)
{'ok': 3, 'ng': 2}
Chương trình chạy, nhưng có hai vấn đề. Thứ nhất, "Ok" viết sai chữ hoa đã bị đếm là NG mà không ai báo. Thứ hai, ai cũng có thể sửa thẳng bo_dem["ng"] = 0 ở bất kỳ đâu trong chương trình. Class giải quyết cả hai: dữ liệu và các thao tác hợp lệ trên dữ liệu được gói chung, và chính class kiểm tra đầu vào.
2. Định nghĩa class đầu tiên
class BoDemCa:
"""Đếm kết quả OK/NG của một ca sản xuất."""
def __init__(self, ten_ca):
self.ten_ca = ten_ca # thuộc tính (attribute): dữ liệu riêng của từng đối tượng
self.so_ok = 0
self.so_ng = 0
def ghi(self, ket_qua): # phương thức (method): hàm gắn với đối tượng
if ket_qua == "OK":
self.so_ok += 1
elif ket_qua == "NG":
self.so_ng += 1
else:
raise ValueError(f"Kết quả không hợp lệ: {ket_qua!r} (chỉ nhận 'OK' hoặc 'NG')")
def tong(self):
return self.so_ok + self.so_ng
def ti_le_ng(self):
return self.so_ng / self.tong() if self.tong() else 0.0
ca_sang = BoDemCa("Ca sáng") # tạo một đối tượng (object, instance) từ class
ca_dem = BoDemCa("Ca đêm")
for kq in ["OK", "OK", "NG", "OK"]:
ca_sang.ghi(kq)
ca_dem.ghi("NG")
print(ca_sang.ten_ca, ca_sang.tong(), f"{100 * ca_sang.ti_le_ng():.1f}%")
print(ca_dem.ten_ca, ca_dem.tong(), f"{100 * ca_dem.ti_le_ng():.1f}%")
try:
ca_sang.ghi("Ok")
except ValueError as loi:
print("Lỗi:", loi)
Ca sáng 4 25.0%
Ca đêm 1 100.0%
Lỗi: Kết quả không hợp lệ: 'Ok' (chỉ nhận 'OK' hoặc 'NG')
- Class là bản thiết kế (
BoDemCa); đối tượng là một sản phẩm làm theo bản thiết kế đó (ca_sang,ca_dem). Hai đối tượng có dữ liệu riêng, không lẫn vào nhau. __init__chạy tự động khi tạo đối tượng, dùng để đặt giá trị ban đầu. Hai dấu gạch dưới mỗi bên là quy ước của Python cho các phương thức "đặc biệt".selflà chính đối tượng đang được gọi.ca_sang.ghi("OK")thực chất làBoDemCa.ghi(ca_sang, "OK"), nên phương thức nào cũng cóselflà tham số đầu tiên.- Giá trị sai giờ bị chặn ngay ở cửa:
"Ok"gây lỗi rõ ràng thay vì âm thầm thành NG.
Quy ước đặt tên: class viết hoa chữ đầu mỗi từ (BoDemCa, CameraGia), hàm và biến viết thường có gạch dưới (ti_le_ng), như bài hàm và module.
3. In đối tượng cho dễ đọc và thuộc tính tính toán
In thẳng một đối tượng chỉ cho ra dạng <__main__.BoDemCa object at 0x...>, vô dụng khi đọc log. Phương thức đặc biệt __repr__ quyết định đối tượng được in thế nào. Còn @property biến một phương thức thành thứ dùng như thuộc tính (không cần dấu ()), hợp với các giá trị tính từ dữ liệu khác:
class DungSai:
"""Một kích thước danh nghĩa với dung sai hai phía, ví dụ 25,00 ± 0,05 mm."""
def __init__(self, danh_nghia, duoi, tren):
if duoi >= tren:
raise ValueError("giới hạn dưới phải nhỏ hơn giới hạn trên")
self.danh_nghia = danh_nghia
self.duoi = duoi # độ lệch cho phép phía dưới (số âm)
self.tren = tren # độ lệch cho phép phía trên (số dương)
@property
def gioi_han_duoi(self):
return self.danh_nghia + self.duoi
@property
def gioi_han_tren(self):
return self.danh_nghia + self.tren
def danh_gia(self, gia_tri):
return "OK" if self.gioi_han_duoi <= gia_tri <= self.gioi_han_tren else "NG"
def __repr__(self):
return f"DungSai({self.danh_nghia} {self.duoi:+} / {self.tren:+} mm)"
duong_kinh = DungSai(25.00, -0.05, +0.05)
print(duong_kinh)
print(duong_kinh.gioi_han_duoi, duong_kinh.gioi_han_tren)
for d in (24.94, 25.00, 25.05, 25.06):
print(d, duong_kinh.danh_gia(d))
DungSai(25.0 -0.05 / +0.05 mm)
24.95 25.05
24.94 NG
25.0 OK
25.05 OK
25.06 NG
Hai giới hạn được tính từ danh nghĩa và độ lệch, không lưu riêng, nên không bao giờ "lệch pha" khi ai đó đổi danh_nghia. Kiểm tra hợp lệ đặt trong __init__: một đối tượng DungSai đã tạo được thì chắc chắn hợp lệ.
25.00 + 0.05 trong máy tính là 25.05 đúng không? Kết quả in ở trên cho thấy 25,05 được đánh giá OK, nhưng với các con số khác, sai số làm tròn số thực (bài biến và kiểu dữ liệu) có thể làm một giá trị đúng bằng giới hạn rơi sang NG. Trong trạm thật, kết quả đo luôn được làm tròn đến độ phân giải của phép đo (ví dụ 0,001 mm) trước khi so với giới hạn.4. dataclass: class cho dữ liệu, viết ngắn gọn
Rất nhiều class chỉ để chứa dữ liệu: một bản ghi kết quả đo, một bộ cấu hình. Viết __init__ và __repr__ cho chúng rất nhàm. Decorator @dataclass trong thư viện chuẩn tự sinh các phương thức đó từ danh sách trường có khai báo kiểu:
from dataclasses import asdict, dataclass, field
from datetime import datetime
@dataclass
class KetQuaDo:
ma_sp: str
gia_tri_mm: float
ket_qua: str
ly_do: str = "" # trường có giá trị mặc định đứng sau
thoi_diem: datetime = field(default_factory=datetime.now)
def __post_init__(self): # chạy ngay sau __init__ tự sinh
if self.ket_qua not in ("OK", "NG"):
raise ValueError(f"ket_qua phải là 'OK' hoặc 'NG', nhận {self.ket_qua!r}")
kq1 = KetQuaDo("SP-0001", 25.012, "OK", thoi_diem=datetime(2026, 10, 21, 8, 0, 5))
kq2 = KetQuaDo("SP-0002", 25.061, "NG", "vượt giới hạn trên", datetime(2026, 10, 21, 8, 0, 7))
print(kq1)
print(kq2.ly_do, kq2.gia_tri_mm)
print(asdict(kq1))
print(kq1 == KetQuaDo("SP-0001", 25.012, "OK", thoi_diem=datetime(2026, 10, 21, 8, 0, 5)))
KetQuaDo(ma_sp='SP-0001', gia_tri_mm=25.012, ket_qua='OK', ly_do='', thoi_diem=datetime.datetime(2026, 10, 21, 8, 0, 5))
vượt giới hạn trên 25.061
{'ma_sp': 'SP-0001', 'gia_tri_mm': 25.012, 'ket_qua': 'OK', 'ly_do': '', 'thoi_diem': datetime.datetime(2026, 10, 21, 8, 0, 5)}
True
- Từ 5 dòng khai báo,
@dataclasssinh__init__(theo đúng thứ tự trường),__repr__dễ đọc và__eq__(hai bản ghi bằng nhau khi mọi trường bằng nhau). __post_init__là chỗ đặt kiểm tra hợp lệ.asdictđổi thành dict, sẵn sàng ghi ra JSON hay CSV như bài đọc ghi file.- Kiểu khai báo (
str,float) chỉ là ghi chú cho người đọc và công cụ kiểm tra; Python không tự ép hay kiểm tra kiểu lúc chạy.
loi: list = [] trong dataclass sẽ bị Python từ chối (ValueError: mutable default ... is not allowed), vì mọi đối tượng sẽ dùng chung một list. Viết loi: list = field(default_factory=list) để mỗi đối tượng có list riêng. Cùng lý do đó, thoi_diem ở trên dùng default_factory=datetime.now: thời điểm được lấy lúc tạo từng bản ghi, không phải một lần lúc định nghĩa class.Cấu hình bất biến với frozen=True
Cấu hình của trạm được đọc một lần lúc khởi động và không nên bị sửa giữa chừng bởi một dòng code vô tình. frozen=True làm đối tượng chỉ đọc; muốn đổi thì tạo bản mới bằng dataclasses.replace:
from dataclasses import FrozenInstanceError, replace
@dataclass(frozen=True)
class CauHinhTram:
ma_tram: str = "ST3"
nguong: int = 128
roi: tuple = (100, 80, 400, 300)
cfg = CauHinhTram()
try:
cfg.nguong = 90
except FrozenInstanceError as loi:
print("Không sửa được:", loi)
cfg_moi = replace(cfg, nguong=90)
print(cfg)
print(cfg_moi)
Không sửa được: cannot assign to field 'nguong'
CauHinhTram(ma_tram='ST3', nguong=128, roi=(100, 80, 400, 300))
CauHinhTram(ma_tram='ST3', nguong=90, roi=(100, 80, 400, 300))
5. Enum: tập giá trị cố định, không gõ nhầm
Kết quả kiểm tra chỉ có vài giá trị: OK, NG, và thường thêm "lỗi hệ thống" (camera mất kết nối, không căn được ảnh) cần tách riêng khỏi NG. Chuỗi ký tự dễ gõ sai; Enum tạo một tập giá trị có tên, gõ sai là lỗi ngay:
from enum import Enum
class KetQua(Enum):
OK = "OK"
NG = "NG"
LOI = "LOI" # lỗi hệ thống: không đánh giá được sản phẩm
kq = KetQua("NG") # đổi từ chuỗi (ví dụ đọc từ file) sang Enum
print(kq, kq.value, kq is KetQua.NG)
print([k.name for k in KetQua])
try:
KetQua("Ok")
except ValueError as loi:
print("Lỗi:", loi)
print(KetQua.OK == "OK") # Enum KHÔNG bằng chuỗi: so với KetQua.OK hoặc dùng .value
KetQua.NG NG True
['OK', 'NG', 'LOI']
Lỗi: 'Ok' is not a valid KetQua
False
Dòng cuối là cái bẫy hay gặp: so KetQua.OK == "OK" luôn là False. Trong code, so với KetQua.OK; khi ghi ra file hay gửi PLC thì dùng .value.
6. Kế thừa vừa đủ: nhiều nguồn ảnh, một cách dùng
Trạm thật lấy ảnh từ camera; khi phát triển và kiểm thử, bạn lấy ảnh từ thư mục; khi viết bài tập, bạn dùng "camera giả" sinh dữ liệu. Nếu ba nguồn có cùng một phương thức doc(), phần còn lại của chương trình không cần biết đang dùng nguồn nào. Kế thừa (inheritance) cho phép viết một class cha mô tả "hợp đồng" chung, các class con thực hiện cụ thể:
from pathlib import Path
class NguonAnh:
"""Lớp cha: mọi nguồn ảnh phải có doc() trả về (tên, dữ liệu), hoặc None khi hết."""
def doc(self):
raise NotImplementedError("lớp con phải viết doc()")
def dong(self): # mặc định không cần dọn dẹp gì
pass
class CameraGia(NguonAnh):
"""Camera giả: trả về 'ảnh' là list độ sáng, dùng cho bài tập và kiểm thử."""
def __init__(self, so_khung):
self.so_khung = so_khung
self.dem = 0
def doc(self):
if self.dem >= self.so_khung:
return None
self.dem += 1
return f"khung_{self.dem:03d}", [120 + 10 * self.dem] * 4
class ThuMucAnh(NguonAnh):
"""Đọc lần lượt các file trong thư mục (ở đây đọc nội dung văn bản cho đơn giản)."""
def __init__(self, thu_muc, mau="*.txt"):
self.ds = sorted(Path(thu_muc).glob(mau))
self.vi_tri = 0
def doc(self):
if self.vi_tri >= len(self.ds):
return None
p = self.ds[self.vi_tri]
self.vi_tri += 1
return p.name, p.read_text(encoding="utf-8")
def chay_kiem_tra(nguon: NguonAnh, toi_da=10):
"""Không cần biết nguồn là camera hay thư mục: chỉ gọi doc() cho tới khi hết."""
so_anh = 0
while so_anh < toi_da and (khung := nguon.doc()) is not None:
ten, du_lieu = khung
print(f" xử lý {ten}: {du_lieu}")
so_anh += 1
nguon.dong()
return so_anh
print("Camera giả:")
chay_kiem_tra(CameraGia(so_khung=3))
Path("anh_thu").mkdir(exist_ok=True)
for i in range(2):
Path(f"anh_thu/anh_{i}.txt").write_text(f"nội dung ảnh {i}", encoding="utf-8")
print("Thư mục:")
print("đã xử lý", chay_kiem_tra(ThuMucAnh("anh_thu")), "ảnh")
print(isinstance(CameraGia(1), NguonAnh), issubclass(ThuMucAnh, NguonAnh))
Camera giả:
xử lý khung_001: [130, 130, 130, 130]
xử lý khung_002: [140, 140, 140, 140]
xử lý khung_003: [150, 150, 150, 150]
Thư mục:
xử lý anh_0.txt: nội dung ảnh 0
xử lý anh_1.txt: nội dung ảnh 1
đã xử lý 2 ảnh
True True
class CameraGia(NguonAnh):CameraGiakế thừaNguonAnh, có sẵn mọi phương thức của lớp cha (dong()) và tự viết lại (ghi đè, override)doc().- Lớp cha ném
NotImplementedErrortrongdoc(): quên viếtdoc()ở lớp con là lỗi rõ ràng ngay lần gọi đầu tiên. (khung := nguon.doc())là toán tử gán trong biểu thức (Python 3.8+): gán và kiểm tra trong cùng một dòng củawhile.- Ở chặng OpenCV, bạn sẽ thêm lớp
CameraUSB(NguonAnh)đọc webcam bằngcv2.VideoCapture;chay_kiem_trakhông phải sửa một dòng nào.
Camera → CameraCongNghiep → CameraGigE → CameraBasler → ...) rất khó đọc và khó sửa. Khi chỉ muốn tái sử dụng chức năng, cách thường tốt hơn là để một đối tượng chứa đối tượng khác (ví dụ trạm kiểm tra có thuộc tính self.nguon và self.bo_dem).7. Ghép lại: một trạm kiểm tra nhỏ
Đoạn cuối ghép mọi thứ của bài: nguồn ảnh, dung sai, bản ghi kết quả, bộ đếm, enum. Class TramKiemTra chứa các đối tượng kia thay vì kế thừa chúng.
import json
class CameraDo(NguonAnh):
"""Camera giả trả về một giá trị đo (mm) mỗi lần đọc."""
def __init__(self, cac_gia_tri):
self.cac_gia_tri = list(cac_gia_tri)
def doc(self):
return self.cac_gia_tri.pop(0) if self.cac_gia_tri else None
class TramKiemTra:
def __init__(self, nguon, dung_sai, ten_ca):
self.nguon = nguon
self.dung_sai = dung_sai
self.bo_dem = BoDemCa(ten_ca)
self.ban_ghi = []
def chay(self):
so = 0
while (gia_tri := self.nguon.doc()) is not None:
so += 1
kq = KetQua(self.dung_sai.danh_gia(round(gia_tri, 3)))
ly_do = "" if kq is KetQua.OK else ("dưới giới hạn" if gia_tri < self.dung_sai.danh_nghia else "trên giới hạn")
self.bo_dem.ghi(kq.value)
self.ban_ghi.append(KetQuaDo(f"SP-{so:04d}", gia_tri, kq.value, ly_do,
datetime(2026, 10, 21, 8, 0, so)))
def luu(self, duong_dan):
dong = [json.dumps(asdict(b), ensure_ascii=False, default=str) for b in self.ban_ghi]
Path(duong_dan).write_text("\n".join(dong) + "\n", encoding="utf-8")
tram = TramKiemTra(CameraDo([25.012, 24.991, 25.061, 25.003, 24.948]), DungSai(25.00, -0.05, 0.05), "Ca sáng")
tram.chay()
tram.luu("ket_qua_ca.jsonl")
print(f"{tram.bo_dem.ten_ca}: {tram.bo_dem.tong()} sản phẩm, NG {100 * tram.bo_dem.ti_le_ng():.0f}%")
for b in tram.ban_ghi:
if b.ket_qua == KetQua.NG.value:
print(" ", b.ma_sp, b.gia_tri_mm, b.ly_do)
print(Path("ket_qua_ca.jsonl").read_text(encoding="utf-8").splitlines()[2])
Ca sáng: 5 sản phẩm, NG 40%
SP-0003 25.061 trên giới hạn
SP-0005 24.948 dưới giới hạn
{"ma_sp": "SP-0003", "gia_tri_mm": 25.061, "ket_qua": "NG", "ly_do": "trên giới hạn", "thoi_diem": "2026-10-21 08:00:03"}
default=str trong json.dumps đổi những thứ JSON không biết (ở đây datetime) thành chuỗi. Mỗi class làm một việc và có tên nói rõ việc đó; muốn đổi camera giả sang thư mục ảnh thật hay camera thật, chỉ thay đối tượng truyền vào TramKiemTra.
Tóm tắt
- Class gói dữ liệu (thuộc tính) và thao tác (phương thức); đối tượng là một bản cụ thể.
__init__đặt giá trị ban đầu,selflà chính đối tượng. - Kiểm tra hợp lệ ngay trong
__init__hoặc phương thức nhận dữ liệu: dữ liệu sai bị chặn ở cửa. __repr__để in dễ đọc;@propertycho giá trị tính từ thuộc tính khác.@dataclasscho class chứa dữ liệu: tự sinh__init__,__repr__,__eq__;__post_init__để kiểm tra;field(default_factory=...)cho mặc định là list, dict, thời điểm;frozen=Truecho cấu hình chỉ đọc.Enumcho tập giá trị cố định như OK/NG/LOI; nhớKetQua.OK != "OK".- Kế thừa để nhiều class có chung "hợp đồng" (cùng phương thức
doc()); ưu tiên chứa đối tượng khác hơn là kế thừa nhiều tầng.
Bài tập
Bài 1. Bộ đếm theo lý do NG
Mở rộng BoDemCa: phương thức ghi(ket_qua, ly_do="") lưu thêm số lần của từng lý do NG vào một dict, và phương thức pareto() trả về list (ly_do, so_lan) sắp xếp giảm dần. Thêm __repr__ in tên ca, tổng và tỉ lệ NG.
Xem đáp án
class BoDemCa2(BoDemCa):
def __init__(self, ten_ca):
super().__init__(ten_ca) # chạy __init__ của lớp cha trước
self.ly_do_ng = {}
def ghi(self, ket_qua, ly_do=""):
super().ghi(ket_qua) # giữ nguyên kiểm tra hợp lệ của lớp cha
if ket_qua == "NG":
ly_do = ly_do or "không rõ"
self.ly_do_ng[ly_do] = self.ly_do_ng.get(ly_do, 0) + 1
def pareto(self):
return sorted(self.ly_do_ng.items(), key=lambda cap: cap[1], reverse=True)
def __repr__(self):
return f"BoDemCa2({self.ten_ca!r}, tổng {self.tong()}, NG {100 * self.ti_le_ng():.1f}%)"
bd = BoDemCa2("Ca chiều")
for kq, ld in [("OK", ""), ("NG", "xước"), ("NG", "móp"), ("NG", "xước"), ("OK", ""), ("NG", "")]:
bd.ghi(kq, ld)
print(bd)
print(bd.pareto())
BoDemCa2('Ca chiều', tổng 6, NG 66.7%)
[('xước', 2), ('móp', 1), ('không rõ', 1)]
super() gọi phương thức của lớp cha: lớp con chỉ viết phần thêm vào, phần kiểm tra hợp lệ không bị chép lại (chép lại thì sửa một chỗ sẽ quên chỗ kia).
Bài 2. Cấu hình đọc từ JSON
Viết hàm doc_cau_hinh(duong_dan) -> CauHinhTram: đọc file JSON (như bài trước), bỏ qua khóa lạ, đổi roi từ list sang tuple, và báo lỗi nếu nguong ngoài 0–255. Gợi ý: CauHinhTram(**du_lieu) truyền dict thành các tham số có tên; dataclasses.fields(CauHinhTram) cho danh sách tên trường.
Xem đáp án
from dataclasses import fields
def doc_cau_hinh(duong_dan):
du_lieu = json.loads(Path(duong_dan).read_text(encoding="utf-8"))
ten_truong = {f.name for f in fields(CauHinhTram)}
la = set(du_lieu) - ten_truong
if la:
print("Bỏ qua khóa lạ:", sorted(la))
du_lieu = {k: v for k, v in du_lieu.items() if k in ten_truong}
if "roi" in du_lieu:
du_lieu["roi"] = tuple(du_lieu["roi"]) # JSON chỉ có list
cfg = CauHinhTram(**du_lieu)
if not 0 <= cfg.nguong <= 255:
raise ValueError(f"nguong phải trong khoảng 0–255, nhận {cfg.nguong}")
return cfg
Path("tram.json").write_text('{"nguong": 95, "roi": [10, 20, 300, 200], "mau_den": "do"}', encoding="utf-8")
print(doc_cau_hinh("tram.json"))
Bỏ qua khóa lạ: ['mau_den']
CauHinhTram(ma_tram='ST3', nguong=95, roi=(10, 20, 300, 200))
Bài 3. Thêm một nguồn ảnh
Viết lớp LapLai(NguonAnh) nhận một nguồn khác và số lần n, trả về mỗi khung của nguồn đó n lần liên tiếp (hữu ích để đo độ lặp lại: đo cùng một ảnh nhiều lần). Chạy chay_kiem_tra(LapLai(CameraGia(2), 2)).
Xem đáp án
class LapLai(NguonAnh):
def __init__(self, nguon, n):
self.nguon = nguon # chứa một nguồn khác, không kế thừa nó
self.n = n
self.khung = None
self.con_lai = 0
def doc(self):
if self.con_lai == 0:
self.khung = self.nguon.doc()
if self.khung is None:
return None
self.con_lai = self.n
self.con_lai -= 1
return self.khung
def dong(self):
self.nguon.dong()
print("đã xử lý", chay_kiem_tra(LapLai(CameraGia(2), 2)), "khung")
xử lý khung_001: [130, 130, 130, 130]
xử lý khung_001: [130, 130, 130, 130]
xử lý khung_002: [140, 140, 140, 140]
xử lý khung_002: [140, 140, 140, 140]
đã xử lý 4 khung
LapLai vừa là một nguồn ảnh (kế thừa NguonAnh) vừa chứa một nguồn ảnh khác: kiểu thiết kế này gọi là "bọc" (wrapper), rất hay gặp khi thêm chức năng cho camera như ghi lại ảnh, giới hạn tốc độ, hay chèn ảnh lỗi để kiểm thử.
Bài tiếp theo: Môi trường ảo, pip và thư viện cho AI Vision, chuẩn bị cài NumPy và OpenCV.
Nguồn tham khảo: Python Tutorial: Classes, Python: dataclasses, Python: enum, Python: assignment expressions (:=).
Bài tập thực hành
- Mở rộng BoDemCa để đếm theo lý do NG và in bảng Pareto.
- Viết lớp LapLai(NguonAnh) trả mỗi khung của một nguồn khác n lần.
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.


