Kế thừa trong Python: Thực tiễn tốt nhất để tái sử dụng mã

Kiến thức cơ bản về kế thừa trong Python

Kế thừa là một trong những trụ cột nền tảng của lập trình hướng đối tượng (OOP) cho phép một lớp (gọi là lớp con) dẫn xuất các thuộc tính và phương thức từ một lớp khác (gọi là lớp cha). Tính năng này là trung tâm của tái sử dụng mã và đơn giản hóa bảo trì, giúp việc xây dựng chương trình có khả năng mở rộng và hiệu quả trở nên dễ dàng hơn.

Định nghĩa lớp cha và lớp con

Trước khi đi xa hơn, hãy khám phá mối quan hệ giữa lớp cha và lớp con.

Lớp cha

Hãy bắt đầu với lớp cha. Lớp cha là lớp cơ sở mà từ đó các lớp con kế thừa. Nó đóng gói các thuộc tính và phương thức dùng chung.

Trong Python, chúng ta định nghĩa lớp cha như sau:

class ParentClass:
    def __init__(self, attributes):
        # Initialize attributes
        pass

    def method(self):
        # Define behavior
        passĐược hỗ trợ bởi

Lớp con 

Một lớp con thừa hưởng các thuộc tính và phương thức từ lớp cha. Điều này cho phép nó sử dụng chức năng được định nghĩa trong lớp cha. Đoạn mã sau cho thấy cách một lớp con kế thừa thuộc tính và phương thức từ một lớp cha:

class ChildClass(ParentClass):
    def additional_method(self):
        # Define new behavior
        passĐược hỗ trợ bởi

Cú pháp đơn giản này cho phép lớp con sử dụng và mở rộng chức năng được định nghĩa trong lớp cha.

Tạo lớp cha và lớp con

Hãy tạo một ví dụ thực tế với lớp Person làm lớp cha và lớp Student làm lớp con.

Tạo lớp cha

Lớp Person chứa các thuộc tính dùng chung và một phương thức để hiển thị thông tin:    

# Defining the Parent Class
class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id
    def display_info(self):
        return f"Name: {self.name}, ID: {self.id}"Được hỗ trợ bởi

Tạo lớp con

Lớp Student kế thừa từ Person và bổ sung phương thức mới study.

# Defining the Child Class
class Student(Person):
    def study(self):
        return f"{self.name} is studying."Được hỗ trợ bởi

Hãy kiểm thử lớp cha và lớp con.

# Creating and Testing Instances
student = Student("Samuel", 102)
print(student.display_info())  
print(student.study())      Được hỗ trợ bởi

Name: Samuel, ID: 102
Samuel is studying.Được hỗ trợ bởi

Điều đang diễn ra là:

1. Lớp Student sử dụng phương thức __init__ từ Person để khởi tạo name và id.

2. Phương thức study là duy nhất của lớp Student, mở rộng chức năng của nó.

3. Phương thức display_info được kế thừa trực tiếp từ Person.

Các kiểu kế thừa trong Python

Kế thừa trong Python cho phép các lớp thừa hưởng thuộc tính và hành vi từ các lớp khác, thúc đẩy tái sử dụng mã và thiết kế gọn gàng như đã nói ở trên. Trong phần này, chúng ta sẽ bàn về các kiểu kế thừa trong Python, bao gồm kế thừa đơn, đa kế thừa, thứ bậc và lai, như những danh mục riêng.

Kế thừa đơn

Kế thừa đơn xảy ra khi một lớp con kế thừa từ một lớp cha duy nhất, cho phép nó mở rộng chức năng của lớp cha. Điều này hữu ích khi một kiểu đối tượng chia sẻ thuộc tính chung với một danh mục rộng hơn nhưng cũng cần thêm thuộc tính hoặc hành vi bổ sung.

Ví dụ tôi đã triển khai ở trên là kế thừa đơn, nhưng giờ hãy nhìn kỹ hơn một chút: Trong một hệ thống quản lý trường học, tất cả cá nhân, bao gồm học sinh, giáo viên và nhân viên, đều chia sẻ một số thông tin chung như name và ID. Tuy nhiên, học sinh còn có hồ sơ học tập như điểm số và các môn đăng ký. Sử dụng kế thừa đơn, chúng ta có thể tạo một lớp Person cho các thuộc tính dùng chung và mở rộng nó với lớp Student cho thông tin học tập.

Kế thừa đơn. Hình minh họa của Tác giả

Dưới đây là một ví dụ phù hợp cho kịch bản trên:

class Person:
    """Represents a general person with basic details."""
    def __init__(self, name, id):
        self.name = name
        self.id = id

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}"

class Student(Person):
    """Represents a student, extending the Person class to include academic details."""
    def __init__(self, name, id, grade, courses):
        super().__init__(name, id)
        self.grade = grade
        self.courses = courses

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}, Courses: {', '.join(self.courses)}"

# Example usage in a school system
student = Student("Samuel", 5678, "B+", ["Math", "Physics", "Computer Science"])
print(student.get_details())Được hỗ trợ bởi

Name: Samuel, ID: 5678, Grade: B+, Courses: Math, Physics, Computer ScienceĐược hỗ trợ bởi

Lớp Student kế thừa phương thức get_details() từ Person nhưng mở rộng để bao gồm grade và courses. Đây là một ví dụ điển hình cho thấy kế thừa đơn thúc đẩy cái gọi là mã mô-đun.

Đa kế thừa

Đa kế thừa, theo một cách nào đó giống cây phả hệ, cho phép một lớp con kế thừa từ nhiều lớp cha, kết hợp thuộc tính và hành vi từ mỗi lớp. Điều này có thể dẫn đến xung đột tiềm ẩn, mà Python giải quyết bằng thứ tự phân giải phương thức (MRO).

Đa kế thừa. Hình minh họa của Tác giả

Xem thử nhé:

class Person:
    def get_details(self):
        return "Details of a person."

class Athlete:
    def get_skill(self):
        return "Athletic skills."

class Student(Person, Athlete):
    pass

# Example usage
student = Student()
print(student.get_details())
print(student.get_skill())Được hỗ trợ bởi

Details of a person.
Athletic skills.Được hỗ trợ bởi

Ta thấy lớp Student kế thừa thuộc tính và phương thức từ cả Person và Athlete. Không cần nỗ lực bổ sung, lớp Student có quyền truy cập phương thức get_details()  từ lớp cha Person và phương thức get_skill() từ lớp cha Athlete. Chúng ta đang kết hợp hiệu quả chức năng từ nhiều nguồn.

Tuy nhiên, kế thừa từ nhiều lớp có thể dẫn tới xung đột. Điều gì xảy ra nếu cả hai lớp cha đều định nghĩa một phương thức hoặc thuộc tính cùng tên? Tôi đã đề cập tới thứ tự phân giải phương thức, giờ nói thêm chút. Thứ tự phân giải phương thức xác định thứ tự các lớp được tìm kiếm khi truy xuất phương thức và thuộc tính. MRO tuân theo cách tiếp cận ưu tiên chiều sâu, từ trái sang phải.

Bạn có thể xem MRO của một lớp bằng thuộc tính __mro__ hoặc phương thức mro():

print(Student.__mro__)Được hỗ trợ bởi

(<class '__main__.Student'>, <class '__main__.Person'>, <class '__main__.Athlete'>, <class 'object'>)Được hỗ trợ bởi

Kế thừa đa cấp, thứ bậc và lai

Python cũng hỗ trợ các cấu trúc kế thừa phức tạp hơn. Tôi sẽ minh họa các ý tưởng này bằng cùng một ví dụ.

Kế thừa đa cấp

Kế thừa đa cấp xảy ra khi một lớp con kế thừa từ một lớp con khác, và lớp con đó kế thừa từ một lớp cha. Điều này tạo thành một chuỗi kế thừa.

Kế thừa đa cấp. Hình minh họa của Tác giả

Một ví dụ hay như sau:

class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}"

class Student(Person):
    def __init__(self, name, id, grade):
        super().__init__(name, id)
        self.grade = grade

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}"

class GraduateStudent(Student):
    def __init__(self, name, id, grade, thesis_title):
        super().__init__(name, id, grade)
        self.thesis_title = thesis_title

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}, Thesis: {self.thesis_title}"

# Example usage
grad_student = GraduateStudent("Charlie", 91011, "A", "AI in Healthcare")
print(grad_student.get_details())Được hỗ trợ bởi

Name: Charlie, ID: 91011, Grade: A, Thesis: AI in HealthcareĐược hỗ trợ bởi

Ở đây, mỗi lớp trong chuỗi đều bổ sung điều gì đó mới: Person quản lý tên và ID, Student thêm điểm số, và GraduateStudent thêm luận văn. Nhờ super().__init__(), chúng ta tái sử dụng logic khởi tạo mà không lặp mã. Cách này hiệu quả, gọn gàng và đảm bảo mọi tầng trong “thang kế thừa”, theo cách tôi hình dung, đều hoạt động.

Kế thừa thứ bậc

Trong kế thừa thứ bậc, nhiều lớp con kế thừa từ một lớp cha duy nhất, cho phép chia sẻ hành vi giữa các lớp con với thuộc tính riêng.

Kế thừa thứ bậc. Hình minh họa của Tác giả

Hãy cùng xem một ví dụ rõ ràng:

class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}"

class Student(Person):
    def __init__(self, name, id, grade):
        super().__init__(name, id)
        self.grade = grade

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}"

class Teacher(Person):
    def __init__(self, name, id, subject):
        super().__init__(name, id)
        self.subject = subject

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Subject: {self.subject}"

# Example usage
student = Student("Samuel", 5678, "B+")
teacher = Teacher("Dr. Smith", 1234, "Math")
print(student.get_details())  
print(teacher.get_details())Được hỗ trợ bởi

Name: Samuel, ID: 5678, Grade: B+
Dr. Smith, ID: 1234, Subject: MathĐược hỗ trợ bởi

Ở đây, lớp Person đóng vai trò nền tảng, cung cấp thuộc tính và phương thức chung (name, id và get_details). Các lớp Student và Teacher sau đó mở rộng chức năng này bằng cách thêm thuộc tính riêng (grade và subject) và tùy biến phương thức get_details để phản ánh bối cảnh cụ thể của chúng.

Với cách tiếp cận này, chức năng dùng chung được giữ ở một nơi (lớp Person), trong khi hành vi chuyên biệt được gói gọn gàng trong các lớp con.

Kế thừa lai

Kế thừa lai kết hợp nhiều kiểu kế thừa, như đa cấp hoặc đa kế thừa, để mô hình hóa các mối quan hệ phức tạp hơn.

Kế thừa lai. Hình minh họa của Tác giả

Hãy xem một ví dụ thể hiện độ phức tạp của kế thừa lai.

# Base class
class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}"

# Intermediate class inheriting from the base class
class Employee(Person):
    def __init__(self, name, id, position):
        super().__init__(name, id)
        self.position = position

    def get_position(self):
        return f"Position: {self.position}"

# Another independent base class
class Athlete:
    def __init__(self, sport):
        self.sport = sport

    def get_sport(self):
        return f"Sport: {self.sport}"

# Derived class combining Employee and Athlete
class Student(Employee, Athlete):
    def __init__(self, name, id, position, grade, sport):
        Employee.__init__(self, name, id, position)
        Athlete.__init__(self, sport)
        self.grade = grade

    def get_grade(self):
        return f"Grade: {self.grade}"

# Example usage
student = Student("Samuel", 1234, "Intern", "A", "Soccer")
print(student.get_details())  # From Person
print(student.get_position())  # From Employee
print(student.get_grade())  # From Student
print(student.get_sport())  # From AthleteĐược hỗ trợ bởi

Name: Samuel, ID: 1234
Position: Intern
Grade: A
Sport: SoccerĐược hỗ trợ bởi

Trong ví dụ này, lớp Student thể hiện kế thừa lai bằng cách thừa hưởng thuộc tính và phương thức từ cả Employee (bản thân nó kế thừa từ Person) và Athlete. Đây là sự kết hợp giữa kế thừa thứ bậc (nơi Employee kế thừa từ Person) và đa kế thừa (nơi Student kế thừa từ cả Employee và Athlete).

Lợi ích của kế thừa trong Python

Giờ là lúc xem điểm mạnh và hạn chế: 

Lợi ích của kế thừa

1. Tái sử dụng: Với kế thừa, bạn có thể viết mã một lần trong lớp cha và tái sử dụng trong các lớp con. Trong ví dụ, cả FullTimeEmployee và Contractor đều có thể kế thừa phương thức get_details() từ lớp cha Employee.

2. Đơn giản: Kế thừa mô hình hóa mối quan hệ một cách rõ ràng. Ví dụ hay là lớp FullTimeEmployee “là một” kiểu của lớp cha Employee.

3. Khả năng mở rộng: Cũng dễ dàng thêm tính năng mới hoặc lớp con mới mà không ảnh hưởng tới mã hiện có. Ví dụ, ta có thể dễ dàng thêm lớp con Intern.

Hạn chế tiềm ẩn của kế thừa

1. Phức tạp: Điều này không gây ngạc nhiên, nhưng quá nhiều tầng kế thừa có thể khiến mã khó theo dõi. Ví dụ, nếu một Employee có quá nhiều lớp con như Manager, Engineer, Intern, v.v., nó có thể trở nên rối rắm.

2. Phụ thuộc: Thay đổi ở lớp cha có thể vô tình ảnh hưởng đến tất cả lớp con. Nếu bạn chỉnh sửa Employee chẳng hạn, có thể làm hỏng FullTimeEmployee hoặc Contractor.

3. Lạm dụng: Sử dụng kế thừa khi không phù hợp có thể làm phức tạp thiết kế. Bạn sẽ không muốn tạo giải pháp trong đó Car kế thừa từ Boat chỉ để tái sử dụng move(). Mối quan hệ như vậy không hợp lý.

Kỹ thuật kế thừa nâng cao trong Python

Sau khi đã khám phá những điều cơ bản về kế thừa, hãy xem một số kỹ thuật nâng cao. Những kỹ thuật như ghi đè phương thức, super(), lớp cơ sở trừu tượng và đa hình sẽ tăng tính linh hoạt và cho phép các mẫu thiết kế tinh vi hơn. 

Ghi đè phương thức trong Python

Ghi đè phương thức cho phép lớp con cung cấp hiện thực cụ thể cho một phương thức đã được định nghĩa trong lớp cha. Điều này hữu ích khi hành vi kế thừa không hoàn toàn đáp ứng yêu cầu của lớp con.

class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id
    
    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}"

class Student(Person):
    def __init__(self, name, id, grade):
        super().__init__(name, id)
        self.grade = grade
    
    # Overriding the get_details method
    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}"

# Example usage
student = Student("Samuel", 1234, "A")
print(student.get_details())Được hỗ trợ bởi

Name: Samuel, ID: 1234, Grade: AĐược hỗ trợ bởi

Tại đây, lớp Student ghi đè phương thức get_details() từ lớp Person để đưa ra hiện thực riêng. Điều này cho phép lớp con có hành vi riêng trong khi vẫn giữ cùng tên phương thức.

Vì sao chúng ta ghi đè? Chúng ta ghi đè để tùy biến hành vi được kế thừa và điều chỉnh chức năng của phương thức lớp cha cho phù hợp với yêu cầu riêng của lớp con.

Dùng super() để khởi tạo lớp cha

Hàm super() được dùng để gọi các phương thức trong lớp cha từ lớp con. Điều này đặc biệt hữu ích khi bạn muốn mở rộng hoặc chỉnh sửa chức năng của một phương thức lớp cha, chẳng hạn như phương thức khởi tạo __Init__().

Vì sao chúng ta dùng hàm super()? Chúng ta dùng super vì muốn gọi và khởi tạo hàm tạo của lớp cha và tránh phải gọi đích danh lớp cha. Điều này hữu ích, nhất là trong các trường hợp đa kế thừa.

class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id

class Student(Person):
    def __init__(self, name, id, grade):
        # Using super() to initialize the parent class
        super().__init__(name, id)
        self.grade = grade

# Example usage
student = Student("Samuel", 5678, "B+")
print(student.name)
print(student.id)
print(student.grade)Được hỗ trợ bởi

Samuel
5678
B+Được hỗ trợ bởi

Tại đây, lớp Student dùng super().__init__(name, id) để gọi phương thức __init__ của lớp cha Person, vì vậy không cần lặp mã để khởi tạo các thuộc tính name và id. Lớp con sau đó giới thiệu thuộc tính grade, đặc thù cho lớp Student.

Lớp cơ sở trừu tượng (ABC)

Lớp cơ sở trừu tượng (ABC) là lớp không thể dùng trực tiếp để tạo đối tượng. Nó dùng để định nghĩa một tập phương thức chung mà các lớp khác nên hiện thực. ABC hữu ích khi bạn muốn đảm bảo một số phương thức luôn có mặt trong các lớp con.

from abc import ABC, abstractmethod

class Person(ABC):
    @abstractmethod
    def get_details(self):
        pass

class Student(Person):
    def __init__(self, name, id, grade):
        self.name = name
        self.id = id
        self.grade = grade
    
    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}"

# Example usage
student = Student("Hamilton", 7890, "A-")
print(student.get_details())Được hỗ trợ bởi

Name: Hamilton, ID: 7890, Grade: A-Được hỗ trợ bởi

Lớp Person ở đây là lớp trừu tượng yêu cầu mọi lớp con phải hiện thực phương thức get_details(). Phương thức này được hiện thực sau đó bởi lớp con Student.

Đa hình

Đa hình nghĩa là nhiều hình thái. Trong Python, nó cho phép các lớp khác nhau dùng chung một tên phương thức, nhưng mỗi lớp có thể hiện thực phương thức đó theo cách khác nhau.

Đa hình giúp chúng ta viết mã có thể làm việc với các đối tượng thuộc những lớp khác nhau, ngay cả khi những lớp đó có hành vi khác nhau:

class Person:
    def get_details(self):
        return "Details of a person."

class Student(Person):
    def get_details(self):
        return "Details of a student."

class Teacher(Person):
    def get_details(self):
        return "Details of a teacher."

# Example usage
def print_details(person):
    print(person.get_details())

student = Student()
teacher = Teacher()

print_details(student) 
print_details(teacher) Được hỗ trợ bởi

Details of a student.
Details of a teacher.Được hỗ trợ bởi

Trong ví dụ này, hàm print_details() có thể nhận bất kỳ đối tượng nào thuộc kiểu Person, nhưng sẽ gọi phương thức get_details() thích hợp dựa trên việc đối tượng là Student hay Teacher.

Lỗi thường gặp và thực tiễn tốt nhất

Mặc dù kế thừa rất mạnh mẽ, nhưng cũng dễ bị lạm dụng. Tôi sẽ chia sẻ một số ý giúp bạn tận dụng tốt các khái niệm này.

Tránh bất ngờ với các phương thức bị ghi đè

Khi một lớp con ghi đè phương thức từ lớp cha, hành vi có thể thay đổi.

Ví dụ, nếu lớp cha Employee có phương thức calculate_pay(), và lớp con Manager ghi đè nó mà không xét mọi kịch bản, có thể sẽ tính lương sai.

Thực tiễn tốt nhất trong trường hợp này là luôn kiểm thử kỹ các phương thức bị ghi đè và ghi chú rõ hành vi của chúng.

Chọn giữa kế thừa và hợp thành

Tôi biết bài viết này nói về kế thừa, nhưng không phải lúc nào cũng là cách tiếp cận đúng. Đôi khi, hợp thành (composition), nơi bạn xây dựng lớp bằng cách kết hợp các đối tượng thay vì mở rộng chúng, sẽ phù hợp hơn với công việc bạn đang làm.

Để chưng cất khác biệt theo cách cơ bản nhất, hãy nghĩ rằng:

• Kế thừa liên quan đến mối quan hệ “là một”. Ví dụ, một Manager là một Employee.

• Hợp thành liên quan đến mối quan hệ “có một”. Ví dụ, một Car có một Engine.

Vậy làm sao biết khi nào hợp thành là cách tiếp cận tốt nhất? Hãy dùng hợp thành khi mối quan hệ không hoàn toàn theo thứ bậc và/hoặc khi bạn muốn giảm sự phụ thuộc chặt chẽ giữa các lớp.

Hoặc, ta cũng có thể nói rằng, trong khi kế thừa mô hình hóa mối quan hệ, hợp thành tập trung vào chức năng. Để dễ hình dung, hãy cân nhắc điều này:

• Dùng kế thừa khi các đối tượng có phân cấp tự nhiên. Ví dụ, Animal > Bird > Parrot.

• Dùng hợp thành khi các đối tượng chia sẻ chức năng nhưng không liên quan. Ví dụ, một Printer và Scanner đều dùng DeviceManager.

Tránh chuỗi kế thừa quá sâu

Chuỗi kế thừa sâu (nhiều tầng quan hệ cha–con) có thể khiến mã khó đọc và bảo trì. Đây là vấn đề vì thay đổi ở lớp cha có thể vô tình ảnh hưởng tới nhiều lớp con. Ngoài ra, gỡ lỗi trở nên phức tạp do hành vi bị phân tán qua nhiều tầng.

Thực tiễn tốt nhất trong trường hợp này là giữ hệ phân cấp nông. Ngoài ra, hãy cân nhắc dùng hợp thành (như đã đề cập) hoặc tách chuỗi thành các hệ phân cấp riêng nếu thấy nó trở nên quá sâu.

Kết luận

Kế thừa là một trụ cột lớn của lập trình hướng đối tượng, giúp các nhà phát triển như bạn tạo ra mã tái sử dụng, mô-đun và có khả năng mở rộng. Nếu làm chủ được kế thừa, bạn sẽ dễ dàng đơn giản hóa các hệ thống phức tạp.

Một cách hay để đào sâu hiểu biết là thử xây dựng các cấu trúc kế thừa trong dự án của bạn. Bắt đầu đơn giản, rồi thử nghiệm với những hệ phân cấp phức tạp hơn để xem chúng vận hành thế nào trong thực tế.

Nếu bạn muốn khám phá sâu hơn nữa, bạn có thể xem khóa học Programming Paradigm Concepts để hiểu rõ hơn về kế thừa và các ý tưởng khác. Lộ trình nghề nghiệp Python Developer của chúng tôi cũng là một nguồn tài nguyên tốt, cung cấp lộ trình toàn diện để phát triển kỹ năng lập trình nâng cao, trang bị cho bạn cho công việc phát triển phần mềm.