Overzicht van abstracte klasse in Python
Abstracte klassen zijn de klassen die zijn gedeclareerd maar geen implementaties bevatten. Het kan alleen worden geërfd. Abstracte klassen werken als een sjabloon voor de subklassen. Abstracte klassen kunnen niet worden geïnstantieerd en vereisen subklassen om implementaties voor abstracte methoden te bieden. Het heeft subklassen nodig om implementaties te bieden van de abstracte methoden die zijn gedefinieerd in abstracte klassen. Abstracte klassen bevatten een of meer abstracte methoden. Abstracte methoden zijn de methoden die zonder enige implementatie worden gedeclareerd. We kunnen het object van de abstracte klasse niet rechtstreeks maken, maar we kunnen erven aan de basisklasse en vervolgens het object maken. In dit onderwerp gaan we meer te weten komen over Abstract Class in Python.
Zowel de abstracte klasse als de concrete klasse kunnen worden opgenomen in de abstracte klasse. Door een abstracte klasse te gebruiken, kunnen we een algemene structuur van de methoden definiëren zonder volledige implementaties van elke methode te bieden. Abstracte methoden die in de abstracte klasse zijn gedefinieerd, hebben over het algemeen geen body, maar het is mogelijk om abstracte methoden met implementaties in de abstracte klasse te hebben en als een subklasse wordt afgeleid van een dergelijke abstracte klasse, moet de implementatie voor dergelijke methoden worden verstrekt . Als een abstracte methode niet door de afgeleide klasse wordt geïmplementeerd, geeft dit een foutmelding. Het abstracte klasseobject kan niet rechtstreeks worden gemaakt, maar wanneer we deze abstracte klasse gebruiken om bepaalde functies aan een basisklasse of onderliggende klasse te bieden, kan dit door het object van de basisklasse te maken.
Het belang van abstracte klassen
1. Het biedt de standaardfunctionaliteit van de basisklassen.
2. Het definieert een gemeenschappelijke API voor de set van subklassen, handig wanneer een derde plug-ins in een applicatie levert.
3. Nuttig in grote code was het onthouden van veel klassen moeilijk.
Syntaxis
From abc import ABC
Class Educba(ABC):
Om elke klasse als een abstracte klasse te beschouwen, moet de klasse de ABC-metaclass erven van de ingebouwde abc-module van python. abc module importeert de ABC-metaclass.
Abstracte methoden in Python
Abstracte methoden zijn de methoden die zonder enige implementatie worden gedeclareerd.
Syntaxis
from abc import ABC, abstract method
Class Educba(ABC):
@abstractmethod
def mymethod(self):
#empty body
pass
Om de abstracte methoden in een abstracte klasse te definiëren, moet de methode worden gedecoreerd met een trefwoord met de naam @abstractmethod decorateur. De decorateur @abstractmethod moet worden geïmporteerd uit de ingebouwde python-bibliotheek genaamd abc.
Hoe werkte Abstract Classes in Python?
Python heeft standaard geen abstracte klassen, maar het heeft een module of bibliotheek die de basis vormt voor het definiëren van abstracte basisklassen (ABC) en die modulenaam wordt ABC genoemd. Het markeert de methode van de basisklasse als de abstracte basisklasse en produceert vervolgens concrete klassen als implementaties van de abstracte basis. Een methode verandert in een abstracte methode met behulp van een sleutelwoord voor de decorateur genaamd @abstractmethod.
ABC-module wordt gebruikt om de abstracte klassen te maken, @ abstractmethod is de decorateur die wordt gebruikt om de methode abstract te verklaren. ABC-module stelt een contract vast tussen de basisklasse en de concrete klasse.
De abc-module biedt de basis voor het definiëren van abstracte basisklassen (ABC) in Python. De verzamelmodule heeft een aantal concrete klassen die zijn afgeleid van ABC en die verder kunnen worden verdeeld. Afgezien van al deze, bevat de collectiesmodule ook wat ABC dat kan worden gebruikt om te testen of een klasse of instantie een bepaalde interface biedt of niet.
Deze module biedt de volgende klasse:
klasse abc.ABCMeta
De metaclass wordt gebruikt voor het definiëren van abstracte basisklassen (ABC)
We gebruiken een metaclass om een abstracte basisklasse te maken.
from abc import ABCMeta
class C:
__metaclass__ = ABCMeta
MyABC.register(tuple)
assert issubclass(tuple, C)
assert isinstance((), C)
Voorbeeld
# 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())
Output verkregen
Dit is een concrete methode
16
16
Dit is een concrete methode
8
12
In het bovenstaande voorbeeld is de klasse Abstract de vorm die een concrete methode bevat die algemeen wordt genoemd en twee abstracte methoden die gebied en omtrek worden genoemd. Er zijn twee onderliggende klassen Vierkant en Rechthoek die de abstracte klassenvorm erven en de abstracte methode implementeren.
Implementatie via subklasse:
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))
Abstracte eigenschappen
Abstracte klassen bevatten abstracte eigenschappen samen met abstracte methoden gedefinieerd door @abstractproperty.
We kunnen nu property, property.getter (), property.setter () en property.deleter () gebruiken met abstracte klassen.
Syntaxis
class class_name(ABC):
@property
@abstractmethod
Def method(self):
Dit definieert de alleen-lezen eigenschap.
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)
Output:
Kan abstracte klasse Shape met abstract methodegebied niet instantiëren
Vierkante klas
Conclusie
Ten slotte concludeer ik dat abstracte klasse een manier is om een bepaald niveau van codekwaliteit te waarborgen, omdat ze bepaalde normen afdwingen en de hoeveelheid dubbele code die we schrijven kan verminderen. Het legt een verband tussen de basisklasse en de concrete klasse. Het biedt een eenvoudige implementatie van code. Het definieert een algemene methodestructuur zonder de volledige implementatie ervan. Het maakt het leven van de programmeur gemakkelijk door het achtergrondproces samen te vatten en zich alleen op belangrijke punten te concentreren. Het maakt het onderzoek en de begrijpelijkheid veel sneller door de gemeenschappelijke en eenvoudige structuur van klassen binnen de code te begrijpen.
Aanbevolen artikelen
Dit is een gids voor Abstract Class in Python. Hier bespreken we hoe Abstract Classes werken in Python met het belang en de methoden met passende voorbeelden. U kunt ook de volgende artikelen bekijken voor meer informatie -
- Python-bestandsbewerkingen
- Inkapseling in Python
- Lussen in Python
- Aannemer in Python
- Python-sets
- Introductie tot Abstract Class in PHP