Abstrakte klasser i Python

Denne artikkelen forklarer abstrakte klasser i Python.

Vi vil forklare den grunnleggende mekanismen for abstrakte klasser ved å bruke abc-modulen, gi praktiske eksempler, og beskrive alt med medfølgende kode.

YouTube Video

Abstrakte klasser i Python

Pythons abc-modul (Abstract Base Classes) er en del av standardbiblioteket og brukes til å definere abstrakte klasser, og gir en mal for metoder som en klasse skal implementere. Å bruke denne modulen øker fleksibiliteten og robustheten i klasseutforming.

Hva er en abstrakt klasse?

Abstrakte klasser er klasser som brukes til å definere et felles grensesnitt for konkrete (instansierbare) klasser. Abstrakte klasser kan ikke instansieres selv; en konkret implementering må gis i avledede (sub)klasser.

abc-modulen lar deg definere abstrakte metoder eller egenskaper og kreve deres implementering i de arvende klassene. Hvis bare én abstrakt metode ikke er implementert, kan klassen ikke instansieres.

Hvordan bruke abc-modulen

For å opprette en abstrakt klasse ved hjelp av abc-modulen, arver du fra ABC-klassen og definerer abstrakte metoder ved å bruke @abstractmethod-dekoren.

 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 definert som en abstrakt klasse og inkluderer en abstrakt metode kalt sound. Denne metoden må implementeres konkret i subklasser. Dog og Cat arver fra Animal og implementerer hver sin sound-metode.

Instansiering av abstrakte klasser

Abstrakte klasser kan ikke instansieres direkte. For eksempel, å forsøke å instansiere Animal-klassen selv vil føre til en feil.

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

• Når man prøver å instansiere en abstrakt klasse, avgjør Python at det finnes uimplementerte abstrakte metoder og kaster en TypeError. Hvis alle nødvendige abstrakte metoder er implementert i subklassen, blir instansiering mulig.

Flere abstrakte metoder

Det er også mulig for en klasse å ha flere abstrakte metoder. Med mindre alle abstrakte metoder er implementert i en subklasse, forblir 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 eksemplet har Vehicle-klassen to abstrakte metoder, og Car-klassen kan bare instansieres etter at begge metodene er implementert.

Definere abstrakte egenskaper

abc-modulen støtter ikke bare abstrakte metoder, men også abstrakte egenskaper. Dette gjør det mulig å håndheve implementeringen av egenskaper i avledede 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 eksemplet har Shape-klassen en abstrakt egenskap area, og underklassen Circle konkretiserer denne egenskapen. På denne måten bidrar bruken av abstrakte klasser til å opprettholde kodeskonsistens ved å håndheve implementering av egenskaper.

Bruke isinstance() og issubclass()

Ved å bruke abstrakte klasser kan du bekrefte klassearvforhold med isinstance() eller issubclass(), noe som forbedrer kodesikkerhet 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() brukes til å sjekke om et objekt er en instans av en spesifisert klasse, og issubclass() brukes til å sjekke om en klasse er en underklasse av en spesifisert klasse.

Sammendrag

Ved å designe abstrakte klasser ved hjelp av abc-modulen kan du klargjøre grensesnittet mellom klasser og håndheve implementeringen av nødvendige metoder og egenskaper. Dette bidrar til å opprettholde kodeskonsistens og reduserer feil, noe som gjør det spesielt nyttig for storskala prosjekter.

Abstrakte klasser er et viktig verktøy i Python som støtter fleksibel objektorientert programmering og forbedrer gjenbrukbarhet og vedlikeholdbarhet av klasser.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video