Abstracte Klassen in Python

Dit artikel legt abstracte klassen in Python uit.

We leggen het basismechanisme van abstracte klassen uit met behulp van de abc-module, geven praktische voorbeelden en beschrijven alles met bijbehorende code.

YouTube Video

Abstracte Klassen in Python

De abc-module van Python (Abstracte Basisklassen) is onderdeel van de standaardbibliotheek en wordt gebruikt om abstracte klassen te definiëren, waarbij een sjabloon wordt geboden voor de methoden die een klasse moet implementeren. Het gebruik van deze module verbetert de flexibiliteit en robuustheid in klassedesign.

Wat is een abstracte klasse?

Abstracte klassen zijn klassen die worden gebruikt om een gemeenschappelijke interface voor concrete (instantieerbare) klassen te definiëren. Abstracte klassen kunnen niet zelf worden geïnstantieerd; een concrete implementatie moet worden voorzien in afgeleide (sub)klassen.

Met de abc-module kun je abstracte methoden of eigenschappen definiëren en afdwingen dat ze worden geïmplementeerd in de klassen die erven. Als zelfs maar één abstracte methode niet is geïmplementeerd, kan de klasse niet worden geïnstantieerd.

Hoe de abc-module te gebruiken

Om een abstracte klasse te maken met behulp van de abc-module, erft u van de ABC-klasse en definieert u abstracte methoden met behulp van de @abstractmethod-decorator.

 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 wordt de Animal-klasse gedefinieerd als een abstracte klasse en bevat deze een abstracte methode genaamd sound. Deze methode moet concreet worden geïmplementeerd in de subklassen. Dog en Cat erven van Animal en implementeren elk de sound-methode.

Instanties maken van abstracte klassen

Abstracte klassen kunnen niet direct worden geïnstantieerd. Bijvoorbeeld, het proberen te instantiëren van de Animal-klasse zelf zal resulteren in een fout.

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

• Bij het proberen te instantiëren van een abstracte klasse, bepaalt Python dat er niet-geïmplementeerde abstracte methoden zijn en genereert een TypeError. Als alle vereiste abstracte methoden in de subklasse zijn geïmplementeerd, wordt instanties maken mogelijk.

Meerdere abstracte methoden

Het is ook mogelijk dat een klasse meerdere abstracte methoden heeft. Tenzij alle abstracte methoden in een subklasse worden geïmplementeerd, blijft de klasse een abstracte klasse.

 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 dit voorbeeld heeft de klasse Vehicle twee abstracte methoden, en kan de klasse Car alleen worden geïnstantieerd nadat beide methoden zijn geïmplementeerd.

Abstracte Eigenschappen Definiëren

De abc-module ondersteunt niet alleen abstracte methoden, maar ook abstracte eigenschappen. Hierdoor kan de implementatie van eigenschappen in afgeleide klassen worden afgedwongen.

 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 dit voorbeeld heeft de klasse Shape een abstracte eigenschap area, en concretiseert de subklasse Circle deze eigenschap. Op deze manier helpt het gebruik van abstracte klassen om de implementatie van eigenschappen af te dwingen de code consistent te houden.

Het Gebruik van isinstance() en issubclass()

Door abstracte klassen te gebruiken, kun je relaties tussen klasse-erfenissen bevestigen met isinstance() of issubclass(), wat de veiligheid en flexibiliteit van de code verbetert.

 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() wordt gebruikt om te controleren of een object een instantie is van een specifieke klasse, en issubclass() wordt gebruikt om te controleren of een klasse een subklasse is van een specifieke klasse.

Samenvatting

Door abstracte klassen te ontwerpen met behulp van de abc-module, kun je de interface tussen klassen verduidelijken en de implementatie van vereiste methoden en eigenschappen afdwingen. Dit helpt de code consistent te houden en vermindert fouten, wat het bijzonder nuttig maakt voor grootschalige projecten.

Abstracte klassen zijn een belangrijk hulpmiddel in Python die flexibel objectgeoriënteerd programmeren ondersteunen, en ze verhogen de herbruikbaarheid en onderhoudbaarheid van klassen.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video