Classi astratte in Python: guida completa con esempi

Il modulo abc in Python

Il modulo abc in Python offre un solido supporto integrato per le classi astratte. Il modulo, che sta per "Abstract Base Classes", fornisce agli sviluppatori gli strumenti necessari per creare classi astratte, incluso il decoratore abstractmethod e la classe ABC. 

Definendo metodi astratti e richiedendone l'implementazione nelle sottoclassi, questi strumenti ti aiutano a mantenere uniformità e aderenza a un'interfaccia prestabilita. Richiedendo l'implementazione di metodi essenziali in tutte le classi derivate e consentendo l'implementazione parziale di funzionalità comuni nelle classi base astratte, il modulo favorisce anche pattern di progettazione migliori. 

Per questo, il modulo ABC è un componente fondamentale per organizzare applicazioni Python scalabili, robuste e stabili.

Creare una classe astratta in Python

Nel modulo ABC vengono introdotti due componenti essenziali:

Abstract Base Class, o ABC

La classe ABC è una funzionalità integrata di Python che funge da base per sviluppare classi astratte. Devi ereditare da ABC per definire una classe astratta. Questa ereditarietà indica che la classe è astratta e non può essere istanziata direttamente. Agendo come progetti, le classi astratte assicurano che qualsiasi sottoclasse concreta rispetti un insieme di regole.

Puoi definire metodi astratti all'interno di una classe astratta usando il decoratore abstractmethod. I metodi astratti sono segnaposto che qualsiasi sottoclasse concreta deve implementare e sovrascrivere. Questo garantisce che tutte le classi derivate forniscano funzionalità per i metodi designati, rendendo il codice coerente e prevedibile. Il decoratore abstractmethod è uno strumento utile per imporre l'implementazione dei metodi lasciando alle sottoclassi la flessibilità su come soddisfare questi requisiti.

Ecco un esempio base:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14159 * self.radius

# Uncommenting the following line will raise an error because we’re missing method implementations
# shape = Shape() # TypeError: Can't instantiate abstract class Shape with abstract methods #area, perimeter

circle = Circle(5)
print(f"Area: {circle.area()}")
print(f"Perimeter: {circle.perimeter()}")

# Area: 78.53975
# Perimeter: 31.4159

Se cerchi altri progetti pratici in Python, dai un'occhiata al nostro elenco dei migliori 60 progetti Python per sviluppatori di ogni livello. 

Come il modulo abc impone l'implementazione dei metodi

Il decoratore abstractmethod garantisce che qualsiasi sottoclasse di una classe astratta implementi i metodi decorati. Come misura preventiva, impedisce la creazione di sottoclassi prive delle capacità necessarie. 

Python segnala un TypeError quando si tenta di istanziare una sottoclasse che non sovrascrive tutti i metodi astratti. Questa applicazione rigorosa riduce la probabilità di difetti e migliora la stabilità del codice, aiutando gli sviluppatori a individuare presto le lacune di implementazione. 

Garantisce inoltre che tutte le sottoclassi concrete seguano il comportamento e il design previsti dalla classe astratta.

Per esempio:

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    # Missing area and perimeter implementation

# This will raise an error
rectangle = Rectangle(5, 10)

# TypeError: Can't instantiate abstract class Rectangle with abstract methods area, perimeter

Metodi di classe astratta in Python

In Python, definire una classe astratta implica usare il decoratore abstractmethod ed ereditare da ABC. In questo modo, gli sviluppatori possono gettare le basi per altre classi definendo i metodi che devono essere utilizzati. 

Ecco una procedura dettagliata, passo dopo passo:

• Importa i moduli necessari: inizia importando ABC e abstractmethod dal modulo ABC. Questi strumenti sono necessari per definire classi e metodi astratti.
• Costruisci una classe basata su ABC: crea una nuova classe e imposta ABC come genitore. Questa ereditarietà indica che la classe è astratta e non può essere istanziata direttamente.
• Definisci metodi astratti usando @abstractmethod: usa il decoratore @abstractmethod per specificare quali metodi le sottoclassi devono sovrascrivere. In sostanza, questi metodi fungono da segnaposto, garantendo che tutte le classi derivate eseguano le operazioni necessarie.

Esempio passo passo di definizione di una classe astratta

Ecco un esempio pratico per dimostrare:

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def start_engine(self):
        pass

    @abstractmethod
    def stop_engine(self):
        pass

class Car(Vehicle):
    def start_engine(self):
        print("Car engine started")

    def stop_engine(self):
        print("Car engine stopped")

# Instantiating the abstract class directly will raise an error
# vehicle = Vehicle()

car = Car()
car.start_engine()
car.stop_engine()

# Car engine started
# Car engine stopped

Questo garantisce che le funzioni start_engine e stop_engine siano implementate da qualsiasi sottoclasse di Vehicle.

Esempio pratico: implementazione di una classe astratta

Guarda un esempio più completo usando una classe Vehicle:

from abc import ABC, abstractmethod

class Vehicle(ABC):
    def __init__(self, brand):
        self.brand = brand

    @abstractmethod
    def start_engine(self):
        pass

    @abstractmethod
    def stop_engine(self):
        pass

class Motorcycle(Vehicle):
    def start_engine(self):
        print(f"{self.brand} motorcycle engine started")

    def stop_engine(self):
        print(f"{self.brand} motorcycle engine stopped")

motorcycle = Motorcycle("Yamaha")
motorcycle.start_engine()
motorcycle.stop_engine()
# Yamaha motorcycle engine started
# Yamaha motorcycle engine stopped

Questo mostra come le classi astratte consentano flessibilità di implementazione pur imponendo un'interfaccia coerente.

Esempio di Abstract Base Class in Python

Ora che abbiamo visto come le classi base astratte definiscono un contratto per le sottoclassi, esploriamo come le classi concrete soddisfano questi requisiti implementando tutti i metodi astratti.

Classe concreta che eredita da una classe astratta

Una sottoclasse che implementa ogni metodo astratto di una classe astratta è chiamata classe concreta. Ciò significa che la classe concreta fornisce implementazioni specifiche per tutti i metodi necessari, rispettando così il contratto stabilito dalla classe astratta. 

Per esempio:

from abc import ABC, abstractmethod

class Appliance(ABC):
    @abstractmethod
    def turn_on(self):
        pass

    @abstractmethod
    def turn_off(self):
        pass

class WashingMachine(Appliance):
    def turn_on(self):
        print("Washing machine is now ON")

    def turn_off(self):
        print("Washing machine is now OFF")

machine = WashingMachine()
machine.turn_on()
machine.turn_off()

# Washing machine is now ON
# Washing machine is now OFF

Creare istanze e imporre le regole

Python impedisce di istanziare direttamente una classe astratta. Questo è un aspetto essenziale delle classi astratte, perché garantisce che qualsiasi sottoclasse generata dalla classe astratta rispetti il contratto necessario fornito dai suoi metodi astratti. 

Per esempio, verrà generato un TypeError se provi a istanziare appliance = Appliance()

Questa limitazione garantisce che le classi astratte funzionino solo come progetti e non vengano abusate. Implementando tutti i metodi astratti in WashingMachine, Python consente la creazione di istanze di WashingMachine mantenendo il contratto specificato in Appliance. Applicando questa regola, si migliora l'integrità del codebase garantendo che ogni funzionalità definita nella classe astratta sia completamente implementata nelle sue sottoclassi concrete.

Proprietà astratte e inizializzazione

Con queste basi, approfondiamo come Python supporta le proprietà astratte usando i decoratori @property e @abstractmethod, permettendo agli sviluppatori di imporre la coerenza degli attributi insieme ai metodi.

Usare proprietà astratte in Python

Le classi astratte possono specificare, oltre ai metodi, anche proprietà che le sottoclassi devono implementare. Questa funzionalità consente agli sviluppatori di imporre un'interfaccia uniforme per le proprietà che le sottoclassi devono dichiarare oltre ai metodi. 

Per garantire che ogni sottoclasse fornisca la propria implementazione, le proprietà astratte possono essere definite usando il decoratore @property in combinazione con @abstractmethod. Questo approccio è particolarmente utile quando si creano classi che necessitano di attributi in sola lettura o calcolati, essenziali per il funzionamento della classe.

Esempio: classe astratta con proprietà

Ecco un esempio:

from abc import ABC, abstractmethod

class Animal(ABC):
    @property
    @abstractmethod
    def sound(self):
        pass

class Bird(Animal):
    @property
    def sound(self):
        return "Chirp"

bird = Bird()
print(bird.sound)

# Chirp

La proprietà sound della classe Bird soddisfa la condizione della classe astratta Animal.

Quando usare le classi astratte in Python

Le classi astratte sono ideali in scenari come:

• Quando progetti framework o librerie in cui è necessario imporre un comportamento specifico: in sistemi complessi, le classi astratte possono stabilire un insieme unificato di regole o interfacce che tutte le sottoclassi devono seguire, garantendo coerenza e riducendo gli errori.
• Implementare API coerenti tra classi: definendo metodi astratti, gli sviluppatori possono garantire che tutte le classi derivate offrano un modo standardizzato e prevedibile di interagire con l'applicazione o la libreria.
• Fornire un quadro di base per una gerarchia di classi: le classi astratte possono fungere da guida per creare una gerarchia di classi correlate. Dichiarando comportamenti e caratteristiche condivisi nella classe astratta e consentendo la personalizzazione nelle sottoclassi, questa struttura favorisce il riuso e riduce la duplicazione.

Best practice

Usa le classi astratte quando devi stabilire un contratto preciso per le sottoclassi. Le classi astratte sono utili quando devi applicare una struttura o un comportamento specifico a diverse classi derivate. Aiutano a garantire che ogni sottoclasse segua un design standard, migliorando la prevedibilità del codice e semplificando la manutenzione.

Se ogni metodo può avere un'implementazione predefinita, non usare classi astratte. In alcuni casi, una classe base concreta potrebbe essere un'opzione migliore per ridurre la complessità mantenendo la possibilità di riutilizzare funzionalità condivise.

Assicurati che le classi astratte siano chiare e semplici, definendo solo gli attributi e i metodi più importanti. Se una classe astratta ha troppi requisiti, può essere difficile da costruire e mantenere. Concentrati invece sugli aspetti essenziali che le classi derivate devono avere.

Conclusione

Le classi astratte fanno parte della cassetta degli attrezzi OOP di Python e sono uno strumento potente che consente di creare programmi affidabili e manutenibili. Definendo classi astratte e imponendo un'interfaccia uniforme tra le sottoclassi con l'aiuto del modulo ABC, puoi promuovere chiarezza, riuso ed estendibilità nelle tue applicazioni. L'implementazione di classi astratte aiuta a scrivere codice migliore e più affidabile, indipendentemente dalle dimensioni del sistema su cui stai lavorando.

Che tu stia progettando programmi orientati agli oggetti robusti, imponendo interfacce coerenti o creando applicazioni scalabili, padroneggiare le classi astratte in Python migliora la tua capacità di scrivere codice efficiente e manutenibile. Fai un salto di qualità oggi con il nostro completo skill track Python Fundamentals.