Python Vererbung: Best Practices für wiederverwendbaren Code

Grundlagen der Vererbung in Python

Die Vererbung ist eine der grundlegenden Säulen der objektorientierten Programmierung (OOP), die es einer Klasse (der sogenannten Kindklasse) ermöglicht , Attribute und Methoden von einer anderen Klasse (der sogenannten Elternklasse) abzuleiten . Diese Funktion ist von zentraler Bedeutung für die Wiederverwendung von Code und vereinfacht die Wartung, wodurch es einfacher wird, skalierbare und effiziente Programme zu erstellen.

Definieren von Eltern- und Kind-Klassen

Bevor wir weitergehen, wollen wir die Beziehung zwischen Eltern- und Kind-Klassen untersuchen.

Übergeordnete Klasse

Beginnen wir mit der Elternklasse. Eine übergeordnete Klasse ist die Basisklasse, von der sich untergeordnete Klassen ableiten. Sie kapselt gemeinsame Attribute und Methoden.

In Python definieren wir eine übergeordnete Klasse folgendermaßen:

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

    def method(self):
        # Define behavior
        pass

Klasse Kind 

Eine Kindklasse erbt Attribute und Methoden von der Elternklasse. Dadurch kann sie die in der übergeordneten Klasse definierten Funktionen nutzen. Der folgende Code zeigt, wie eine Kindklasse Attribute und Methoden von einer Elternklasse erbt:

class ChildClass(ParentClass):
    def additional_method(self):
        # Define new behavior
        pass

Diese einfache Syntax ermöglicht es der Kindklasse, die in der Elternklasse definierten Funktionen zu nutzen und zu erweitern.

Erstellen einer übergeordneten Klasse und einer untergeordneten Klasse

Lass uns ein praktisches Beispiel mit einer Person Klasse als Elternteil und einer Student Klasse als Kind erstellen.

Erstellen der übergeordneten Klasse

Die Klasse Person enthält gemeinsame Attribute und eine Methode zur Anzeige von Informationen:    

# 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}"

Erstellen der untergeordneten Klasse

Die Klasse Student erbt von Person und fügt eine neue Methode study hinzu.

# Defining the Child Class
class Student(Person):
    def study(self):
        return f"{self.name} is studying."

Lass uns die Eltern- und Kind-Klassen testen.

# Creating and Testing Instances
student = Student("Samuel", 102)
print(student.display_info())  
print(student.study())      

Name: Samuel, ID: 102
Samuel is studying.

Hier ist, was passiert ist:

1. Die Klasse Student verwendet die Methode __init__ von Person, um name und id zu initialisieren.

2. Die Methode study ist einzigartig in der Klasse Student und erweitert deren Funktionalität.

3. Die Methode display_info wird direkt von Person geerbt.

Arten der Vererbung in Python

Die Vererbung in Python ermöglicht es Klassen, Attribute und Verhaltensweisen von anderen Klassen zu erben, was die Wiederverwendung von Code und ein sauberes Design fördert, wie wir bereits erwähnt haben. In diesem Abschnitt können wir über die verschiedenen Arten der Python-Vererbung sprechen, zu denen die einfache, die mehrfache, die hierarchische und die hybride Vererbung als eigene Kategorien gehören.

Einzelvererbung

Einfachvererbung liegt vor, wenn eine Kindklasse von einer einzigen Elternklasse erbt und damit die Funktionalität der Elternklasse erweitert. Dies ist nützlich, wenn ein Objekttyp gemeinsame Eigenschaften mit einer breiteren Kategorie hat, aber auch zusätzliche Attribute oder Verhaltensweisen benötigt.

Das Beispiel, das ich vorhin durchgearbeitet habe, war einfache Vererbung, aber schauen wir uns das jetzt etwas genauer an: In einem Schulverwaltungssystem teilen alle Personen, einschließlich Schüler/innen, Lehrer/innen und Mitarbeiter/innen, einige gemeinsame Details wie name und ID. Allerdings haben die Schüler/innen auch akademische Aufzeichnungen wie Noten und eingeschriebene Kurse. Mithilfe der Einfachvererbung können wir eine Klasse Person für gemeinsame Attribute erstellen und diese um eine KlasseStudent für akademische Details erweitern .

Einzelvererbung. Bild vom Autor

Hier ist ein gutes Beispiel für das oben beschriebene Szenario:

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())

Name: Samuel, ID: 5678, Grade: B+, Courses: Math, Physics, Computer Science

Die Klasse Student erbt die Methode get_details() von Person, erweitert sie aber um die Methoden grade und courses. Dies ist ein gutes Beispiel dafür, wie Einfachvererbung den so genannten modularen Code fördert.

Mehrfachvererbung

Die Mehrfachvererbung ermöglicht es einer Kindklasse, von mehr als einer Elternklasse zu erben und die Attribute und Verhaltensweisen der einzelnen Klassen zu kombinieren. Dies kann zu potenziellen Konflikten führen, die Python mit Hilfe der Method Resolution Order (MRO) auflöst.

Mehrfachvererbung. Bild vom Autor

Sieh es dir an:

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())

Details of a person.
Athletic skills.

Wir sehen, dass die Klasse Student Attribute und Methoden sowohl von Person als auch von Athlete geerbt hat. Ohne zusätzlichen Aufwand hat die Klasse Student Zugriff auf die Methode get_details() der Elternklasse Person und die Methode get_skill() der Elternklasse Athlete. Wir kombinieren effektiv Funktionen aus verschiedenen Quellen.

Das Erben von mehreren Klassen kann jedoch zu Konflikten führen. Was ist, wenn beide Elternklassen eine Methode oder ein Attribut mit demselben Namen definieren? Ich habe vorhin schon etwas über die Reihenfolge der Methodenauflösung gesagt, aber lass mich noch ein bisschen mehr dazu sagen. Reihenfolge der Methodenauflösung bestimmt die Reihenfolge, in der die Klassen nach Methoden und Attributen durchsucht werden. Die MRO verfolgt einen Ansatz, der von der Tiefe ausgeht und von links nach rechts verläuft.

Du kannst die MRO einer Klasse mit dem Attribut __mro__ oder der Methode mro() anzeigen:

print(Student.__mro__)

(<class '__main__.Student'>, <class '__main__.Person'>, <class '__main__.Athlete'>, <class 'object'>)

Mehrstufige, hierarchische und hybride Vererbung

Python unterstützt auch komplexere Vererbungsstrukturen. Ich werde diese komplexeren Ideen anhand desselben Beispiels zeigen.

Mehrstufige Vererbung

Mehrstufige Vererbung liegt vor, wenn eine Kindklasse von einer anderen Kindklasse erbt und diese wiederum von einer Elternklasse. So entsteht eine Kette der Vererbung.

Mehrstufige Vererbung. Bild vom Autor

Hier ist ein gutes Beispiel:

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())

Name: Charlie, ID: 91011, Grade: A, Thesis: AI in Healthcare

Hier fügt jede Klasse in der Kette etwas Neues hinzu: Person verwaltet Namen und IDs, Student enthält Noten, und GraduateStudent führt eine These ein. Dank super().__init__() können wir die Initialisierungslogik wiederverwenden, ohne Code zu duplizieren. Es ist effizient, übersichtlich und stellt sicher, dass jede Stufe der "Vererbungsleiter", wie ich sie mir vorstelle, funktioniert.

Hierarchische Vererbung

Bei der hierarchischen Vererbung erben mehrere untergeordnete Klassen von einer einzigen übergeordneten Klasse und ermöglichen so ein gemeinsames Verhalten von Unterklassen mit einzigartigen Attributen.

Hierarchische Vererbung. Bild vom Autor

Schauen wir uns gemeinsam ein gutes Beispiel an:

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())

Name: Samuel, ID: 5678, Grade: B+
Dr. Smith, ID: 1234, Subject: Math

Hier dient die Klasse Person als Grundlage und bietet gemeinsame Attribute und Methoden (name, id und get_details). Die Klassen Student und Teacher erweitern diese Funktionalität, indem sie ihre eigenen Eigenschaften (grade und subject) hinzufügen und die Methode get_details anpassen, um ihre spezifischen Kontexte zu berücksichtigen.

Bei diesem Ansatz bleibt die gemeinsame Funktionalität an einem Ort (der Klasse Person ), während das spezielle Verhalten in den Unterklassen gekapselt wird.

Hybride Vererbung

Die hybride Vererbung kombiniert mehrere Vererbungsarten, wie z. B. die mehrstufige oder mehrfache Vererbung, um komplexere Beziehungen zu modellieren.

Hybride Vererbung. Bild vom Autor

Schauen wir uns ein Beispiel an, das die Komplexität der hybriden Vererbung zeigt.

# 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

Name: Samuel, ID: 1234
Position: Intern
Grade: A
Sport: Soccer

In diesem Beispiel demonstriert die Klasse Student die hybride Vererbung, indem sie Attribute und Methoden sowohl von Employee (die wiederum von Person erbt) als auch von Athlete erbt. Dies kombiniert hierarchische Vererbung ( Employee erbt von Person) und Mehrfachvererbung ( Student erbt sowohl von Employee als auch von Athlete ).

Vorteile der Vererbung in Python

Jetzt ist es an der Zeit, die Stärken und Schwächen zu erkennen: 

Vorteile der Vererbung

1. Wiederverwendbarkeit: Mit Vererbung kannst du Code einmal in der Elternklasse schreiben und ihn in den Kindklassen wiederverwenden. In diesem Beispiel können sowohl FullTimeEmployee als auch Contractor eine Methode get_details() von der Elternklasse Employee erben.

2. Einfachheit: Vererbung modelliert Beziehungen eindeutig. Ein gutes Beispiel ist die Klasse FullTimeEmployee, die ein Typ der Elternklasse Employee ist.

3. Skalierbarkeit: Außerdem können neue Funktionen oder Unterklassen hinzugefügt werden, ohne den bestehenden Code zu verändern. Wir können zum Beispiel ganz einfach eine neue Klasse Intern als Kindklasse hinzufügen.

Mögliche Grenzen der Vererbung

1. Komplexität: Das wird dich nicht überraschen, aber zu viele Ebenen der Vererbung können den Code schwer verständlich machen. Wenn zum Beispiel eine Employee zu viele untergeordnete Klassen wie Manager, Engineer, Intern, usw. hat, kann sie verwirrend werden.

2. Abhängigkeit: Änderungen an einer übergeordneten Klasse können sich ungewollt auf alle Unterklassen auswirken. Wenn du zum Beispiel Employee änderst, könnte das FullTimeEmployee oder Contractor kaputt machen.

3. Missbrauch: Die Verwendung von Vererbung, wenn sie nicht die beste Lösung ist, kann Entwürfe verkomplizieren. Du würdest keine Lösung erstellen wollen, bei der Car von Boat erbt, nur um move() wiederzuverwenden. Die Beziehung macht keinen Sinn.

Fortgeschrittene Vererbungstechniken in Python

Nachdem wir nun die Grundlagen der Vererbung kennengelernt haben, wollen wir uns nun einige fortgeschrittene Techniken ansehen. Diese Techniken, wie z. B. Methodenüberschreibung, super(), abstrakte Basisklassen und Polymorphismus, erhöhen die Flexibilität des Codes und ermöglichen anspruchsvollere Entwurfsmuster. 

Überschreibende Methoden in Python

Das Überschreiben von Methoden ermöglicht es einer Kindklasse, eine spezifische Implementierung für eine Methode bereitzustellen, die bereits in ihrer Elternklasse definiert ist. Dies ist nützlich, wenn das geerbte Verhalten die Anforderungen der Kindklasse nicht vollständig erfüllt.

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())

Name: Samuel, ID: 1234, Grade: A

Hier überschreibt die Klasse Student die Methode get_details() der Klasse Person, um ihre eigenen spezifischen Implementierungen zu erhalten. So kann die Kindklasse ihr eigenes Verhalten haben und trotzdem denselben Methodennamen verwenden.

Warum setzen wir uns also außer Kraft? Wir überschreiben, weil wirdas geerbte Verhalten anpassen wollen und auch, weil wir die Funktionalität einer Elternmethode an die besonderen Anforderungen einer Kindklasseanpassen wollen .

Verwendung von super() für die Initialisierung der Eltern

Die Funktion super() wird verwendet, um Methoden der Elternklasse von der Kindklasse aus aufzurufen. Dies ist besonders nützlich, wenn du die Funktionalität einer übergeordneten Klassenmethode erweitern oder ändern möchtest, wie z. B. die __Init__() Konstruktormethode.

Warum verwenden wir also die Funktion super()? Wir verwenden die Superfunktion, weil wir den Konstruktor der Elternklasse aufrufen und initialisieren wollenund weil wir vermeiden wollen, die Elternklasse explizit zu nennen. Das ist vor allem in Fällen von Mehrfachvererbung hilfreich.

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)

Samuel
5678
B+

Hier verwendet die Klasse Student super().__init__(name, id) , um die Methode __init__ der Elternklasse Person aufzurufen, so dass sie den Code zur Initialisierung der Attribute name und id nicht wiederholen muss. Die Kindklasse führt dann ein grade Attribut ein, das spezifisch für die Klasse Student ist.

Abstrakte Basisklassen (ABCs)

Eine abstrakte Basisklasse (ABC) ist eine Klasse, die nicht direkt zur Erstellung von Objekten verwendet werden kann. Sie dient dazu, eine gemeinsame Reihe von Methoden zu definieren, die andere Klassen implementieren sollten. ABCs sind also nützlich, wenn du sicherstellen willst, dass bestimmte Methoden immer in den Kindklassen vorhanden sind.

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())

Name: Hamilton, ID: 7890, Grade: A-

Die Klasse Person ist eine abstrakte Klasse, die von jeder untergeordneten Klasse verlangt, dass sie die Methode get_details() implementiert. Diese Methode wird später von der Kindklasse Student implementiert.

Polymorphismus

Polymorphismus bedeutet viele Formen. In Python können verschiedene Klassen denselben Methodennamen verwenden, aber jede kann diese Methode auf eine andere Weise implementieren.

Polymorphismus hilft uns, Code zu schreiben, der mit Objekten verschiedener Klassen arbeiten kann, auch wenn diese Klassen unterschiedliche Verhaltensweisen haben:

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) 

Details of a student.
Details of a teacher.

In diesem Beispiel kann die Funktion print_details() ein beliebiges Objekt vom Typ Person annehmen, ruft aber die entsprechende Methode get_details() auf, je nachdem, ob das Objekt ein Student oder ein Teacher ist.

Häufige Fehler und bewährte Praktiken

Vererbung ist zwar mächtig, kann aber auch leicht missbraucht werden. Ich werde einige Ideen teilen, die dir helfen, das Beste aus den Ideen zu machen.

Vermeiden von Überraschungen mit überschriebenen Methoden

Wenn eine Kindklasse eine Methode der Elternklasse überschreibt, kann sich das Verhalten ändern.

Wenn zum Beispiel die übergeordnete Klasse Employee eine Methode calculate_pay() hat und die untergeordnete Klasse Manager diese überschreibt, ohne alle Szenarien zu berücksichtigen, kann dies zu falschen Lohnberechnungen führen.

Die beste Praxis ist in diesem Fall, überschriebene Methoden immer gründlich zu testen und ihr Verhalten zu dokumentieren.

Die Wahl zwischen Vererbung und Komposition

Ich weiß, dass es in diesem Artikel um Vererbung geht, aber das ist nicht immer der richtige Ansatz. Manchmal ist die Komposition, bei der du Klassen durch das Kombinieren von Objekten erstellst, anstatt sie zu erweitern, besser für deine Arbeit geeignet.

Um die Unterschiede auf die einfachste Weise zu verdeutlichen, denke daran, dass:

• Vererbung bezieht sich auf "Is-a"-Beziehungen. Eine Manager ist zum Beispiel eine Employee.

• Die Zusammensetzung bezieht sich auf "Has-a"-Beziehungen. Eine Car hat zum Beispiel eine Engine.

Woher weißt du also, wann Komposition der beste Ansatz ist? Verwende die Komposition w wenndie Beziehung nicht streng hierarchisch ist und/oder wenn dudie enge Kopplung zwischen Klassen reduzierenwillst.

Oder wir könnten auch sagen, dass die Vererbung Beziehungen modelliert, während die Komposition sich auf die Funktionalität konzentriert. Um dir dabei zu helfen, bedenke Folgendes:

• Verwende Vererbung, wenn Objekte von Natur aus hierarchisch sind. Zum Beispiel: Animal > Bird > Parrot.

• Verwende die Komposition, wenn Objekte die gleiche Funktionalität haben, aber nicht miteinander verbunden sind. Zum Beispiel verwenden Printer und Scanner beide ein DeviceManager.

Vermeide tiefe Vererbungsketten

Tiefe Vererbungsketten (viele Ebenen von Eltern-Kind-Beziehungen) können deinen Code schwer lesbar und wartbar machen. Das ist ein Problem, dennänderungen an einer übergeordneten Klasse können sich ungewollt auf viele untergeordnete Klassen auswirken. Außerdemwird dieebugging komplex, wenn sich das Verhalten über mehrere Ebenen erstreckt.

In diesem Fall ist es am besten,eep Hierarchien flach zu halten. onsiere auchdie Komposition (wie ich bereits erwähnt habe) oder zerlege eine Kette in einzelne Hierarchien, wenn du merkst, dass sie zu tief wird.

Fazit

Vererbung ist eine wichtige Säule der objektorientierten Programmierung, die es Entwicklern wie dir ermöglicht, wiederverwendbaren, modularen und skalierbaren Code zu erstellen. Wenn du die Vererbung beherrschst, wird es dir leicht fallen, komplexe Systeme zu vereinfachen.

Eine gute Möglichkeit, dein Verständnis zu vertiefen, ist es, zu versuchen, Vererbungsstrukturen in deinen Projekten aufzubauen. Fang einfach an und experimentiere dann mit komplexeren Hierarchien, um zu sehen, wie sie in der Praxis funktionieren.

Wenn du noch tiefer in die Materie einsteigen möchtest, kannst du unseren Kurs Konzepte des Programmierparadigmas besuchen, um ein tieferes Verständnis von Vererbung und anderen Ideen zu erlangen. Unser Lernpfad für Python-Entwickler/innen ist ebenfalls eine gute Ressource, die einen umfassenden Weg zur Entwicklung fortgeschrittener Programmierkenntnisse bietet, die dich für die Softwareentwicklung rüsten.