Classi astratte in Python

Questo articolo spiega le classi astratte in Python.

Spiegheremo il meccanismo di base delle classi astratte utilizzando il modulo abc, forniremo esempi pratici e descriveremo tutto con codice esplicativo.

YouTube Video

Classi astratte in Python

Il modulo abc di Python (Abstract Base Classes) fa parte della libreria standard ed è utilizzato per definire classi astratte, fornendo un modello per i metodi che una classe dovrebbe implementare. L'utilizzo di questo modulo migliora la flessibilità e la robustezza nella progettazione delle classi.

Che cos'è una classe astratta?

Le classi astratte sono classi utilizzate per definire un'interfaccia comune per le classi concrete (istanziabili). Le classi astratte non possono essere istanziate direttamente; è necessario fornire un'implementazione concreta nelle classi derivate (sottoclassi).

Il modulo abc consente di definire metodi o proprietà astratte e di imporne l'implementazione nelle classi che ereditano. Se anche un solo metodo astratto non è implementato, la classe non può essere istanziata.

Come utilizzare il modulo abc

Per creare una classe astratta utilizzando il modulo abc, eredita dalla classe ABC e definisci metodi astratti utilizzando il decoratore @abstractmethod.

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

Qui, la classe Animal è definita come una classe astratta e include un metodo astratto chiamato sound. Questo metodo deve essere concretamente implementato nelle sottoclassi. Dog e Cat ereditano da Animal e implementano ciascuno il metodo sound.

Istanziamento di classi astratte

Le classi astratte non possono essere istanziate direttamente. Ad esempio, tentare di istanziare direttamente la classe Animal genererà un errore.

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

• Quando si tenta di istanziare una classe astratta, Python determina che ci sono metodi astratti non implementati e solleva un TypeError. Se tutti i metodi astratti richiesti sono implementati nella sottoclasse, è possibile l'istanziamento.

Metodi astratti multipli

È anche possibile che una classe abbia più metodi astratti. A meno che tutti i metodi astratti non vengano implementati in una sottoclasse, la classe rimane una classe astratta.

 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 questo esempio, la classe Vehicle ha due metodi astratti e la classe Car può essere istanziata solo dopo aver implementato entrambi i metodi.

Definizione delle Proprietà Astratte

Il modulo abc supporta non solo i metodi astratti, ma anche le proprietà astratte. Questo consente di imporre l'implementazione delle proprietà nelle classi derivate.

 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 questo esempio, la classe Shape ha una proprietà astratta area, e la sottoclasse Circle concretizza questa proprietà. In questo modo, l'uso di classi astratte per imporre l'implementazione delle proprietà aiuta a mantenere la coerenza del codice.

Uso di isinstance() e issubclass()

Usando le classi astratte, puoi confermare le relazioni di ereditarietà tra classi con isinstance() o issubclass(), migliorando la sicurezza e la flessibilità del codice.

 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() viene utilizzato per verificare se un oggetto è un'istanza di una classe specificata, mentre issubclass() viene utilizzato per verificare se una classe è una sottoclasse di una classe specificata.

Riepilogo

Progettando classi astratte utilizzando il modulo abc, è possibile chiarire l'interfaccia tra le classi e imporre l'implementazione di metodi e proprietà richiesti. Questo aiuta a mantenere la coerenza del codice e a ridurre gli errori, risultando particolarmente utile per progetti di larga scala.

Le classi astratte sono uno strumento importante in Python che supporta una programmazione orientata agli oggetti flessibile, migliorando la riutilizzabilità e la manutenibilità delle classi.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video