Kế thừa, đa hình & lớp trừu tượng

ke_thua.py

class DongVat:
    def __init__(self, ten):
        self.ten = ten
    def keu(self):
        return "..."
    def gioi_thieu(self):
        return f"{self.ten} keu {self.keu()}"

class Cho(DongVat):
    def keu(self):                 # GHI DE (override)
        return "Gau gau"

class Meo(DongVat):
    def __init__(self, ten, mau):
        super().__init__(ten)      # goi __init__ cua cha, khoi chep
        self.mau = mau
    def keu(self):
        return "Meo meo"

print(Cho("Lu").gioi_thieu())      # Lu keu Gau gau
print(Meo("Mun", "den").gioi_thieu())

Lu keu Gau gau
Mun keu Meo meo

da_hinh.py

class HinhVuong:
    def __init__(self, c): self.c = c
    def dien_tich(self): return self.c * self.c

class HinhTron:
    def __init__(self, r): self.r = r
    def dien_tich(self): return 3.14159 * self.r ** 2

# Hai lop KHONG chung cha - chi can deu co .dien_tich()
hinh = [HinhVuong(2), HinhTron(3)]
print(sum(h.dien_tich() for h in hinh))   # goi dung phuong thuc cua tung loai

32.27431

mro.py - kim cuong

class A:
    def chao(self): return "A"
class B(A):
    def chao(self): return "B -> " + super().chao()
class C(A):
    def chao(self): return "C -> " + super().chao()
class D(B, C):
    pass

print(D().chao())                          # B -> C -> A
print([k.__name__ for k in D.__mro__])     # ['D', 'B', 'C', 'A', 'object']

B -> C -> A
['D', 'B', 'C', 'A', 'object']

abc_demo.py

from abc import ABC, abstractmethod

class Hinh(ABC):
    @abstractmethod
    def dien_tich(self): ...        # chi la "hop dong", khong cai dat

class Vuong(Hinh):
    def __init__(self, c): self.c = c
    def dien_tich(self): return self.c * self.c

print(Vuong(3).dien_tich())         # 9
# Hinh()  -> TypeError: Can't instantiate abstract class Hinh
# class Thieu(Hinh): pass; Thieu() -> cung loi vi chua cai dien_tich()

9

class_static.py

class Ngay:
    def __init__(self, d, m, y):
        self.d, self.m, self.y = d, m, y

    @classmethod
    def tu_chuoi(cls, s):              # constructor thay the; cls = chinh class
        d, m, y = map(int, s.split("/"))
        return cls(d, m, y)            # dung cls -> ke thua van dung dung lop con

    @staticmethod
    def la_nam_nhuan(y):              # khong self/cls - chi la tien ich
        return y % 4 == 0 and (y % 100 != 0 or y % 400 == 0)

ng = Ngay.tu_chuoi("2/9/1945")
print(ng.y, Ngay.la_nam_nhuan(2024), Ngay.la_nam_nhuan(1900))

1945 True False

dong_goi.py

class TaiKhoan:
    def __init__(self, so_du):
        self._chu = "an"          # _x: QUY UOC noi bo (Python khong chan)
        self.__so_du = so_du      # __x: doi ten -> _TaiKhoan__so_du

    @property
    def so_du(self):              # kiem soat truy cap qua property
        return self.__so_du

    def nap(self, tien):
        if tien <= 0: raise ValueError("phai > 0")
        self.__so_du += tien

t = TaiKhoan(100)
t.nap(50); print(t.so_du)         # 150
# t.__so_du            -> AttributeError (da bi doi ten)
print(t._TaiKhoan__so_du)         # 150  (van truy cap duoc -> khong phai bao mat)

150
150

enum_demo.py

from enum import Enum, auto

class TrangThai(Enum):
    CHO = auto()          # 1
    DANG_LAM = auto()     # 2
    XONG = auto()         # 3

print(TrangThai.XONG)                     # TrangThai.XONG
print(TrangThai.XONG.name, TrangThai.XONG.value)   # XONG 3

def mo_ta(t):
    if t is TrangThai.XONG:               # so sanh bang 'is' -> ro & an toan
        return "Hoan tat"
    return "Chua xong"

print(mo_ta(TrangThai.XONG))              # Hoan tat
# TrangThai.XONGG  -> AttributeError ngay (go sai bao loi luon)

TrangThai.XONG
XONG 3
Hoan tat