Abstrakte klasser i Python

Denne artikel forklarer abstrakte klasser i Python.

Vi vil forklare den grundlæggende mekanisme for abstrakte klasser ved hjælp af abc-modulet, give praktiske eksempler og beskrive alt med ledsagende kode.

YouTube Video

Abstrakte klasser i Python

abc-modulet i Python (Abstract Base Classes) er en del af standardbiblioteket og bruges til at definere abstrakte klasser, hvilket giver en skabelon til metoder, en klasse skal implementere. Brug af dette modul forbedrer fleksibiliteten og robustheden i klassedesign.

Hvad er en abstrakt klasse?

Abstrakte klasser er klasser, der bruges til at definere en fælles grænseflade for konkrete (instansierbare) klasser. Abstrakte klasser kan ikke instansieres selv; en konkret implementering skal leveres i afledte (under)klasser.

abc-modulet giver dig mulighed for at definere abstrakte metoder eller egenskaber og kræve deres implementering i de nedarvende klasser. Hvis selv én abstrakt metode ikke er implementeret, kan klassen ikke instansieres.

Sådan bruges abc-modulet

For at oprette en abstrakt klasse ved hjælp af abc-modulet skal du arve fra ABC-klassen og definere abstrakte metoder ved hjælp af @abstractmethod-dekorationen.

 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!"

Her er Animal-klassen defineret som en abstrakt klasse og inkluderer en abstrakt metode kaldet sound. Denne metode skal konkret implementeres i underklasserne. Dog og Cat arver fra Animal og implementerer hver især sound-metoden.

Instansiering af abstrakte klasser

Abstrakte klasser kan ikke instansieres direkte. Forsøger man for eksempel at instansiere Animal-klassen selv, vil det resultere i en fejl.

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

• Når man forsøger at instansiere en abstrakt klasse, registrerer Python, at der er uimplementerede abstrakte metoder og rejser en TypeError. Hvis alle nødvendige abstrakte metoder er implementeret i underklassen, bliver instansiering mulig.

Flere abstrakte metoder

Det er også muligt for en klasse at have flere abstrakte metoder. Medmindre alle abstrakte metoder er implementeret i en underklasse, forbliver klassen en abstrakt 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"

I dette eksempel har Vehicle-klassen to abstrakte metoder, og Car-klassen kan kun instantieres efter implementeringen af begge metoder.

Definition af abstrakte egenskaber

abc-modulet understøtter ikke kun abstrakte metoder, men også abstrakte egenskaber. Dette muliggør håndhævelse af implementeringen af egenskaber i afledte klasser.

 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)

• I dette eksempel har Shape-klassen en abstrakt egenskab area, og underklassen Circle konkretiserer denne egenskab. På denne måde hjælper brugen af abstrakte klasser til at håndhæve egenskabsimplementering med at opretholde kodekonsistens.

Brug af isinstance() og issubclass()

Ved at bruge abstrakte klasser kan du bekræfte klassearverelationer med isinstance() eller issubclass(), hvilket forbedrer kodesikkerhed og fleksibilitet.

 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() bruges til at kontrollere, om et objekt er en instans af en specificeret klasse, og issubclass() bruges til at kontrollere, om en klasse er en underklasse af en specificeret klasse.

Sammendrag

Ved at designe abstrakte klasser med abc-modulet kan du præcisere grænsefladen mellem klasser og håndhæve implementeringen af påkrævede metoder og egenskaber. Dette hjælper med at opretholde kodekonsistens og reducerer fejl, hvilket gør det særligt nyttigt til storskala-projekter.

Abstrakte klasser er et vigtigt værktøj i Python, der understøtter fleksibel objektorienteret programmering og øger klassernes genanvendelighed og vedligeholdelse.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video