Kế thừa trong Python: lớp con, super(), ghi đè và MRO

Một lớp được xây dựng trên lớp khác

Kế thừa (inheritance) cho phép bạn định nghĩa một lớp mới như một bản mở rộng của lớp có sẵn. Lớp có sẵn là lớp cha (còn gọi là lớp cơ sở hay superclass), còn lớp mới là lớp con (subclass). Lớp con nhận mọi phương thức và thuộc tính lớp của lớp cha mà không phải viết lại, và có thể thêm cái riêng hoặc thay thế những cái cần hoạt động khác đi.

Bạn khai báo lớp cha trong ngoặc tròn sau tên lớp:

class Animal:
    def __init__(self, name):
        self.name = name

    def describe(self):
        return f"{self.name} is an animal"

    def speak(self):
        return "..."

class Dog(Animal):
    def speak(self):
        return "Woof"

rex = Dog("Rex")
print(rex.describe())   # inherited from Animal
print(rex.speak())      # defined in Dog

Đầu ra:

Rex is an animal
Woof

Dog không có __init__ và cũng không có describe riêng. Khi bạn gọi Dog("Rex"), Python tìm __init__ trên Dog, không thấy, nên dùng cái trên Animal. Việc tìm kiếm tương tự diễn ra với rex.describe(). Với rex.speak(), Python tìm thấy speak trên Dog trước và dừng ở đó.

Thứ tự tìm kiếm đó chính là toàn bộ cơ chế: Python tìm trong lớp của chính đối tượng, rồi đến lớp cha, rồi lớp cha của lớp cha, và dùng kết quả khớp đầu tiên. Nếu bạn mới làm quen với lớp, trang về lớp giới thiệu __init__, self và phương thức trước.

Ghi đè một phương thức

Một phương thức trong lớp con trùng tên với phương thức của lớp cha sẽ thay thế nó đối với các instance của lớp con. Đây gọi là ghi đè (overriding). Mỗi lớp con có thể trả lời cùng một lời gọi theo cách riêng:

class Shape:
    def area(self):
        return 0

    def summary(self):
        return f"{type(self).__name__} with area {self.area()}"

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)

shapes = [Rectangle(3, 4), Square(5), Shape()]
for shape in shapes:
    print(shape.summary())

Đầu ra:

Rectangle with area 12
Square with area 25
Shape with area 0

summary chỉ được định nghĩa một lần, trên Shape, nhưng nó gọi self.area(). Vì self là đối tượng thực tế, một Rectangle sẽ chạy Rectangle.area, còn một Square tìm thấy area trên lớp cha Rectangle của nó. Code của lớp cha gọi phương thức của lớp con mà không cần biết lớp con tồn tại. Đây là điều khiến kế thừa hữu ích để chia sẻ một quy trình chung trong khi để mỗi lớp con tự điền các chi tiết.

Gọi lớp cha với super()

Khi lớp con định nghĩa __init__ riêng, __init__ của lớp cha không còn tự chạy nữa. Nếu lớp con vẫn cần phần thiết lập của lớp cha, hãy gọi nó bằng super().__init__():

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount

class SavingsAccount(Account):
    def __init__(self, owner, balance=0, rate=0.02):
        super().__init__(owner, balance)   # let Account set owner and balance
        self.rate = rate                   # then add what is new

    def add_interest(self):
        self.deposit(self.balance * self.rate)

acct = SavingsAccount("Ada", 1000, rate=0.05)
acct.add_interest()
print(acct.owner, acct.balance)

Đầu ra:

Ada 1050.0

super() trả về một đối tượng tìm kiếm phương thức bắt đầu từ lớp cha của lớp hiện tại. Vì vậy super().__init__(owner, balance) chạy Account.__init__ trên cùng đối tượng đó, và sau đó self.owner cùng self.balance đều tồn tại.

Bỏ dòng đó đi thì đối tượng chỉ được dựng một nửa:

class Account:
    def __init__(self, owner):
        self.owner = owner

class SavingsAccount(Account):
    def __init__(self, owner, rate):
        self.rate = rate   # forgot super().__init__(owner)

acct = SavingsAccount("Ada", 0.05)
print(acct.rate)

try:
    print(acct.owner)
except AttributeError as err:
    print("AttributeError:", err)

Đầu ra:

0.05
AttributeError: 'SavingsAccount' object has no attribute 'owner'

Bạn có thể viết Account.__init__(self, owner) thay thế, và code cũ thường làm vậy. super() được ưu tiên hơn vì nó không lặp lại tên lớp cha và phối hợp đúng với đa kế thừa, sẽ được nói ở phần dưới.

Mở rộng phương thức thay vì thay thế

super() dùng được trong bất kỳ phương thức nào, không chỉ __init__. Gọi phiên bản của lớp cha bên trong phương thức ghi đè giúp bạn bổ sung hành vi xung quanh nó thay vì viết lại từ đầu:

class Logger:
    def format(self, message):
        return message

    def log(self, message):
        print(self.format(message))

class TimestampLogger(Logger):
    def format(self, message):
        base = super().format(message)
        return f"[12:00] {base}"

class LevelLogger(TimestampLogger):
    def format(self, message):
        return "INFO " + super().format(message)

Logger().log("started")
TimestampLogger().log("started")
LevelLogger().log("started")

Đầu ra:

started
[12:00] started
INFO [12:00] started

Mỗi cấp thêm một phần và chuyển phần còn lại lên trên. Nếu sau này format của lớp cha thay đổi, cả hai lớp con đều nhận được thay đổi đó.

isinstance và issubclass

Một instance của lớp con cũng là instance của mọi lớp phía trên nó. isinstance(obj, cls) kiểm tra quan hệ đó, còn issubclass(child, parent) kiểm tra quan hệ giữa hai lớp:

class Animal:
    pass

class Dog(Animal):
    pass

class Cat(Animal):
    pass

rex = Dog()

print(isinstance(rex, Dog))       # True
print(isinstance(rex, Animal))    # True: a Dog is an Animal
print(isinstance(rex, Cat))       # False
print(isinstance(rex, (Cat, Dog)))  # True: matches any class in the tuple

print(issubclass(Dog, Animal))    # True
print(issubclass(Animal, Dog))    # False
print(issubclass(Dog, Dog))       # True: a class counts as its own subclass

print(type(rex) is Animal)        # False: type() ignores inheritance

Hãy ưu tiên isinstance thay vì so sánh trực tiếp type(obj). Một phép kiểm tra như type(obj) is Animal sẽ loại bỏ mọi lớp con, và hỏng ngay khi có người thêm Dog.

Mọi lớp bạn viết đều kế thừa từ object, kể cả khi bạn không ghi ra. class Animal: giống hệt class Animal(object):. Đó là nơi các phương thức mặc định như __str__, __repr__ và __eq__ đến từ, và là lý do việc ghi đè __str__ làm thay đổi những gì print() hiển thị:

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

    def __str__(self):
        return f"({self.x}, {self.y})"

print(Point(2, 3))
print(issubclass(Point, object))

Đầu ra:

(2, 3)
True

Bắt buộc lớp con cài đặt một phương thức

Đôi khi lớp cha không bao giờ nên được dùng trực tiếp, mà chỉ làm khuôn mẫu. Module abc đánh dấu một lớp như vậy là lớp trừu tượng. Mọi phương thức có decorator @abstractmethod phải được ghi đè thì lớp mới tạo được instance:

from abc import ABC, abstractmethod

class Exporter(ABC):
    @abstractmethod
    def export(self, rows):
        ...

    def run(self, rows):
        print(f"exporting {len(rows)} rows")
        return self.export(rows)

class CsvExporter(Exporter):
    def export(self, rows):
        return "\n".join(",".join(map(str, row)) for row in rows)

print(CsvExporter().run([[1, 2], [3, 4]]))

try:
    Exporter()
except TypeError as err:
    print("TypeError:", err)

Ba dòng đầu tiên của đầu ra là kết quả xuất:

exporting 2 rows
1,2
3,4

Dòng cuối cùng là một TypeError nêu tên Exporter và phương thức export còn thiếu của nó (câu chữ chính xác khác nhau giữa các phiên bản Python). Lỗi lộ ra ngay khi tạo đối tượng, chứ không phải đợi đến khi export cuối cùng được gọi.

Đa kế thừa và MRO

Một lớp có thể liệt kê nhiều hơn một lớp cha. Khi đó nó kế thừa từ tất cả:

class Swimmer:
    def move(self):
        return "swims"

    def swim(self):
        return "paddling"

class Flyer:
    def move(self):
        return "flies"

    def fly(self):
        return "flapping"

class Duck(Swimmer, Flyer):
    pass

d = Duck()
print(d.swim(), d.fly())
print(d.move())
print([cls.__name__ for cls in Duck.__mro__])

Đầu ra:

paddling flapping
swims
['Duck', 'Swimmer', 'Flyer', 'object']

Cả hai lớp cha đều định nghĩa move, và Duck nhận cái của Swimmer. Python quyết định dựa vào thứ tự phân giải phương thức (MRO): một danh sách các lớp duy nhất, lưu trong Duck.__mro__, mà mọi lần tìm thuộc tính đều duyệt từ đầu đến cuối. Danh sách bắt đầu bằng chính lớp đó, giữ các lớp cha theo thứ tự bạn đã liệt kê, đặt mỗi lớp trước các lớp cha của nó, và kết thúc bằng object. Đổi thứ tự thành class Duck(Flyer, Swimmer) thì move trả về "flies".

super() đi theo cùng danh sách đó. Bên trong một phương thức của Swimmer, super() nghĩa là "lớp kế tiếp sau Swimmer trong MRO của lớp đối tượng", mà với một Duck thì đó là Flyer, không phải object. Đó là cách các lớp phối hợp với nhau: mỗi lớp đều gọi super() và mọi lớp trong chuỗi chạy đúng một lần, kể cả trong hình kim cương, khi hai lớp cha có chung một lớp ông.

Trong thực tế, đa kế thừa chủ yếu được dùng cho mixin: những lớp nhỏ bổ sung một khả năng, như JsonMixin thêm phương thức to_json, kết hợp với một lớp cha chính. Các hệ phân cấp sâu với nhiều lớp cha đầy đủ rất khó theo dõi và hiếm khi cần đến.

Kế thừa hay composition?

Kế thừa mô tả quan hệ "là một". Một SavingsAccount là một Account: mọi code làm việc với Account đều phải chạy được với nó mà không cần sửa. Khi câu đó nghe không ổn, có lẽ bạn cần composition, mô tả quan hệ "có một": đối tượng giữ một đối tượng khác làm thuộc tính và gọi đến nó.

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

    def start(self):
        return f"{self.horsepower} hp engine running"

class Car:
    def __init__(self, model, engine):
        self.model = model
        self.engine = engine   # a Car has an Engine

    def start(self):
        return f"{self.model}: {self.engine.start()}"

car = Car("Roadster", Engine(300))
print(car.start())

Đầu ra:

Roadster: 300 hp engine running

class Car(Engine) cũng chạy được, nhưng như vậy là khẳng định xe hơi là một loại động cơ, cho Car mọi phương thức của động cơ, và khiến bạn không thể thay một động cơ khác mà không tạo lớp khác. Với composition, các bộ phận vẫn tách biệt, và thay động cơ chỉ là chuyện truyền vào một đối tượng khác.

Vài dấu hiệu cho thấy kế thừa là công cụ sai:

• Lớp con ghi đè hầu hết phương thức của lớp cha, hoặc vô hiệu hóa một số phương thức.
• Bạn kế thừa chỉ để dùng lại một hai phương thức trợ giúp.
• Hệ phân cấp vượt quá hai ba cấp và bạn phải đọc nhiều tệp mới biết một phương thức làm gì.

Những lỗi thường gặp

• Quên super().__init__(). __init__ của lớp con thay thế __init__ của lớp cha, nên các thuộc tính của lớp cha không bao giờ được đặt và về sau bạn gặp AttributeError.
• Truyền self vào lời gọi super(). Viết super().__init__(name), đừng viết super().__init__(self, name). super() đã gắn phương thức với đối tượng hiện tại rồi.
• Chữ ký không khớp khi ghi đè. Nếu speak(self) của lớp cha được code dùng chung gọi đến, một speak(self, volume) ở lớp con với đối số bắt buộc thêm vào sẽ làm hỏng code đó. Giữ phương thức ghi đè tương thích, hoặc cho tham số mới giá trị mặc định.
• Kiểm tra type(obj) == SomeClass. Cách này bỏ qua lớp con. Hãy dùng isinstance.
• Dùng kế thừa để chia sẻ code giữa các lớp không liên quan. Hãy chuyển phần code dùng chung vào một hàm hoặc một đối tượng trợ giúp.