Abstrakta klasser i Python

Den här artikeln förklarar abstrakta klasser i Python.

Vi kommer att förklara den grundläggande mekanismen för abstrakta klasser med hjälp av abc-modulen, ge praktiska exempel och beskriva allt med tillhörande kod.

YouTube Video

Abstrakta klasser i Python

abc-modulen i Python (Abstract Base Classes) är en del av standardbiblioteket och används för att definiera abstrakta klasser, vilket tillhandahåller en mall för metoder som en klass bör implementera. Att använda denna modul förbättrar flexibilitet och robusthet i klassdesign.

Vad är en abstrakt klass?

Abstrakta klasser är klasser som används för att definiera ett gemensamt gränssnitt för konkreta (instansierbara) klasser. Abstrakta klasser kan inte instansieras själva; en konkret implementering måste tillhandahållas i härledda (sub)klasser.

abc-modulen gör det möjligt att definiera abstrakta metoder eller egenskaper och kräva deras implementering i de ärvande klasserna. Om ens en abstrakt metod inte implementeras kan klassen inte instansieras.

Hur man använder abc-modulen

För att skapa en abstrakt klass med hjälp av abc-modulen, arv från ABC-klassen och definiera abstrakta metoder med @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!"

Här definieras Animal-klassen som en abstrakt klass och inkluderar en abstrakt metod som kallas sound. Denna metod måste implementeras konkret i subklasserna. Dog och Cat ärver från Animal och implementerar var och en metoden sound.

Instansiering av abstrakta klasser

Abstrakta klasser kan inte instansieras direkt. Till exempel, att försöka instansiera själva Animal-klassen kommer att resultera i ett fel.

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

• När man försöker instansiera en abstrakt klass avgör Python att det finns icke-implementerade abstrakta metoder och genererar ett TypeError-fel. Om alla nödvändiga abstrakta metoder implementeras i subklassen, blir instansiering möjlig.

Flera abstrakta metoder

Det är också möjligt för en klass att ha flera abstrakta metoder. Om inte alla abstrakta metoder implementeras i en subklass, förblir klassen en abstrakt klass.

 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 det här exemplet har Vehicle-klassen två abstrakta metoder, och Car-klassen kan endast instansieras efter att båda metoderna har implementerats.

Definiera abstrakta egenskaper

abc-modulen stöder inte bara abstrakta metoder utan också abstrakta egenskaper. Detta gör det möjligt att tvinga fram implementering av egenskaper i härledda 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 det här exemplet har Shape-klassen en abstrakt egenskap area, och subklassen Circle konkretiserar denna egenskap. På så sätt hjälper användningen av abstrakta klasser för att tvinga fram egenskapsimplementering att upprätthålla kodens konsekvens.

Använda isinstance() och issubclass()

Genom att använda abstrakta klasser kan du bekräfta klassarvsrelationer med isinstance() eller issubclass(), vilket ökar kodens säkerhet och flexibilitet.

 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() används för att kontrollera om ett objekt är en instans av en angiven klass, och issubclass() används för att kontrollera om en klass är en subklass av en angiven klass.

Sammanfattning

Genom att designa abstrakta klasser med hjälp av abc-modulen kan du tydliggöra gränssnittet mellan klasser och tvinga fram implementeringen av nödvändiga metoder och egenskaper. Detta hjälper till att upprätthålla kodens konsekvens och minskar fel, vilket gör det särskilt användbart för storskaliga projekt.

Abstrakta klasser är ett viktigt verktyg i Python som stöder flexibel objektorienterad programmering och förbättrar klassers återanvändbarhet och underhållbarhet.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video