Na discussão sobre herança e mixins foram criadas várias classes, como Autenticavel
e AutenticavelComRegistro
que adicionam funcionalidades a outras classes e implementavam tudo o que precisavam para seu funcionamento. Entretanto podem existir casos em que não seja possível implementar todas as funções na própria classe, deixando com que as classes que a estende implemente essas funções. Uma forma de fazer isso é través das ABC (abstract base classes, ou classes base abstratas).
Sem uso de classes base abstratas
Um exemplo de classe que não é possível implementar todas as funcionalidades foi dada no texto Encapsulamento da lógica do algoritmo, que discutia a leitura de valores do teclado até que um valor válido fosse lido (ou que repete a leitura caso um valor inválido tivesse sido informado). Nesse caso a classe ValidaInput
implementava a lógica base de funcionamento, porém eram suas classes filhas (ValidaNomeInput
e ValidaNotaInput
) que implementavam as funções para tratar o que foi lido do teclado e verificar se é um valor válido ou não.
class ValidaInput:
mensagem_valor_invalido = 'Valor inválido!'
def ler_entrada(self, prompt):
return input(prompt)
def transformar_entrada(self, entrada):
raise NotImplementedError
def validar_valor(self, valor):
raise NotImplementedError
def __call__(self, prompt):
while True:
try:
valor = self.transformar_entrada(self.ler_entrada(prompt))
if self.validar_valor(valor):
break
except ValueError:
...
print(self.mensagem_valor_invalido)
return valor
class ValidaNomeInput(ValidaInput):
mensagem_valor_invalido = 'Nome inválido!'
def transformar_entrada(self, entrada):
return entrada.strip().title()
def validar_valor(self, valor):
return valor != ''
class ValidaNotaInput(ValidaInput):
mensagem_valor_invalido = 'Nota inválida!'
def transformar_entrada(self, entrada):
return float(entrada)
def validar_valor(self, valor):
return 0 <= valor <= 10
Entretanto, esse código permite a criação de objetos da classe ValidaInput
mesmo sem ter uma implementação das funções transformar_entrada
e validar_valor
. E a única mensagem de erro ocorreria ao tentar executar essas funções, o que poderia estar longe do problema real, que é a criação de um objeto a partir de uma classe que não prove todas as implementações das suas funções, o que seria semelhante a uma classe abstrata em outras linguagens.
obj = ValidaInput()
# Diversas linhas de código
obj('Entrada: ') # Exceção NotImplementedError lançada
Com uso de classes base abstratas
Seguindo a documentação da ABC, para utilizá-las é necessário informar a metaclasse ABCMeta
na criação da classe, ou simplesmente estender a classe ABC
, e decorar com abstractmethod
as funções que as classes que a estenderem deverão implementar. Exemplo:
from abc import ABC, abstractmethod
class ValidaInput(ABC):
mensagem_valor_invalido = 'Valor inválido!'
def ler_entrada(self, prompt):
return input(prompt)
@abstractmethod
def transformar_entrada(self, entrada):
...
@abstractmethod
def validar_valor(self, valor):
...
def __call__(self, prompt):
while True:
try:
valor = self.transformar_entrada(self.ler_entrada(prompt))
if self.validar_valor(valor):
break
except ValueError:
...
print(self.mensagem_valor_invalido)
return valor
Desta forma, ocorrerá um erro já ao tentar criar um objeto do tipo ValidaInput
, dizendo quais são as funções que precisam ser implementadas. Porém funcionará normalmente ao criar objetos a partir das classes ValidaNomeInput
e ValidaNotaInput
visto que elas implementam essas funções.
obj = ValidaInput() # Exceção TypeError lançada
nome_input = ValidaNomeInput() # Objeto criado
nota_input = ValidaNotaInput() # Objeto criado
Como essas funções não utilizam a referência ao objeto (self
), ainda é possível decorar as funções com staticmethod
, como:
from abc import ABC, abstractmethod
class ValidaInput(ABC):
mensagem_valor_invalido = 'Valor inválido!'
@staticmethod
def ler_entrada(prompt):
return input(prompt)
@staticmethod
@abstractmethod
def transformar_entrada(entrada):
...
@staticmethod
@abstractmethod
def validar_valor(valor):
...
def __call__(self, prompt):
while True:
try:
valor = self.transformar_entrada(self.ler_entrada(prompt))
if self.validar_valor(valor):
break
except ValueError:
...
print(self.mensagem_valor_invalido)
return valor
class ValidaNomeInput(ValidaInput):
mensagem_valor_invalido = 'Nome inválido!'
@staticmethod
def transformar_entrada(entrada):
return entrada.strip().title()
@staticmethod
def validar_valor(valor):
return valor != ''
class ValidaNotaInput(ValidaInput):
mensagem_valor_invalido = 'Nota inválida!'
@staticmethod
def transformar_entrada(entrada):
return float(entrada)
@staticmethod
def validar_valor(valor):
return 0 <= valor <= 10
Isso também seria válido para funções decoradas com classmethod
, que receberiam a referência a classe (cls
).
Considerações
Não é necessário utilizar ABC para fazer o exemplo discutido, porém ao utilizar essa biblioteca ficou mais explícito quais as funções que precisavam ser implementados nas classes filhas, ainda mais que sem utilizar ABC a classe base poderia nem ter as funções, com:
class ValidaInput:
mensagem_valor_invalido = 'Valor inválido!'
def ler_entrada(self, prompt):
return input(prompt)
def __call__(self, prompt):
while True:
try:
valor = self.transformar_entrada(self.ler_entrada(prompt))
if self.validar_valor(valor):
break
except ValueError:
...
print(self.mensagem_valor_invalido)
return valor
Como Python possui duck-typing, não é necessário uma grande preocupação com os tipos, como definir e utilizar interfaces presentes em outras implementações de orientação a objetos, porém devido à herança múltipla, ABC pode ser utilizada como interface que não existe em Python, fazendo com que as classes implementem determinadas funções. Para mais a respeito desse assunto, recomendo as duas lives do dunossauro sobre ABC (1 e 2), e a apresentação do Luciano Ramalho sobre type hints.
Uma classe filha também não é obrigada a implementar todas as funções decoradas com abstractmethod
, mas assim como a classe pai, não será possível criar objetos a partir dessa classe, apenas de uma classe filha dela que implemente as demais funções. Como se ao aplicar um abstractmethod
tornasse a classe abstrata, e qualquer classe filha só deixasse de ser abstrata quando a última função decorada com abstractmethod
for sobrescrita. Exemplo:
from abc import ABC, abstractmethod
class A(ABC):
@abstractmethod
def func1(self):
...
@abstractmethod
def func2(self):
...
class B(A):
def func1(self):
print('1')
class C(B):
def func2(self):
print('2')
a = A() # Erro por não implementar func1 e func2
b = B() # Erro por não implementar func2
c = C() # Objeto criado
Top comments (0)