Panoramica di Abstract Class in Python
Le classi astratte sono le classi dichiarate ma che non contengono implementazioni. Può solo essere ereditato. Le classi astratte funzionano come modello per le sottoclassi. Le classi astratte non possono essere istanziate e richiedono sottoclassi per fornire implementazioni per metodi astratti. Ha bisogno di sottoclassi per fornire implementazioni dei metodi astratti definiti nelle classi astratte. Le classi astratte contengono uno o più metodi astratti. I metodi astratti sono i metodi dichiarati senza implementazioni. Non possiamo creare direttamente l'oggetto della classe astratta, ma possiamo ereditare la classe base e quindi creare l'oggetto. In questo argomento, impareremo la lezione astratta in Python.
Sia la classe astratta che la classe concreta possono essere contenute nella classe astratta. Usando una classe astratta possiamo definire una struttura generalizzata dei metodi senza fornire implementazioni complete di ogni metodo. I metodi astratti definiti nella classe astratta in genere non hanno il corpo, ma è possibile avere metodi astratti con implementazioni nella classe astratta e se una sottoclasse viene derivata da tale classe astratta deve fornire l'implementazione di tali metodi . Se un metodo astratto non viene implementato dalla classe derivata, verrà generato un errore. L'oggetto classe astratta non può essere creato direttamente, ma quando utilizziamo questa classe astratta per fornire determinate funzionalità a una classe base o a una classe figlio, può farlo creando l'oggetto della classe base.
Importanza delle classi astratte
1. Fornisce la funzionalità predefinita delle classi di base.
2. Definisce un'API comune per l'insieme di sottoclassi, utile quando una terza parte fornisce plug-in in un'applicazione.
3. Utile in codice grande era ricordare che molte classi sono difficili.
Sintassi
From abc import ABC
Class Educba(ABC):
Per considerare qualsiasi classe come una classe astratta, la classe deve ereditare la metaclasse ABC dal modulo abc incorporato di Python. Il modulo abc importa la metaclasse ABC.
Metodi astratti in Python
I metodi astratti sono i metodi dichiarati senza implementazioni.
Sintassi
from abc import ABC, abstract method
Class Educba(ABC):
@abstractmethod
def mymethod(self):
#empty body
pass
Per definire i metodi astratti in una classe astratta, il metodo deve essere decorato con una parola chiave chiamata @abstractmethod decorator. Il decoratore @abstractmethod deve essere importato dalla libreria integrata in Python chiamata abc.
Come funzionavano le classi astratte in Python?
Python non ha classi astratte per impostazione predefinita, ma ha un modulo o una libreria che costituisce la base per la definizione delle classi Abstract Base (ABC) e quel nome del modulo è chiamato ABC. Contrassegna il metodo della classe base come classe base astratta e quindi produce classi concrete come implementazioni della base astratta. Un metodo si trasforma in un metodo astratto con l'aiuto di una parola chiave decoratore chiamata @abstractmethod.
Il modulo ABC viene utilizzato per creare le classi astratte, @ abstractmethod è il decoratore utilizzato per dichiarare il metodo astratto. Il modulo ABC stabilisce un contratto tra la classe base e la classe concreta.
Il modulo abc fornisce la base per la definizione di classi di base astratte (ABC) in Python. Il modulo collezioni ha alcune classi concrete derivate da ABC e possono essere ulteriormente suddivise. Oltre a tutto ciò, il modulo di collezioni contiene anche un po 'di ABC che può essere usato per verificare se una classe o un'istanza fornisce o meno un'interfaccia particolare.
Questo modulo fornisce la seguente classe:
classe abc.ABCMeta
La metaclasse viene utilizzata per definire le classi di base astratte (ABC)
Usiamo una metaclasse per creare una classe base astratta.
from abc import ABCMeta
class C:
__metaclass__ = ABCMeta
MyABC.register(tuple)
assert issubclass(tuple, C)
assert isinstance((), C)
Esempio
# importing the ABC module
from abc import ABC, abstractmethod
class Shape(ABC):
def common(self):
print("This is a concrete method")
@abstractmethod # decorator
def area(self):
pass
@abstractmethod
def perimeter(self):
pass
class Square(Shape):
def __init__(self, side):
self.__side=side
def area(self):
return self.__side*self.__side
def perimeter(self):
return 4*self.__side
class Rectangle(Shape):
def __init__(self, length, breath):
self.__length=length
self.__breath=breath
def area(self):
return self.__length*self.__breath
def perimeter(self):
return 2*(self.__length+self.__breath)
S1=Square(4)
print(S1.common())
print(S1.area())
print(S1.perimeter())
R1=Rectangle(2, 4)
print(R1.common())
print(R1.area())
print(R1.perimeter())
Uscita ottenuta
Questo è un metodo concreto
16
16
Questo è un metodo concreto
8
12
Nell'esempio sopra, la classe astratta è Forma che contiene un metodo concreto chiamato comune e due metodi astratti chiamati area e perimetro. Esistono due classi secondarie Square e Rectangle che ereditano la classe astratta Shape e implementano il metodo astratto.
Implementazione tramite sottoclasse:
import abc
class Shape:
def area(self):
pass
class Square(Shape):
def area(self):
print("Square is a child class")
print( issubclass(Square, Shape))
print( isinstance(Square(), Shape))
Proprietà astratte
Le classi astratte contengono proprietà astratte insieme a metodi astratti definiti da @abstractproperty.
Ora possiamo usare property, property.getter (), property.setter () e property.deleter () con classi astratte.
Sintassi
class class_name(ABC):
@property
@abstractmethod
Def method(self):
Questo definisce la proprietà di sola lettura.
class Class_name:
__metaclass__ = ABCMeta
def getx(self): …
def setx(self, value): …
x = abstractproperty(getx, setx)
Python 2
class C(ABC):
@abstractproperty
def my_abstract_property(self):
Python 3.3
class C(ABC):
@property
@abstractmethod
def my_abstract_property(self):
import abc
from abc import ABC, abstractmethod
class Shape(ABC):
@abc.abstractproperty
def area(self):
return "Shape class"
class Square(parent):
@property
def area(self):
return "Square class"
try:
s1 =Shape()
print( s1.area)
except for Exception as err:
print (err)
s1 = Square()
print (s1.area)
Produzione:
Impossibile creare un'istanza della classe astratta con l'area del metodo astratto
Classe quadrata
Conclusione
Alla fine, concludo che la classe astratta è un modo per garantire un certo livello di qualità del codice perché impone determinati standard e può ridurre la quantità di codice duplicato che scriviamo. Stabilisce una connessione tra la classe base e la classe concreta. Fornisce una facile implementazione del codice. Definisce una struttura generalizzata di metodi senza la sua completa implementazione. Rende facile la vita del programmatore astraggendo il processo in background e facendolo concentrare solo su punti importanti. Rende la ricerca e la comprensibilità molto più rapide comprendendo la struttura comune e semplice delle classi all'interno del codice.
Articoli consigliati
Questa è una guida alla classe astratta in Python. Qui discutiamo di come funzionano le classi astratte in Python con l'importanza e i metodi con esempi appropriati. Puoi anche dare un'occhiata ai seguenti articoli per saperne di più -
- Operazioni sui file Python
- Incapsulamento in Python
- Loop in Python
- Costruttore in Python
- Set di Python
- Introduzione alla classe astratta in PHP