This document is for an old version of Python that is no longer supported. You should upgrade and read the documentação do Python para versão estável atual.

# 28.8. `abc` — Classes Base Abstratas

Novo na versão 2.6.

Código-fonte: Lib/abc.py

Este módulo fornece a infraestrutura para definir abstract base classes (CBAs) 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 CBAs.)

The `collections` module has some concrete classes that derive from ABCs; these can, of course, be further derived. In addition, the `collections` module has some ABCs that can be used to test whether a class or instance provides a particular interface, for example, if it is hashable or if it is a mapping.

This module provides the following class:

class `abc.``ABCMeta`

  Metaclasse para definir Classe Base Abstrata (CBAs).

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

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

  `register`(subclass)

    Registrar subclasse como uma “subclasse virtual” desta CBA. Por exemplo:

        from abc import ABCMeta

        class MyABC:
            __metaclass__ = ABCMeta

        MyABC.register(tuple)

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

  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.)

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

    Este método deve retornar `True`, `False` ou `NotImplemented`. Se retornar `True`, a subclasse é considerada uma subclasse desta CBA. Se retornar `False`, a subclasse não é considerada uma subclasse desta CBA, 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 CBA:

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

      class MyIterable:
          __metaclass__ = ABCMeta

          @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 `Mylterable` da CBA 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.

It also provides the following decorators:

`abc.``abstractmethod`(function)

  Um decorator indicando métodos abstratos.

  Using this decorator requires that the class’s metaclass is `ABCMeta` or is derived from it. A class that has a metaclass derived from `ABCMeta` cannot be instantiated unless all of its abstract methods and properties are overridden. The abstract methods can be called using any of the normal ‘super’ call mechanisms.

  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, não é tolerado. A `abstractmethod()` afeta apenas subclasses derivadas usando herança regular; “subclasses virtuais” registradas com o método da CBA `register()` não são afetadas.

  Usage:

      class C:
          __metaclass__ = ABCMeta
          @abstractmethod
          def my_abstract_method(self, ...):
              ...

  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.

`abc.``abstractproperty`([fget[, fset[, fdel[, doc]]]])

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

  Using this function requires that the class’s metaclass is `ABCMeta` or is derived from it. A class that has a metaclass derived from `ABCMeta` cannot be instantiated unless all of its abstract methods and properties are overridden. The abstract properties can be called using any of the normal ‘super’ call mechanisms.

  Usage:

      class C:
          __metaclass__ = ABCMeta
          @abstractproperty
          def my_abstract_property(self):
              ...

  This defines a read-only property; you can also define a read-write abstract property using the ‘long’ form of property declaration:

      class C:
          __metaclass__ = ABCMeta
          def getx(self): ...
          def setx(self, value): ...
          x = abstractproperty(getx, setx)

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++.