Una classe astratta può essere considerata un modello per altre classi . Ti consente di creare una serie di metodi che devono essere creati all'interno di qualsiasi classe figlia costruita dalla classe astratta.

Una classe che contiene uno o più metodi astratti è chiamata an classe astratta . UN metodo astratto è un metodo che ha una dichiarazione ma non ha un'implementazione.

Utilizziamo una classe astratta mentre progettiamo unità funzionali di grandi dimensioni o quando vogliamo fornire un'interfaccia comune per diverse implementazioni di un componente.

Classi base astratte in Python

Definendo una classe base astratta, è possibile definire una classe comune Interfaccia del programma applicativo (API) per un insieme di sottoclassi. Questa funzionalità è particolarmente utile in situazioni in cui una terza parte fornirà implementazioni, ad esempio con i plugin, ma può anche aiutarti quando lavori in un team di grandi dimensioni o con una base di codice di grandi dimensioni in cui tenere a mente tutte le classi è difficile o meno possibile.

Lavorare su classi Python Abstract

Per impostazione predefinita, Pitone non fornisce classi astratte . Python viene fornito con un modulo che fornisce la base per definire A Classi base astratte (ABC) e il nome del modulo è ABC .

ABC funziona decorando i metodi della classe base come astratti e quindi registrando le classi concrete come implementazioni della base astratta. Un metodo diventa astratto quando decorato con la parola chiave @abstractmethod.

Esempio 1:

Questo codice definisce una classe base astratta chiamata Poligono utilizzando il modulo ABC (Abstract Base Class) in Python. La classe Polygon ha un metodo astratto chiamato noofsides che deve essere implementato dalle sue sottoclassi.

Sono definite quattro sottoclassi di Poligono: Triangolo, Pentagono, Esagono e Quadrilatero. Ognuna di queste sottoclassi sovrascrive il metodo noofsides e fornisce la propria implementazione stampando il numero di lati di cui dispone.

Nel codice del driver vengono create istanze di ciascuna sottoclasse e il metodo noofsides viene chiamato su ciascuna istanza per visualizzare il numero di lati specifico di quella forma.

# Python program showing # abstract base class work from abc import ABC, abstractmethod class Polygon(ABC): @abstractmethod def noofsides(self): pass class Triangle(Polygon): # overriding abstract method def noofsides(self): print('I have 3 sides') class Pentagon(Polygon): # overriding abstract method def noofsides(self): print('I have 5 sides') class Hexagon(Polygon): # overriding abstract method def noofsides(self): print('I have 6 sides') class Quadrilateral(Polygon): # overriding abstract method def noofsides(self): print('I have 4 sides') # Driver code R = Triangle() R.noofsides() K = Quadrilateral() K.noofsides() R = Pentagon() R.noofsides() K = Hexagon() K.noofsides()>

I have 3 sides I have 4 sides I have 5 sides I have 6 sides>

Esempio 2:

Qui, questo codice definisce una classe base astratta chiamata Animal utilizzando il modulo ABC (Abstract Base Class) in Python. La classe Animal ha un metodo non astratto chiamato move che non ha alcuna implementazione. Esistono quattro sottoclassi di animali definite: umano, serpente, cane e leone. Ognuna di queste sottoclassi sovrascrive il metodo move e fornisce la propria implementazione stampando una caratteristica di movimento specifica.

# Python program showing # abstract base class work from abc import ABC, abstractmethod class Animal(ABC): def move(self): pass class Human(Animal): def move(self): print('I can walk and run') class Snake(Animal): def move(self): print('I can crawl') class Dog(Animal): def move(self): print('I can bark') class Lion(Animal): def move(self): print('I can roar') # Driver code R = Human() R.move() K = Snake() K.move() R = Dog() R.move() K = Lion() K.move()>

I can walk and run I can crawl I can bark I can roar>

Implementazione di Abstract tramite sottoclasse

Sottoclassando direttamente dalla base, possiamo evitare la necessità di registrare esplicitamente la classe. In questo caso, per riconoscere viene utilizzata la gestione della classe Python Implementazione del plugin come attuazione del PluginBase astratto .

# Python program showing # implementation of abstract # class through subclassing import abc class parent: def geeks(self): pass class child(parent): def geeks(self): print('child class') # Driver code print( issubclass(child, parent)) print( isinstance(child(), parent))>

True True>

Un effetto collaterale dell'utilizzo della sottoclasse diretta è che è possibile trovare tutte le implementazioni del plugin chiedendo alla classe base l'elenco delle classi conosciute derivate da essa.

Metodi concreti in classi base astratte

Le classi concrete contengono solo metodi concreti (normali) mentre le classi astratte possono contenere sia metodi concreti che metodi astratti.

La classe concreta fornisce un'implementazione di metodi astratti, la classe base astratta può anche fornire un'implementazione invocando i metodi tramite super(). Esaminiamo l'esempio per invocare il metodo utilizzando super():

# Python program invoking a  # method using super() from abc import ABC class R(ABC): def rk(self): print('Abstract Base Class') class K(R): def rk(self): super().rk() print('subclass ') # Driver code r = K() r.rk()>

Abstract Base Class subclass>

Nel programma sopra, possiamo invocare i metodi in classi astratte utilizzando super().

Proprietà astratte in Python

Le classi astratte includono attributi oltre ai metodi, puoi richiedere gli attributi nelle classi concrete definendoli con @abstractproperty.

# Python program showing # abstract properties import abc from abc import ABC, abstractmethod class parent(ABC): @abc.abstractproperty def geeks(self): return 'parent class' class child(parent): @property def geeks(self): return 'child class' try: r = parent() print(r.geeks) except Exception as err: print(err) r = child() print(r.geeks)>

Can't instantiate abstract class parent with abstract methods geeks child class>

Nell'esempio precedente, la classe Base non può essere istanziata perché ha solo una versione astratta del metodo getter di proprietà.

Istanziazione di classi astratte

Le classi astratte sono incomplete perché hanno metodi che non hanno nessuno. Se Python consente di creare un oggetto per classi astratte, utilizzare quell'oggetto se qualcuno chiama il metodo astratto, ma non esiste un'implementazione effettiva da invocare.

Quindi, utilizziamo una classe astratta come modello e, a seconda delle necessità, la estendiamo e costruiamo su di essa prima di poterla utilizzare. Dato che una classe astratta non è una classe concreta, non può essere istanziata. Quando creiamo un oggetto per la classe astratta it solleva un errore .

# Python program showing # abstract class cannot # be an instantiation from abc import ABC,abstractmethod class Animal(ABC): @abstractmethod def move(self): pass class Human(Animal): def move(self): print('I can walk and run') class Snake(Animal): def move(self): print('I can crawl') class Dog(Animal): def move(self): print('I can bark') class Lion(Animal): def move(self): print('I can roar') c=Animal()>

Produzione:

Traceback (most recent call last): File '/home/ffe4267d930f204512b7f501bb1bc489.py', line 19, in c=Animal() TypeError: Can't instantiate abstract class Animal with abstract methods move>