Présentation de la classe abstraite en Python
Les classes abstraites sont les classes qui sont déclarées mais ne contiennent aucune implémentation. Elle ne peut qu'être héritée. Les classes abstraites fonctionnent comme un modèle pour les sous-classes. Les classes abstraites ne peuvent pas être instanciées et nécessitent des sous-classes pour fournir des implémentations pour les méthodes abstraites. Il a besoin de sous-classes pour fournir des implémentations des méthodes abstraites définies dans les classes abstraites. Les classes abstraites contiennent une ou plusieurs méthodes abstraites. Les méthodes abstraites sont les méthodes déclarées sans implémentation. Nous ne pouvons pas créer directement l'objet de la classe abstraite, mais nous pouvons hériter de la classe de base, puis créer l'objet. Dans cette rubrique, nous allons découvrir la classe abstraite en Python.
La classe abstraite ainsi que la classe concrète peuvent être contenues dans la classe abstraite. En utilisant une classe abstraite, nous pouvons définir une structure généralisée des méthodes sans fournir d'implémentations complètes de chaque méthode. Les méthodes abstraites définies dans la classe abstraite n'ont généralement pas de corps, mais il est possible d'avoir des méthodes abstraites avec des implémentations dans la classe abstraite et si une sous-classe est dérivée de cette classe abstraite, elle doit fournir l'implémentation de ces méthodes. . Si aucune méthode abstraite n'est implémentée par la classe dérivée, elle générera une erreur. L'objet de classe abstraite ne peut pas être créé directement, mais lorsque nous utilisons cette classe abstraite pour fournir certaines fonctionnalités à une classe de base ou à une classe enfant, il peut le faire en créant l'objet de la classe de base.
Importance des classes abstraites
1. Il fournit la fonctionnalité par défaut des classes de base.
2. Il définit une API commune pour l'ensemble des sous-classes, utile lorsqu'un tiers fournit des plugins dans une application.
3. Utile en gros code se souvenait de nombreuses classes est difficile.
Syntaxe
From abc import ABC
Class Educba(ABC):
Pour considérer une classe comme une classe abstraite, la classe doit hériter de la métaclasse ABC du module abc intégré python. le module abc importe la métaclasse ABC.
Méthodes abstraites en Python
Les méthodes abstraites sont les méthodes déclarées sans implémentation.
Syntaxe
from abc import ABC, abstract method
Class Educba(ABC):
@abstractmethod
def mymethod(self):
#empty body
pass
Pour définir les méthodes abstraites dans une classe abstraite, la méthode doit être décorée avec un mot clé appelé @abstractmethod decorator. Le décorateur @abstractmethod doit être importé de la bibliothèque intégrée python appelée abc.
Comment les classes abstraites ont-elles fonctionné en Python?
Python n'a pas de classes abstraites par défaut, mais il a un module ou une bibliothèque qui forme la base pour définir les classes de base abstraites (ABC) et ce nom de module est appelé ABC. Il marque la méthode de la classe de base comme classe de base abstraite, puis produit des classes concrètes comme implémentations de la base abstraite. Une méthode se transforme en méthode abstraite à l'aide d'un mot-clé décorateur appelé @abstractmethod.
Le module ABC est utilisé pour créer les classes abstraites, @ abstractmethod est le décorateur utilisé pour déclarer la méthode abstraite. Le module ABC établit un contrat entre la classe de base et la classe concrète.
Le module abc fournit la base pour définir des classes de base abstraites (ABC) en Python. Le module collections possède des classes concrètes dérivées de ABC et elles peuvent être divisées davantage. En dehors de tout cela, le module de collections contient également un ABC qui peut être utilisé pour tester si une classe ou une instance fournit une interface particulière ou non.
Ce module fournit la classe suivante:
classe abc.ABCMeta
La métaclasse est utilisée pour définir les classes de base abstraites (ABC)
Nous utilisons une métaclasse pour créer une classe de base abstraite.
from abc import ABCMeta
class C:
__metaclass__ = ABCMeta
MyABC.register(tuple)
assert issubclass(tuple, C)
assert isinstance((), C)
Exemple
# 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())
Sortie obtenue
Ceci est une méthode concrète
16
16
Ceci est une méthode concrète
8
12
Dans l'exemple ci-dessus, la classe Abstract est Shape qui contient une méthode concrète appelée commune et deux méthodes abstraites appelées aire et périmètre. Il existe deux classes enfant Square et Rectangle qui héritent de la classe abstraite Shape et implémentent la méthode abstraite.
Mise en œuvre par sous-classement:
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))
Propriétés abstraites
Les classes abstraites contiennent des propriétés abstraites ainsi que des méthodes abstraites définies par @abstractproperty.
Nous pouvons maintenant utiliser property, property.getter (), property.setter () et property.deleter () avec des classes abstraites.
Syntaxe
class class_name(ABC):
@property
@abstractmethod
Def method(self):
Cela définit la propriété en lecture seule.
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)
Production:
Impossible d'instancier la forme de classe abstraite avec la zone de méthode abstraite
Classe carrée
Conclusion
Enfin, je conclus que la classe abstraite est un moyen d'assurer un certain niveau de qualité de code car elle applique certaines normes et peut réduire la quantité de code en double que nous écrivons. Il établit une connexion entre la classe de base et la classe concrète. Il fournit une implémentation facile du code. Il définit une structure généralisée de méthodes sans sa mise en œuvre complète. Il facilite la vie du programmeur en faisant abstraction du processus d'arrière-plan et en le concentrant uniquement sur des points importants. Il rend la recherche et la compréhensibilité beaucoup plus rapides en comprenant la structure commune et simple des classes dans le code.
Articles recommandés
Ceci est un guide de la classe abstraite en Python. Nous discutons ici comment les classes abstraites fonctionnent en Python avec l'importance et les méthodes avec des exemples appropriés. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Opérations sur les fichiers Python
- Encapsulation en Python
- Boucles en Python
- Constructeur en Python
- Ensembles Python
- Introduction à la classe abstraite en PHP