Een abstracte klasse kan worden beschouwd als een blauwdruk voor anderen klassen . Hiermee kunt u een reeks methoden maken die moeten worden gemaakt binnen alle onderliggende klassen die zijn opgebouwd uit de abstracte klasse.

Een klasse die een of meer abstracte methoden bevat, wordt an genoemd abstracte klasse . Een abstracte methode is een methode die een declaratie heeft maar geen implementatie.

We gebruiken een abstracte klasse terwijl we grote functionele eenheden ontwerpen of wanneer we een gemeenschappelijke interface willen bieden voor verschillende implementaties van een component.

Abstracte basisklassen in Python

Door een abstracte basisklasse te definiëren, kunt u een gemeenschappelijke klasse definiëren Applicatieprogramma-interface (API) voor een reeks subklassen. Deze mogelijkheid is vooral handig in situaties waarin een derde partij implementaties gaat verzorgen, zoals bij plug-ins, maar kan u ook helpen wanneer u in een groot team of met een grote codebasis werkt, waarbij het moeilijk is om alle klassen in gedachten te houden. mogelijk.

Werken aan Python Abstract-lessen

Standaard, Python voorziet niet abstracte klassen . Python wordt geleverd met een module die de basis biedt voor het definiëren van A bstract Basisklassen (ABC) en die modulenaam is abc .

hoe een json-bestand te lezen

abc werkt door methoden van de basisklasse als een abstract te decoreren en vervolgens concrete klassen te registreren als implementaties van de abstracte basis. Een methode wordt abstract als deze wordt versierd met het trefwoord @abstractmethod.

Voorbeeld 1:

Deze code definieert een abstracte basisklasse genaamd Veelhoek met behulp van de ABC-module (Abstract Base Class) in Python. De klasse Polygon heeft een abstracte methode genaamd noofsides dat moet worden geïmplementeerd door de subklassen ervan.

Er zijn vier subklassen van Polygon gedefinieerd: Triangle, Pentagon, Hexagon en Quadrilateral. Elk van deze subklassen heeft voorrang op de noofsides-methode en biedt zijn eigen implementatie door het aantal zijden af ​​te drukken.

In de stuurprogrammacode worden exemplaren van elke subklasse gemaakt en wordt voor elke instantie de noofsides-methode aangeroepen om het aantal zijden weer te geven dat specifiek is voor die vorm.

# 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>

Voorbeeld 2:

Hier definieert deze code een abstracte basisklasse genaamd Animal met behulp van de ABC-module (Abstract Base Class) in Python. De klasse Animal heeft een niet-abstracte methode genaamd move, die geen enkele implementatie heeft. Er zijn vier subklassen van Dieren gedefinieerd: Mens, Slang, Hond en Leeuw. Elk van deze subklassen heeft voorrang op de verplaatsingsmethode en biedt zijn eigen implementatie door een specifiek bewegingskenmerk af te drukken.

# 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>

Implementatie van Abstract via subklasse

Door rechtstreeks vanuit de basis een subklasse te maken, kunnen we voorkomen dat de klasse expliciet moet worden geregistreerd. In dit geval wordt het Python-klassebeheer gebruikt om te herkennen Implementatie van plug-ins als uitvoering van de abstracte PluginBase .

# 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>

Een neveneffect van het gebruik van directe subklassen is dat het mogelijk is om alle implementaties van uw plug-in te vinden door de basisklasse te vragen naar de lijst met bekende klassen die daarvan zijn afgeleid.

Concrete methoden in abstracte basisklassen

Concrete klassen bevatten alleen concrete (normale) methoden, terwijl abstracte klassen zowel concrete methoden als abstracte methoden kunnen bevatten.

De concrete klasse biedt een implementatie van abstracte methoden, de abstracte basisklasse kan ook een implementatie bieden door de methoden aan te roepen via super(). Laten we het voorbeeld bekijken om de methode aan te roepen met 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>

In het bovenstaande programma kunnen we de methoden in abstracte klassen aanroepen met behulp van super().

Abstracte eigenschappen in Python

Abstracte klassen omvatten naast methoden ook attributen. U kunt de attributen in concrete klassen vereisen door ze te definiëren met @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>

In het bovenstaande voorbeeld kan de klasse Base niet worden geïnstantieerd omdat deze alleen een abstracte versie van de property-getter-methode heeft.

Instantiatie van abstracte klassen

Abstracte klassen zijn onvolledig omdat ze methoden hebben die niemand hebben. Als Python het maken van een object voor abstracte klassen toestaat, gebruik dan dat object als iemand de abstracte methode aanroept, maar er is geen daadwerkelijke implementatie om aan te roepen.

We gebruiken dus een abstracte klasse als sjabloon en afhankelijk van de behoefte breiden we deze uit en bouwen erop voort voordat we hem kunnen gebruiken. Vanwege het feit dat een abstracte klasse geen concrete klasse is, kan deze niet worden geïnstantieerd. Wanneer we een object voor de abstracte klasse maken, is dit het geval geeft een foutmelding .

# 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()>

Uitgang:

1 miljard tot miljoen

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>