⭐ Vision Engineer · Chặng 1Bài 7/12Bài học~60 phút

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.

Class và dataclass: tổ chức code cho trạm kiểm tra

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
  1. 1. Vì sao cần class?
  2. 2. Định nghĩa class đầu tiên
  3. 3. In đối tượng cho dễ đọc và thuộc tính tính toán
  4. 4. dataclass: class cho dữ liệu, viết ngắn gọn
  5. 5. Enum: tập giá trị cố định, không gõ nhầm
  6. 6. Kế thừa vừa đủ: nhiều nguồn ảnh, một cách dùng
  7. 7. Ghép lại: một trạm kiểm tra nhỏ
  8. Tóm tắt
  9. Bài tập

Đế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".
  • self là 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ó self là 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ệ.

So sánh số thực ở biên dung sai25.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, @dataclass sinh __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.
Giá trị mặc định là list hay dict: dùng default_factoryViết 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): CameraGia kế thừa NguonAnh, 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 NotImplementedError trong doc(): quên viết doc() ở 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ủa while.
  • Ở chặng OpenCV, bạn sẽ thêm lớp CameraUSB(NguonAnh) đọc webcam bằng cv2.VideoCapture; chay_kiem_tra không phải sửa một dòng nào.
Đừng lạm dụng kế thừaMột hai tầng kế thừa để có "hợp đồng" chung là đủ cho hầu hết code của trạm. Cây kế thừa năm sáu tầng (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, self là 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; @property cho giá trị tính từ thuộc tính khác.
  • @dataclass cho 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=True cho cấu hình chỉ đọc.
  • Enum cho 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

  1. Mở rộng BoDemCa để đếm theo lý do NG và in bảng Pareto.
  2. 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.

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í.