O que é uma classe abstrata?

Uma classe abstrata é uma classe, mas não uma classe da qual você pode criar objetos diretamente. Sua finalidade é definir como outras classes devem se parecer, ou seja, quais métodos e propriedades elas devem ter.

Os métodos e propriedades definidos (mas não implementados) em uma classe abstrata são chamados de métodos abstratos e propriedades abstratas . Todos os métodos e propriedades abstratos precisam ser implementados em uma classe filha para poder criar objetos a partir dela.

Podemos criar uma classe abstrata herdando da ABCclasse que faz parte do abcmódulo .

from abc import (
  ABC,
  abstractmethod,
)

class BasicPokemon(ABC):
  def __init__(self, name):
    self.name = name
    self._level = 1
@abstractmethod
  def main_attack(self):
    ...

O que acontece se você tentar criar um objeto BasicPokemondiretamente? TypeError!

Agora, você notará que BasicPokemono __init__método de espera um nameargumento , portanto, o código acima não terá funcionado de qualquer maneira. A coisa a notar aqui é que ele nem vai para o __init__método para verificar isso. O fato de ter um método abstrato que não foi implementado tem precedência e falha por causa disso!

É assim que se usaria a BasicPokemonclasse.

from collections import namedtuple

Attack = namedtuple('Attack', ('name', 'damage'))

class Pikachu(BasicPokemon):
  def main_attack(self):
    return Attack('Thunder Shock', 5)

class Charmander(BasicPokemon):
  def main_attack(self):
    return Attack('Flame Thrower', 5)

Observe que você também pode criar propriedades abstratas usando o mesmo abstractmethoddecorador.

from abc import (
  ABC,
  abstractmethod,
)

class BasicPokemon(ABC):
  def __init__(self, name):
    self.name = name
  @property
  @abstractmethod
  def level(self):
    ...
  @abstractmethod
  def main_attack(self):
    ...

class Pikachu(BasicPokemon):
  @property
  def level(self):
    return 1
def main_attack(self):
    return Attack('Thunder Shock', 5)

Alguns de vocês podem estar se perguntando por que não poderíamos simplesmente usar uma classe normal (ou seja, não herdar de ABC) e gerar um NotImplementerErrorpara métodos que não foram implementados, como no exemplo abaixo.

class NotAbstractBasicPokemon:
  def __init__(self, name):
    self.name = name
    self._level = 1
def main_attack(self):
    raise NotImplementedError()

Por outro lado, tentar criar um objeto de BasicPokemonresulta em um erro imediatamente, como vimos anteriormente.

Quando devo usar uma classe abstrata?

No exemplo que estamos usando neste post, BasicPokemono propósito de 's era ser usado como um modelo para criar outras classes para tipos específicos de Pokémon. Existem alguns benefícios óbvios em ter uma classe abstrata da qual todos precisam herdar para criar um novo Pokémon:

• Evite a duplicação de código.
• Garanta a consistência em como outros implementam as subclasses.
• Certifique-se de que ninguém se esqueça de implementar métodos e propriedades críticas em subclasses.

Conclusão

Neste post, vimos as classes abstratas do Python e como elas nos dão uma maneira de descrever como esperamos que as subclasses sejam implementadas e avisar os usuários (ou seja, outros programadores ou nossos futuros eus) quando partes críticas não são definidas.

• Siga-me no Medium para atualizações.
• Junte-se ao Medium com meu link de referência para acesso ilimitado às postagens. Sua taxa de adesão apoia diretamente a mim e aos escritores que você lê.

[1]https://docs.python.org/3/library/abc.html

[2]https://realpython.com/python-interface/

Mais do mesmo autor.

Calculando Usando Simulações de Monte-Carlo