Prehľad abstraktnej triedy v Pythone
Abstraktné triedy sú triedy, ktoré sú deklarované, ale neobsahujú žiadne implementácie. Dá sa to len zdediť. Abstraktné triedy fungujú ako šablóna pre podtriedy. Abstraktné triedy nemôžu byť konkretizované a vyžadujú podtriedy na implementáciu abstraktných metód. Potrebuje podtriedy na implementáciu abstraktných metód, ktoré sú definované v abstraktných triedach. Abstraktné triedy obsahujú jednu alebo viac abstraktných metód. Abstraktné metódy sú metódy, ktoré sú deklarované bez akýchkoľvek implementácií. Nemôžeme priamo vytvoriť objekt abstraktnej triedy, ale môžeme zdediť základnú triedu a potom objekt vytvoriť. V tejto téme sa budeme učiť o abstraktnej triede v Pythone.
Abstraktná trieda aj konkrétna trieda môžu byť obsiahnuté v triede abstraktov. Použitím abstraktnej triedy môžeme definovať zovšeobecnenú štruktúru metód bez poskytnutia úplných implementácií každej metódy. Abstraktné metódy, ktoré sú definované v abstraktnej triede, obyčajne nemajú telo, ale je možné mať abstraktné metódy s implementáciami v abstraktnej triede a ak sa z takejto abstraktnej triedy získa nejaká podtrieda, musí sa zabezpečiť implementácia takýchto metód., Ak odvodená trieda neimplementuje žiadnu abstraktnú metódu, vyvolá chybu. Objekt abstraktnej triedy nie je možné vytvoriť priamo, ale keď túto abstraktnú triedu použijeme na poskytnutie určitých funkcií základnej triede alebo podradenej triede, môže to urobiť vytvorením objektu základnej triedy.
Dôležitosť abstraktných tried
1. Poskytuje predvolenú funkčnosť základných tried.
2. Definuje spoločné API pre skupinu podtried, užitočné v prípade, keď tretia strana poskytuje doplnky v aplikácii.
3. Užitočný vo veľkom kóde si pamätal, že veľa tried je ťažké.
syntax
From abc import ABC
Class Educba(ABC):
Aby mohla byť akákoľvek trieda považovaná za abstraktnú triedu, musí zdediť ABC metaclass od vstavaného abc modulu python. modul abc importuje metaclass ABC.
Abstraktné metódy v Pythone
Abstraktné metódy sú metódy, ktoré sú deklarované bez akýchkoľvek implementácií.
syntax
from abc import ABC, abstract method
Class Educba(ABC):
@abstractmethod
def mymethod(self):
#empty body
pass
Na definovanie abstraktných metód v abstraktnej triede musí byť táto metóda ozdobená kľúčovým slovom s názvom @abstractmethod decorator. Dekorátor @abstractmethod sa musí importovať z vstavanej knižnice python zvanej abc.
Ako fungovali v triede Abstract Classes?
Python štandardne nemá abstraktné triedy, ale má modul alebo knižnicu, ktorá tvorí základ pre definovanie abstraktných základných tried (ABC) a tento názov modulu sa nazýva ABC. Označuje metódu základnej triedy ako abstraktnú základnú triedu a potom vytvára konkrétne triedy ako implementácie abstraktnej základne. Metóda sa zmení na abstraktnú metódu pomocou kľúčového slova dekorátora nazývaného @abstractmethod.
ABC modul sa používa na vytvorenie abstraktných tried, @ abstractmethod je dekoračné zariadenie používané na deklarovanie metódy abstrakt. Modul ABC zakladá zmluvu medzi základnou a konkrétnou triedou.
Modul abc poskytuje základ pre definovanie abstraktných základných tried (ABC) v Pythone. Modul kolekcií má niektoré konkrétne triedy, ktoré sú odvodené od ABC a môžu sa ďalej deliť. Modul kolekcií okrem toho všetkého obsahuje aj niektoré ABC, ktoré je možné použiť na testovanie, či trieda alebo inštancia poskytuje konkrétne rozhranie alebo nie.
Tento modul poskytuje nasledujúcu triedu:
trieda abc.ABCMeta
Meta-trieda sa používa na definovanie abstraktných základných tried (ABC)
Používame metaclass na vytvorenie abstraktnej základnej triedy.
from abc import ABCMeta
class C:
__metaclass__ = ABCMeta
MyABC.register(tuple)
assert issubclass(tuple, C)
assert isinstance((), C)
príklad
# 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())
Získaný výstup
Toto je konkrétna metóda
16
16
Toto je konkrétna metóda
8
12
Vo vyššie uvedenom príklade je triedou Abstrakt tvar, ktorý obsahuje jednu konkrétnu metódu nazývanú obyčajnú a dve abstraktné metódy nazývané oblasť a obvod. Existujú dve podradené triedy Classes and Rectangle, ktoré zdedia abstraktnú triedu Shape a implementujú abstraktnú metódu.
Implementácia prostredníctvom podtriedy:
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))
Abstraktné vlastnosti
Abstraktné triedy obsahujú abstraktné vlastnosti spolu s abstraktnými metódami definovanými v @abstractproperty.
Teraz môžeme použiť property, property.getter (), property.setter () a property.deleter () s abstraktnými triedami.
syntax
class class_name(ABC):
@property
@abstractmethod
Def method(self):
Toto definuje vlastnosť len na čítanie.
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)
Výkon:
Tvar abstraktnej triedy nemožno vytvoriť s abstraktnou oblasťou metódy
Štvorcová trieda
záver
Nakoniec som dospela k záveru, že abstraktná trieda je spôsob, ako zabezpečiť určitú úroveň kvality kódu, pretože presadzujú určité štandardy a môžu znížiť množstvo duplikovaného kódu, ktorý píšeme. Vytvára spojenie medzi základnou triedou a konkrétnou triedou. Poskytuje ľahkú implementáciu kódu. Definuje zovšeobecnenú štruktúru metód bez jej úplnej implementácie. Život programátora je ľahký tým, že abstraktuje proces na pozadí a zameriava sa iba na dôležité body. Vďaka výskumu bežnej a jednoduchej štruktúry tried v kóde je výskum a zrozumiteľnosť oveľa rýchlejšia.
Odporúčané články
Toto je príručka pre abstraktnú triedu v Pythone. Tu diskutujeme o tom, ako abstraktné triedy fungujú v Pythone s dôležitosťou a metódami s príslušnými príkladmi. Ďalšie informácie nájdete aj v nasledujúcich článkoch -
- Operácie so súbormi Python
- Zapuzdrenie v Pythone
- Slučky v Pythone
- Konštruktor v Pythone
- Sady Pythonu
- Úvod do abstraktnej triedy v PHP