29.7. abc
— Classes Base Abstratas¶
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 tipos 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.abc
submodule has some ABCs that can be used to test whether
a class or instance provides a particular interface, for example, is it
hashable or a mapping.
This module provides the following classes:
-
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 viasuper()
). [1]Classes criadas com a metaclasse de :classe:`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): 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çãoget_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.)
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 chamarregister()
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
ouNotImplemented
. Se retornarTrue
, a subclasse é considerada uma subclasse desta CBA. Se retornarFalse
, a subclasse não é considerada uma subclasse desta CBA, mesmo que normalmente seria uma. Se retornarNotImplemented
, 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: 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 CBA
Mylterable
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étodoget_iterator()
é também parte da classe base abstrataMyIterable
, 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__
) é considerado umaMyIterable
também.Finalmente, a última linha faz de
Foo
uma subclasse virtual daMyIterable
, 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á oget_iterator
disponível como um método deFoo
, então ele é fornecido separadamente.-
-
class
abc.
ABC
¶ A helper class that has
ABCMeta
as its metaclass. With this class, an abstract base class can be created by simply deriving fromABC
, avoiding sometimes confusing metaclass usage.Note that the type of
ABC
is stillABCMeta
, therefore inheriting fromABC
requires the usual precautions regarding metaclass usage, as multiple inheritance may lead to metaclass conflicts.Novo na versão 3.4.
The abc
module also provides the following decorators:
-
@
abc.
abstractmethod
¶ Um decorator indicando métodos abstratos.
Usar este decorador requer que a metaclasse da classe seja :classe:`ABCMeta` ou seja derivada desta. Uma classe que tem uma metaclasse derivada de :classe:`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 mechanismos normais de ‘super’ chamadas.
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, não é tolerado. A
abstractmethod()
afeta apenas subclasses derivadas usando herança regular; “subclasses virtuais” registradas com o método da CBAregister()
não são afetadas.Quando
abstractmethod()
é aplicado em combinação com outros descriptores de método, ele deve ser aplicado como o decorador mais interno, como mostrado nos seguintes exemplos de uso:class C(metaclass=ABCMeta): @abstractmethod def my_abstract_method(self, ...): ... @classmethod @abstractmethod def my_abstract_classmethod(cls, ...): ... @staticmethod @abstractmethod def my_abstract_staticmethod(...): ... @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)
In order to correctly interoperate with the abstract base class machinery, the descriptor must identify itself as abstract using
__isabstractmethod__
. In general, this attribute should beTrue
if any of the methods used to compose the descriptor are abstract. For example, Python’s built-in property does the equivalent of: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.
-
@
abc.
abstractclassmethod
¶ Uma subclasse da
classmethod()
embutida, indicando um método de classe abstrato. Caso contrário, é similar àabstractmethod()
.Este caso especial está depreciado, pois o decorador da
classmethod()
está agora corretamente identificado como abstrato quando aplicado a um método abstrato:class C(metaclass=ABCMeta): @classmethod @abstractmethod def my_abstract_classmethod(cls, ...): ...
Novo na versão 3.2.
Obsoleto desde a versão 3.3: Agora é possível usar :classe:`classmethod` com
abstractmethod()
, tornando redundante este decorador.
-
@
abc.
abstractstaticmethod
¶ 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(metaclass=ABCMeta): @staticmethod @abstractmethod def my_abstract_staticmethod(...): ...
Novo na versão 3.2.
Obsoleto desde a versão 3.3: Agora é possível usar :classe:`staticmethod` com
abstractmethod()
, tornando redundante este decorador.
-
@
abc.
abstractproperty
(fget=None, fset=None, fdel=None, doc=None)¶ 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 fromABCMeta
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.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(metaclass=ABCMeta): @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 gravação marcando apropriadamente um ou mais dos métodos subjacentes como abstratos:
class C(metaclass=ABCMeta): @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): ...
Obsoleto desde a versão 3.3: Agora é possível usar :classe:`property`,
property.getter()
,property.setter()
eproperty.deleter()
comabstractmethod()
, tornando redundante este decorador.
O módulo: mod: 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.Novo na versão 3.4.
Notas de rodapé
[1] | Programadores C++ devem notar que o conceito da casse base virtual do Python não é o mesmo que o de C++. |