Visão geral da classe abstrata em Python
Classes abstratas são as classes declaradas, mas não contêm implementações. Só pode ser herdado. As classes abstratas funcionam como um modelo para as subclasses. Classes abstratas não podem ser instanciadas e requerem subclasses para fornecer implementações para métodos abstratos. Ele precisa de subclasses para fornecer implementações dos métodos abstratos definidos nas classes Abstratas. As classes abstratas contêm um ou mais métodos abstratos. Métodos abstratos são os métodos declarados sem nenhuma implementação. Não podemos criar diretamente o objeto da classe abstrata, mas podemos herdar a classe base e, em seguida, criar o objeto. Neste tópico, vamos aprender sobre a classe abstrata em Python.
Tanto a classe abstrata quanto a concreta podem estar contidas na classe Abstrata. Usando uma classe abstrata, podemos definir uma estrutura generalizada dos métodos sem fornecer implementações completas de todos os métodos. Métodos abstratos que são definidos na classe abstrata geralmente não têm o corpo, mas é possível ter métodos abstratos com implementações na classe abstrata e se alguma subclasse está sendo derivada dessa classe abstrata precisa fornecer a implementação para esses métodos . Se algum método abstrato não for implementado pela classe derivada, ele emitirá um erro. O objeto da classe abstrata não pode ser criado diretamente, mas quando usamos essa classe abstrata para fornecer determinadas funcionalidades a uma classe base ou classe filho, é possível fazer isso criando o objeto da classe base.
Importância das Classes Abstratas
1. Ele fornece a funcionalidade padrão das classes base.
2. Ele define uma API comum para o conjunto de subclasses, útil quando terceiros estão fornecendo plugins em um aplicativo.
3. Útil em código grande foi lembrar que muitas classes é difícil.
Sintaxe
From abc import ABC
Class Educba(ABC):
Para considerar qualquer classe como uma classe abstrata, a classe deve herdar a metaclasse ABC do módulo abc interno do python. O módulo abc importa a metaclasse ABC.
Métodos abstratos em Python
Métodos abstratos são os métodos declarados sem nenhuma implementação.
Sintaxe
from abc import ABC, abstract method
Class Educba(ABC):
@abstractmethod
def mymethod(self):
#empty body
pass
Para definir os métodos abstratos em uma classe abstrata, o método deve ser decorado com uma palavra-chave chamada @abstractmethod decorator. O decorador @abstractmethod deve ser importado da biblioteca interna python chamada abc.
Como as Classes Abstratas funcionam em Python?
O Python não possui classes abstratas por padrão, mas possui um módulo ou biblioteca que forma a base para a definição de ABC (Abstract Base Class) e esse nome de módulo é chamado ABC. Ele marca o método da classe base como a classe base abstrata e depois produz classes concretas como implementações da base abstrata. Um método se transforma em um método abstrato com a ajuda de uma palavra-chave decoradora chamada @abstractmethod.
O módulo ABC é usado para criar as classes abstratas, @ abstractmethod é o decorador usado para declarar o método abstrato. O módulo ABC estabelece um contrato entre a classe base e a classe concreta.
O módulo abc fornece a base para a definição de classes básicas abstratas (ABC) em Python. O módulo de coleções possui algumas classes concretas derivadas do ABC e podem ser divididas ainda mais. Além de tudo isso, o módulo de coleções também contém alguns ABC que podem ser usados para testar se uma classe ou instância fornece uma interface específica ou não.
Este módulo fornece a seguinte classe:
classe abc.ABCMeta
A metaclasse é usada para definir as classes básicas abstratas (ABC)
Usamos uma metaclasse para criar uma classe base abstrata.
from abc import ABCMeta
class C:
__metaclass__ = ABCMeta
MyABC.register(tuple)
assert issubclass(tuple, C)
assert isinstance((), C)
Exemplo
# 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())
Saída obtida
Este é um método concreto
16
16
Este é um método concreto
8
12
No exemplo acima, a classe Abstract é Shape, que contém um método concreto chamado comum e dois métodos abstratos chamados area e perímetro. Existem duas Classes filho Square e Rectangle que herdam a classe abstrata Shape e implementam o método abstrato.
Implementação por meio de subclassificação:
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))
Propriedades abstratas
Classes abstratas contêm propriedades abstratas juntamente com métodos abstratos definidos por @abstractproperty.
Agora podemos usar property, property.getter (), property.setter () e property.deleter () com classes abstratas.
Sintaxe
class class_name(ABC):
@property
@abstractmethod
Def method(self):
Isso define a propriedade somente leitura.
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)
Resultado:
Não é possível instanciar a classe abstrata Shape com a área de método abstrato
Classe quadrada
Conclusão
Por fim, concluo que a classe abstrata é uma maneira de garantir um certo nível de qualidade do código, porque elas impõem certos padrões e podem reduzir a quantidade de código duplicado que escrevemos. Estabelece uma conexão entre a classe base e a classe concreta. Ele fornece uma fácil implementação de código. Ele define uma estrutura generalizada de métodos sem sua implementação completa. Facilita a vida do programador, abstraindo o processo em segundo plano e concentrando-o apenas em pontos importantes. Isso torna a pesquisa e a compreensibilidade muito mais rápidas, entendendo a estrutura comum e simples das classes dentro do código.
Artigos recomendados
Este é um guia para a classe abstrata em Python. Aqui discutimos como as Classes Abstratas funcionam em Python com a importância e os métodos com exemplos apropriados. Você também pode consultar os seguintes artigos para saber mais -
- Operações de arquivo Python
- Encapsulamento em Python
- Loops em Python
- Construtor em Python
- Conjuntos Python
- Introdução à classe abstrata em PHP