Bỏ qua đến nội dung chính
Mục lục

Module typing trong Python: Generic, TypeVar, Protocol

AIDev Team · duyệt: Nguyễn Việt Chung

Bài 1/10 · Chương 16

Code sạch, kiểm thử và gỡ lỗi

  • 8 phút
  • Trung cấp
  • Python 3.14
  • Cập nhật

Module typing trong Python cung cấp những chú thích kiểu (type hints) mà int hay list[str] chưa tả được: tham số chỉ nhận vài giá trị, tham số là một hàm, hàm nhận list của kiểu nào cũng được. Bạn dùng chúng khi hàm tính tiền của mình được nhiều người gọi, để người đọc và công cụ soát code biết ngay mỗi tham số nhận gì.

Cần biết trước: type hints, import và lớp trừu tượng.

Literal và Any cho tham số đặc biệt

Hàm tính tiền nhận cách trả chỉ là "tien_mat" hoặc "the", còn hàm ghi chú nhận giá trị kiểu gì cũng được:

python
from typing import Any, Literal

CachTra = Literal["tien_mat", "the"]

def tinh_tien(tong: int, cach_tra: CachTra) -> int:
    if cach_tra == "the":
        return tong + tong * 2 // 100
    return tong

def ghi_chu(gia_tri: Any) -> str:
    return f"[{type(gia_tri).__name__}] {gia_tri}"

print(tinh_tien(96000, "the"))
print(ghi_chu(96000), ghi_chu("DH1024"))

KẾT QUẢ

97920
[int] 96000 [str] DH1024

Literal["tien_mat", "the"] nói tham số chỉ nhận đúng các giá trị liệt kê. Dòng CachTra = … đặt cho chú thích một cái tên ngắn, gọi là bí danh kiểu, để dùng lại ở nhiều hàm. Any nghĩa là kiểu nào cũng được: công cụ soát kiểu không kiểm gì ở tham số đó. Các tên này nằm trong module typing của thư viện chuẩn, nên chỉ cần import.

Callable: tham số là một hàm

Phụ phí của mỗi cách trả có thể là một hàm riêng, truyền vào hàm tính tiền như một đối số:

python
from collections.abc import Callable

def phi_the(tong: int) -> int:
    return tong * 2 // 100

def mien_phi(tong: int) -> int:
    return 0

def tinh_tien(tong: int, phu_phi: Callable[[int], int]) -> int:
    return tong + phu_phi(tong)

print(tinh_tien(96000, phi_the))
print(tinh_tien(96000, mien_phi))

KẾT QUẢ

97920
96000

Callable[[int], int] đọc là "một thứ gọi được, nhận một int, trả về int": cặp ngoặc vuông bên trong liệt kê kiểu các đối số, phần sau là kiểu trả về. Hàm không nhận gì thì viết Callable[[], int]. Bản Python mới khuyên lấy Callable từ collections.abc, còn typing.Callable vẫn chạy và hay gặp trong code cũ. Đổi print(tinh_tien(96000, mien_phi)) thành print(tinh_tien(96000, lambda tong: 15000)) rồi chạy lại: dòng thứ hai in 111000, vì một lambda cũng là thứ gọi được.

Hàm generic với tham số kiểu T

Hàm lấy phần tử đầu của list chạy được với list số, list chuỗi hay list object. Chú thích list[int] thì sai với list chuỗi, còn Any thì mất thông tin: kết quả có cùng kiểu với phần tử. Hàm generic giữ thông tin đó bằng một tham số kiểu, viết trong ngoặc vuông ngay sau tên hàm:

python
def phan_tu_dau[T](ds: list[T], mac_dinh: T) -> T:
    if ds:
        return ds[0]
    return mac_dinh

print(phan_tu_dau([29000, 32000], 0))
print(phan_tu_dau([], "chưa có món"))
print(phan_tu_dau.__type_params__)

KẾT QUẢ

29000
chưa có món
(T,)

[T] khai một biến kiểu tên T, và các chỗ ghi T trong dòng def là cùng một kiểu: gọi với list[int] thì kết quả là int, gọi với list[str] thì là str. T giống chỗ trống trong mẫu đơn, mỗi lần gọi điền một kiểu. Thuộc tính __type_params__ cho thấy hàm có những biến kiểu nào. Cú pháp [T] có từ Python 3.12.

Class generic

Một hàng chờ đơn hàng chứa đơn kiểu gì cũng được, nhưng mỗi hàng chờ chỉ chứa một kiểu. Class generic khai tham số kiểu ngay sau tên class:

python
class HangCho[T]:
    def __init__(self) -> None:
        self.cac_phan_tu: list[T] = []

    def them(self, x: T) -> None:
        self.cac_phan_tu.append(x)

    def lay_ra(self) -> T:
        return self.cac_phan_tu.pop(0)

don_cho = HangCho[str]()
don_cho.them("DH1024")
don_cho.them("DH1025")
print(don_cho.lay_ra(), len(don_cho.cac_phan_tu))

KẾT QUẢ

DH1024 1

HangCho[str]() tạo hàng chờ chứa chuỗi. Dòng self.cac_phan_tu: list[T] = [] ghi kiểu cho thuộc tính ngay lúc gán. Code viết trước Python 3.12 khai T bằng TypeVar và cho class kế thừa Generic[T], hai cách cho cùng một nghĩa:

python
from typing import Generic, TypeVar

T = TypeVar("T")

def phan_tu_dau(ds: list[T], mac_dinh: T) -> T:
    return ds[0] if ds else mac_dinh

class HangCho(Generic[T]):
    def __init__(self) -> None:
        self.cac_phan_tu: list[T] = []

print(phan_tu_dau([45000], 0), HangCho[int]().cac_phan_tu)
print(T, phan_tu_dau.__type_params__)

KẾT QUẢ

45000 []
~T ()

Ở cách cũ, T là một biến bình thường của module, in ra ~T, và hàm không có biến kiểu riêng nên __type_params__ rỗng. Gặp TypeVar trong thư viện, bạn đọc nó như [T].

Protocol: object chỉ cần có đúng phương thức

Hàm cộng phí chỉ cần đối số có phương thức gia() trả về int. Lớp trừu tượng đòi các class muốn hợp với nó phải kế thừa nó. Protocol tả cùng yêu cầu mà không bắt kế thừa, đúng tinh thần duck typing:

python
from typing import Protocol

class CoGia(Protocol):
    def gia(self) -> int: ...

class PhiGiao:
    def gia(self) -> int:
        return 30000

def cong_vao(tong: int, muc: CoGia) -> int:
    return tong + muc.gia()

print(cong_vao(96000, PhiGiao()))
print(PhiGiao.__mro__)

KẾT QUẢ

126000
(<class '__main__.PhiGiao'>, <class 'object'>)

PhiGiao không kế thừa CoGia (__mro__ chỉ có chính nó và object), nhưng có gia() trả về int nên hợp với CoGia. Thân ... trong CoGia nghĩa là Protocol chỉ tả chữ ký của phương thức, không cài nó.

Kiểm tra nhanh

  1. Sau dòng def dau[T](ds: list[T]) -> T: return ds[0], lệnh print(dau([29000, "Huế"])) in ra gì?

    • 29000
    • Báo lỗi TypeError
    • Huế
  2. Trong khung bẫy về Protocol, isinstance(30000, CoGia) cho kết quả gì khi CoGia chưa có @runtime_checkable?

    • False, vì số nguyên không có phương thức gia()
    • Báo lỗi TypeError
    • True, vì Protocol không bắt kế thừa
  3. Những chú thích nào tả đúng tham số phu_phi là một hàm nhận một int và trả về int?

    • Callable[[int], int] với Callable lấy từ collections.abc
    • Callable[int, int]
    • typing.Callable[[int], int]
    • Callable[[int]]
  4. Với CachTra = Literal["tien_mat", "the"] như ví dụ đầu bài, lời gọi tinh_tien(96000, "chuyen_khoan") làm gì?

    • Báo lỗi ValueError vì giá trị không có trong Literal
    • Báo lỗi TypeError vì sai chú thích kiểu
    • Trả về 96000 như trả tiền mặt, không báo gì
Đúng hết lần đầu +15 XP

Bài tập

Viết hàm generic nhóm phần tử theo khóa

Báo cáo của chuỗi quán cần gom đơn theo chi nhánh, gom học viên theo chữ cái đầu. Viết nhom_theo(ds, lay_khoa) dạng hàm generic: khai tham số kiểu T trong ngoặc vuông ngay sau tên hàm (không dùng TypeVar), chú thích ds là list[T], lay_khoa là Callable[[T], str], và giá trị trả về là dict[str, list[T]]. Hàm gọi lay_khoa(x) cho từng phần tử, gom các phần tử cùng khóa vào một list theo thứ tự trong ds, các khóa xếp theo thứ tự gặp đầu tiên. Không sửa ds.

Ví dụ: nhom_theo(["Lan", "Minh", "Linh"], lambda ten: ten[0]) trả về {"L": ["Lan", "Linh"], "M": ["Minh"]}.

Trả về: các nhóm, một dict.

python
from collections.abc import Callable

def nhom_theo(ds, lay_khoa):
    pass  # Thêm type hints, rồi viết thân hàm thay cho dòng này

Tóm tắt

  • Literal[...] cho tham số chỉ nhận vài giá trị cố định, Any cho tham số nhận kiểu nào cũng được.

  • Callable[[int], int] tả một hàm nhận một int và trả về int, lấy Callable từ collections.abc.

  • def f[T](ds: list[T]) -> T là hàm generic: các chỗ T là cùng một kiểu ở mỗi lần gọi (Python 3.12 trở lên).

  • class HangCho[T] là class generic, code cũ viết T = TypeVar("T") và class HangCho(Generic[T]).

  • Protocol tả phương thức object phải có. Class hợp với nó mà không cần kế thừa.

  • Python không kiểm type hints khi chạy, còn isinstance() với Protocol cần @runtime_checkable.

Câu hỏi thường gặp

Python có tự kiểm type hints khi chạy chương trình không?

Không. Type hints chỉ là ghi chú: hàm chú thích list[int] vẫn nhận list chuỗi, như câu hỏi đầu của phần Kiểm tra nhanh. Công cụ soát kiểu như mypy đọc các chú thích và báo chỗ sai trước khi chạy; bài công cụ của thư viện chuẩn giới thiệu cách dùng.

Từ Python 3.12 còn cần khai TypeVar không?

Code mới không cần: def f[T](...) và class HangCho[T] tự khai T. Bạn vẫn gặp TypeVar và Generic[T] trong thư viện viết cho Python 3.11 trở về trước, và hai cách cho cùng một nghĩa. Dự án còn phải chạy trên bản cũ thì giữ cách TypeVar.

Nên dùng Protocol hay lớp trừu tượng trong Python?

Dùng lớp trừu tượng khi bạn viết cả các class con và muốn chúng kế thừa phần code chung. Dùng Protocol khi chỉ cần object có vài phương thức, kể cả object của thư viện người khác mà bạn không sửa được dòng class của nó.

Lập trình generics trong Python khác Java hay C# ở đâu?

Tham số kiểu của Python chỉ có ích cho người đọc và công cụ soát kiểu: lúc chạy, HangCho[str] và HangCho[int] là cùng một class và không chặn kiểu sai. Java và C# kiểm tham số kiểu khi biên dịch và báo lỗi ngay.

Chủ đề

typing python

Bài này có hữu ích?

Hỏi đáp

Đang tải câu hỏi…

Tham vấn chuyên môn

Nguyễn Việt Chung

Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE

  • Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
  • Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
  • Xây hệ thống AI cho doanh nghiệp tại VietPlatform.
Biên soạn: AIDev Team · Rà soát · Quy trình biên tập