Abstrakte Klassen in Python

Dieser Artikel erklärt abstrakte Klassen in Python.

Wir erklären den grundlegenden Mechanismus abstrakter Klassen mit dem abc-Modul, stellen praktische Beispiele vor und beschreiben alles mit begleitendem Code.

YouTube Video

Abstrakte Klassen in Python

Das abc-Modul (Abstract Base Classes) von Python ist Teil der Standardbibliothek und wird verwendet, um abstrakte Klassen zu definieren. Es bietet eine Vorlage für Methoden, die eine Klasse implementieren sollte. Die Verwendung dieses Moduls verbessert die Flexibilität und Robustheit beim Klassendesign.

Was ist eine abstrakte Klasse?

Abstrakte Klassen sind Klassen, die verwendet werden, um eine gemeinsame Schnittstelle für konkrete (instanziierbare) Klassen zu definieren. Abstrakte Klassen können nicht selbst instanziiert werden; in abgeleiteten (Unter-)Klassen muss eine konkrete Implementierung bereitgestellt werden.

Das abc-Modul ermöglicht es, abstrakte Methoden oder Eigenschaften zu definieren und deren Implementierung in den erbenden Klassen durchzusetzen. Wenn auch nur eine abstrakte Methode nicht implementiert ist, kann die Klasse nicht instanziiert werden.

Wie man das abc-Modul verwendet

Um mit dem abc-Modul eine abstrakte Klasse zu erstellen, erben Sie von der ABC-Klasse und definieren abstrakte Methoden mit dem @abstractmethod-Dekorator.

 1from abc import ABC, abstractmethod
 2
 3# Definition of the abstract base class
 4class Animal(ABC):
 5
 6    @abstractmethod
 7    def sound(self):
 8        pass
 9
10# Concrete implementation in the subclass
11class Dog(Animal):
12    def sound(self):
13        return "Woof!"
14
15class Cat(Animal):
16    def sound(self):
17        return "Meow!"

Hier wird die Klasse Animal als abstrakte Klasse definiert und enthält eine abstrakte Methode namens sound. Diese Methode muss in den Unterklassen konkret implementiert werden. Dog und Cat erben von Animal und implementieren jeweils die Methode sound.

Instanzierung abstrakter Klassen

Abstrakte Klassen können nicht direkt instanziiert werden. Der Versuch, die Klasse Animal selbst zu instanziieren, führt beispielsweise zu einem Fehler.

1animal = Animal()  # TypeError: Can't instantiate abstract class Animal with abstract methods sound

• Wenn versucht wird, eine abstrakte Klasse zu instanziieren, stellt Python fest, dass nicht implementierte abstrakte Methoden vorhanden sind, und löst einen TypeError aus. Wenn alle erforderlichen abstrakten Methoden in der Unterklasse implementiert sind, wird die Instanzierung möglich.

Mehrere abstrakte Methoden

Es ist auch möglich, dass eine Klasse mehrere abstrakte Methoden hat. Solange nicht alle abstrakten Methoden in einer Unterklasse implementiert sind, bleibt die Klasse abstrakt.

 1from abc import ABC, abstractmethod
 2
 3class Vehicle(ABC):
 4
 5    @abstractmethod
 6    def start_engine(self):
 7        pass
 8
 9    @abstractmethod
10    def stop_engine(self):
11        pass
12
13class Car(Vehicle):
14    def start_engine(self):
15        return "Car engine started"
16
17    def stop_engine(self):
18        return "Car engine stopped"

In diesem Beispiel hat die Klasse Vehicle zwei abstrakte Methoden, und die Klasse Car kann erst instanziiert werden, nachdem beide Methoden implementiert wurden.

Definieren von abstrakten Eigenschaften

Das Modul abc unterstützt nicht nur abstrakte Methoden, sondern auch abstrakte Eigenschaften. Dadurch wird gewährleistet, dass Eigenschaften in abgeleiteten Klassen implementiert werden.

 1from abc import ABC, abstractmethod
 2
 3class Shape(ABC):
 4
 5    @property
 6    @abstractmethod
 7    def area(self):
 8        pass
 9
10class Circle(Shape):
11    def __init__(self, radius):
12        self.radius = radius
13
14    @property
15    def area(self):
16        return 3.14159 * (self.radius ** 2)

• In diesem Beispiel hat die Klasse Shape eine abstrakte Eigenschaft area, und die Unterklasse Circle konkretisiert diese Eigenschaft. Auf diese Weise hilft die Verwendung abstrakter Klassen zur Durchsetzung der Implementierung von Eigenschaften, die Konsistenz des Codes zu wahren.

Verwendung von isinstance() und issubclass()

Durch die Verwendung abstrakter Klassen können Sie Vererbungsbeziehungen mit isinstance() oder issubclass() bestätigen, was die Codesicherheit und -flexibilität erhöht.

 1from abc import ABC, abstractmethod
 2
 3# Definition of the abstract base class
 4class Animal(ABC):
 5
 6    @abstractmethod
 7    def sound(self):
 8        pass
 9
10# Concrete implementation in the subclass
11class Dog(Animal):
12    def sound(self):
13        return "Woof!"
14
15class Cat(Animal):
16    def sound(self):
17        return "Meow!"
18
19class Vehicle(ABC):
20
21    @abstractmethod
22    def start_engine(self):
23        pass
24
25    @abstractmethod
26    def stop_engine(self):
27        pass
28
29class Car(Vehicle):
30    def start_engine(self):
31        return "Car engine started"
32
33    def stop_engine(self):
34        return "Car engine stopped"
35
36print("Dog() is an Animal? -> ", isinstance(Dog(), Animal))   # True
37print("Dog is subclass of Animal? -> ", issubclass(Dog, Animal))  # True
38print("Cat() is a Vehicle? -> ", isinstance(Cat(), Vehicle))  # False

isinstance() wird verwendet, um zu überprüfen, ob ein Objekt eine Instanz einer bestimmten Klasse ist, und issubclass() wird verwendet, um zu überprüfen, ob eine Klasse eine Unterklasse einer bestimmten Klasse ist.

Zusammenfassung

Durch das Entwerfen abstrakter Klassen mit dem Modul abc können Sie die Schnittstelle zwischen Klassen klar definieren und die Implementierung erforderlicher Methoden und Eigenschaften erzwingen. Dies hilft, die Konsistenz des Codes zu wahren und Fehler zu reduzieren, wodurch es besonders nützlich für groß angelegte Projekte wird.

Abstrakte Klassen sind ein wichtiges Werkzeug in Python, das flexibles objektorientiertes Programmieren unterstützt und die Wiederverwendbarkeit und Wartbarkeit von Klassen verbessert.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video