# `abc` — Classes base abstratas

Código-fonte: Lib/abc.py

Este módulo fornece a infraestrutura para definir classes base abstratas (ABCs, do inglês abstract base class) em Python, como delineado em PEP 3119; veja o PEP para entender o porquê isto foi adicionado ao Python. (Veja também PEP 3141 e o módulo `numbers` sobre uma hierarquia de tipo para números baseado nas ABCs.)

O módulo `collections` tem algumas classes concretas que derivam de ABCs; essas podem, evidentemente, ser ainda mais derivadas. Além disso, o submódulo `collections.abc` tem algumas ABCs que podem ser usadas para testar se uma classe ou instância oferece uma interface particular, por exemplo, se é hasheável ou se é um mapeamento.

Este módulo fornece a metaclasse `ABCMeta` para definir ABCs e uma classe auxiliar `ABC` para alternativamente definir ABCs através de herança:

class abc.ABC

  Uma classe auxiliar que tem `ABCMeta` como sua metaclasse. Com essa classe, uma classe base abstrata pode ser criada simplesmente derivando da `ABC` evitando às vezes confundir o uso da metaclasse, por exemplo:

      from abc import ABC

      class MyABC(ABC):
          pass

  Note que o tipo da classe `ABC` ainda é `ABCMeta`, portanto herdar da `ABC` requer as precauções usuais a respeito do uso da metaclasse, pois herança múltipla pode levar a conflitos de metaclasse. Pode-se também definir uma classe base abstrata ao passar a palavra reservada metaclasse e usar `ABCMeta` diretamente, por exemplo:

      from abc import ABCMeta

      class MyABC(metaclass=ABCMeta):
          pass

  Adicionado na versão 3.4.

class abc.ABCMeta

  Metaclasse para definir Classe Base Abstrata (ABCs).

  Use esta metaclasse para criar uma ABC. Uma ABC pode ser diretamente estendida, e então agir como uma classe misturada. Você também pode registrar classes concretas não relacionadas (até mesmo classes embutidas) e ABCs não relacionadas como “subclasses virtuais” – estas e suas descendentes serão consideradas subclasses da ABC de registro pela função embutida `issubclass()`, mas a ABC de registro não irá aparecer na MRO (Ordem de Resolução do Método) e nem as implementações do método definidas pela ABC de registro será chamável (nem mesmo via `super()`). [1]

  Classes criadas com a metaclasse de `ABCMeta` tem o seguinte método:

  register(subclass)

    Registra subclass como uma “subclasse virtual” desta ABC. Por exemplo:

        from abc import ABC

        class MyABC(ABC):
            pass

        MyABC.register(tuple)

        assert issubclass(tuple, MyABC)
        assert isinstance((), MyABC)

    Alterado na versão 3.3: Retorna a subclasse registrada, para permitir o uso como um decorador de classe.

    Alterado na versão 3.4: Para detectar chamadas para `register()`, você pode usar a função `get_cache_token()`.

  Você também pode sobrepor este método em uma classe base abstrata:

  __subclasshook__(subclass)

    (Deve obrigatoriamente ser definido como um método de classe.)

    Verifica se subclass é considerada uma subclasse desta ABC. Isto significa que você pode personalizar ainda mais o comportamento de `issubclass()` sem a necessidade de chamar `register()` em toda classe que você queira considerar uma subclasse da ABC. (Este método de classe é chamado do método `__subclasscheck__()` da ABC.)

    Este método deve retornar `True`, `False` ou `NotImplemented`. Se retornar `True`, subclass é considerada uma subclasse desta ABC. Se retornar `False`, subclass não é considerada uma subclasse desta ABC, mesmo que normalmente seria uma. Se retornar `NotImplemented`, a verificação da subclasse é continuada com o mecanismo usual.

  Para uma demonstração destes conceitos, veja este exemplo de definição ABC:

      class Foo:
          def __getitem__(self, index):
              ...
          def __len__(self):
              ...
          def get_iterator(self):
              return iter(self)

      class MyIterable(ABC):

          @abstractmethod
          def __iter__(self):
              while False:
                  yield None

          def get_iterator(self):
              return self.__iter__()

          @classmethod
          def __subclasshook__(cls, C):
              if cls is MyIterable:
                  if any("__iter__" in B.__dict__ for B in C.__mro__):
                      return True
              return NotImplemented

      MyIterable.register(Foo)

  A `MyIterable` da ABC define o método iterável padrão, `__iter__()`, como um método abstrato. A implementação dada aqui pode ainda ser chamada da subclasse. O método `get_iterator()` é também parte da classe base abstrata `MyIterable`, mas não precisa ser substituído nas classes derivadas não abstratas.

  O método de classe `__subclasshook__()` definido aqui diz que qualquer classe que tenha um método `__iter__()` em seu `__dict__` (ou no de uma de suas classes base, acessados via lista `__mro__`) é considerada uma `MyIterable` também.

  Finalmente, a última linha faz de `Foo` uma subclasse virtual da `MyIterable`, apesar de não definir um método `__iter__()` (ela usa o protocolo iterável antigo, definido em termos de `__len__()` e `__getitem__()`). Note que isto não fará o `get_iterator` disponível como um método de `Foo`, então ele é fornecido separadamente.

O módulo `abc` também fornece o seguinte decorador:

@abc.abstractmethod

  Um decorador indicando métodos abstratos.

  Usar este decorador requer que a metaclasse da classe seja `ABCMeta` ou seja derivada desta. Uma classe que tem uma metaclasse derivada de `ABCMeta` não pode ser instanciada, a menos que todos os seus métodos abstratos e propriedades estejam substituídos. Os métodos abstratos podem ser chamados usando qualquer um dos mecanismos normais de chamadas a ‘super’. `abstractmethod()` pode ser usado para declarar métodos abstratos para propriedades e descritores.

  Adicionar dinamicamente métodos abstratos a uma classe, ou tentar modificar o status de abstração de um método ou classe uma vez que estejam criados, só é suportado usando a função `update_abstractmethods()`. A `abstractmethod()` afeta apenas subclasses derivadas usando herança regular; “subclasses virtuais” registradas com o método `register()` da ABC não são afetadas.

  Quando `abstractmethod()` é aplicado em combinação com outros descritores de método, ele deve ser aplicado como o decorador mais interno, como mostrado nos seguintes exemplos de uso:

      class C(ABC):
          @abstractmethod
          def my_abstract_method(self, arg1):
              ...
          @classmethod
          @abstractmethod
          def my_abstract_classmethod(cls, arg2):
              ...
          @staticmethod
          @abstractmethod
          def my_abstract_staticmethod(arg3):
              ...

          @property
          @abstractmethod
          def my_abstract_property(self):
              ...
          @my_abstract_property.setter
          @abstractmethod
          def my_abstract_property(self, val):
              ...

          @abstractmethod
          def _get_x(self):
              ...
          @abstractmethod
          def _set_x(self, val):
              ...
          x = property(_get_x, _set_x)

  Para que interopere corretamente com o maquinário da classe base abstrata, o descritor precisa identificar-se como abstrato usando `__isabstractmethod__`. No geral, este atributo deve ser `True` se algum dos métodos usados para compor o descritor for abstrato. Por exemplo, a `property` embutida do Python faz o equivalente a:

      class Descriptor:
          ...
          @property
          def __isabstractmethod__(self):
              return any(getattr(f, '__isabstractmethod__', False) for
                         f in (self._fget, self._fset, self._fdel))

  Nota

  Diferente de métodos abstratos Java, esses métodos abstratos podem ter uma implementação. Esta implementação pode ser chamada via mecanismo da `super()` da classe que a substitui. Isto pode ser útil como um ponto final para uma super chamada em um framework que usa herança múltipla cooperativa.

O módulo `abc` também suporta os seguintes decoradores herdados:

@abc.abstractclassmethod

  Adicionado na versão 3.2.

  Descontinuado desde a versão 3.3: Agora é possível usar `classmethod` com `abstractmethod()`, tornando redundante este decorador.

  Uma subclasse da `classmethod()` embutida, indicando um método de classe abstrato. Caso contrário, é similar à `abstractmethod()`.

  Este caso especial está descontinuado, pois o decorador da `classmethod()` está agora corretamente identificado como abstrato quando aplicado a um método abstrato:

      class C(ABC):
          @classmethod
          @abstractmethod
          def my_abstract_classmethod(cls, arg):
              ...

@abc.abstractstaticmethod

  Adicionado na versão 3.2.

  Descontinuado desde a versão 3.3: Agora é possível usar `staticmethod` com `abstractmethod()`, tornando redundante este decorador.

  Uma subclasse da `staticmethod()` embutida, indicando um método estático abstrato. Caso contrário, ela é similar à `abstractmethod()`.

  Este caso especial está descontinuado, pois o decorador da `staticmethod()` está agora corretamente identificado como abstrato quando aplicado a um método abstrato:

      class C(ABC):
          @staticmethod
          @abstractmethod
          def my_abstract_staticmethod(arg):
              ...

@abc.abstractproperty

  Descontinuado desde a versão 3.3: Agora é possível usar `property`, `property.getter()`, `property.setter()` e `property.deleter()` com `abstractmethod()`, tornando redundante este decorador.

  Uma subclasse da `property()` embutida, indicando uma propriedade abstrata.

  Este caso especial está descontinuado, pois o decorador da `property()` está agora corretamente identificado como abstrato quando aplicado a um método abstrato:

      class C(ABC):
          @property
          @abstractmethod
          def my_abstract_property(self):
              ...

  O exemplo acima define uma propriedade somente leitura; você também pode definir uma propriedade abstrata de leitura e escrita marcando apropriadamente um ou mais dos métodos subjacentes como abstratos:

      class C(ABC):
          @property
          def x(self):
              ...

          @x.setter
          @abstractmethod
          def x(self, val):
              ...

  Se apenas alguns componentes são abstratos, apenas estes componentes precisam ser atualizados para criar uma propriedade concreta em uma subclasse:

      class D(C):
          @C.x.setter
          def x(self, val):
              ...

O módulo `abc` também fornece as seguintes funções:

abc.get_cache_token()

  Retorna o token de cache da classe base abstrata atual.

  O token é um objeto opaco (que suporta teste de igualdade) identificando a versão atual do cache da classe base abstrata para subclasses virtuais. O token muda a cada chamada ao `ABCMeta.register()` em qualquer CBA.

  Adicionado na versão 3.4.

abc.update_abstractmethods(cls)

  Uma função para recalcular o status de abstração de uma classe abstrata. Esta função deve ser chamada se os métodos abstratos de uma classe foram implementados ou alterados após sua criação. Normalmente, essa função deve ser chamada de dentro de um decorador de classe.

  Retorna cls, para permitir o uso como decorador de classe.

  Se cls não for uma instância de `ABCMeta`, não faz nada.

  Nota

  Esta função presume que as superclasses de cls já estão atualizadas. Ele não atualiza nenhuma subclasse.

  Adicionado na versão 3.10.

Notas de rodapé

[ 1 ]

Programadores C++ devem notar que o conceito da classe base virtual do Python não é o mesmo que o de C++.