8.9. "types" --- Criação de tipos dinâmicos e nomes para tipos embutidos
************************************************************************

**Código Fonte:** Lib/types.py

======================================================================

This module defines utility function to assist in dynamic creation of
new types.

Também define nomes para alguns tipos de objetos usados pelo
interpretador Python padrão, mas não expostos como componentes
embutidos como "int" ou "str" são.

Por fim, fornece algumas classes e funções adicionais relacionadas ao
tipo que não são fundamentais o suficiente para serem incorporadas.


8.9.1. Criação de Tipo Dinâmico
===============================

types.new_class(name, bases=(), kwds=None, exec_body=None)

   Cria um objeto de classe dinamicamente usando a metaclasse
   apropriada.

   Os três primeiros argumentos são os componentes que compõem um
   cabeçalho de definição de classe: o nome da classe, as classes base
   (em ordem), os argumentos nomeados (como "metaclass").

   O argumento *exec_body* é um retorno de chamada usado para
   preencher o espaço para nome da classe recém-criado. Ele deve
   aceitar o espaço para nome da classe como seu único argumento e
   atualizar o espaço para nome diretamente com o conteúdo da classe.
   Se nenhum retorno de chamada for fornecido, ele terá o mesmo efeito
   que passar em "lambda ns: ns".

   Novo na versão 3.3.

types.prepare_class(name, bases=(), kwds=None)

   Calcula a metaclasse apropriada e cria o espaço de nomes da classe.

   Os argumentos são os componentes que compõem um cabeçalho de
   definição de classe: o nome da classe, as classes base (em ordem) e
   os argumentos nomeados (como "metaclass").

   O valor de retorno é uma tupla de três: "metaclass, namespace,
   kwds"

   *metaclass* é a metaclasse apropriada, *namespace* é o espaço de
   nomes da classe preparada e *kwds* é uma cópia atualizada do
   argumento passado no *kwds* com qualquer entrada "'metaclass'"
   removida. Se nenhum argumento *kwds* for passado, este será um
   ditado vazio.

   Novo na versão 3.3.

   Alterado na versão 3.6: The default value for the "namespace"
   element of the returned tuple has changed.  Now an insertion-order-
   preserving mapping is used when the metaclass does not have a
   "__prepare__" method,

Ver também:

  Metaclasses
     Detalhes completos do processo de criação de classe suportado por
     essas funções

  **PEP 3115** - Metaclasses no Python 3000
     Introduzido o gancho de espaço de nomes "__prepare__"


8.9.2. Tipos padrão do intepretador
===================================

Este módulo fornece nomes para muitos dos tipos necessários para
implementar um interpretador Python. Evita deliberadamente incluir
alguns dos tipos que surgem apenas incidentalmente durante o
processamento, como o tipo "listiterator".

O uso típico desses nomes é para verificações "isinstance()" ou :
func:*issubclass*.

Os nomes padrão são definidos para os seguintes tipos:

types.FunctionType
types.LambdaType

   O tipo de funções definidas pelo usuário e funções criadas por
   expressões "lambda".

types.GeneratorType

   O tipo de objetos de iterador *gerador*, criados pelas funções
   geradoras.

types.CoroutineType

   O tipo de objetos de *coroutine*, criado por funções de "async
   def".

   Novo na versão 3.5.

types.AsyncGeneratorType

   O tipo de objetos de iterador *gerador assíncrono*, criados pelas
   funções do gerador assíncrono.

   Novo na versão 3.6.

types.CodeType

   O tipo de objetos de código retornados por "compile()".

types.MethodType

   O tipo de método de instâncias de classe definidas pelo usuário.

types.BuiltinFunctionType
types.BuiltinMethodType

   O tipo de funções embutidas como "len()" ou "sys.exit()", e métodos
   de classes embutidas. (Aqui, o termo "embutidas" significa "escrito
   em C".)

class types.ModuleType(name, doc=None)

   O tipo de *módulos*. O construtor recebe o nome do módulo a ser
   criado e opcionalmente sua *docstring*.

   Nota:

     Use "importlib.util.module_from_spec()" para criar um novo módulo
     se você deseja definir os vários atributos controlados por
     importação.

   __doc__

      A *docstring* do módulo. O padrão é "None".

   __loader__

      O *carregador* que carregou o módulo. O padrão é "None".

      Alterado na versão 3.4: O padrão é "None". Anteriormente, o
      atributo era opcional.

   __name__

      O nome do módulo.

   __package__

      A qual *pacote* um módulo pertence. Se o módulo é de nível
      superior (ou seja, não faz parte de nenhum pacote específico), o
      atributo deve ser definido como "''", senão deve ser definido
      como o nome do pacote (que pode ser "__name__" se o módulo for o
      próprio pacote). O padrão é "None".

      Alterado na versão 3.4: O padrão é "None". Anteriormente, o
      atributo era opcional.

types.TracebackType

   O tipo de objetos traceback, como encontrados em
   "sys.exc_info()[2]".

types.FrameType

   O tipo de objetos quadro, como encontrado em "tb.tb_frame" se "tb"
   é um objeto traceback.

types.GetSetDescriptorType

   O tipo de objetos definidos em módulos de extensão com
   "PyGetSetDef", como "FrameType.f_locals" ou "array.array.typecode".
   Este tipo é usado como descritor para atributos de objeto; tem o
   mesmo propósito que o tipo "property", mas para classes definidas
   em módulos de extensão.

types.MemberDescriptorType

   O tipo de objetos definidos em módulos de extensão com
   "PyMemberDef", como "datetime.timedelta.days". Este tipo é usado
   como descritor para membros de dados C simples que usam funções de
   conversão padrão; tem o mesmo propósito que o tipo "property", mas
   para classes definidas em módulos de extensão.

   **CPython implementation detail:** Em outras implementações de
   Python, este tipo pode ser idêntico a "GetSetDescriptorType".

class types.MappingProxyType(mapping)

   Proxy somente leitura de um mapeamento. Ele fornece uma visão
   dinâmica das entradas do mapeamento, o que significa que quando o
   mapeamento muda, a visão reflete essas mudanças.

   Novo na versão 3.3.

   key in proxy

      Retorna "True" se o mapeamento subjacente tiver uma chave *key*,
      senão "False".

   proxy[key]

      Retorna e o item do mapeamento subjacente com a chave *key*.
      Levanta um "KeyError" se *key* não estiver no mapeamento
      subjacente.

   iter(proxy)

      Retorna um iterador sobre as chaves do mapeamento subjacente.
      Este é um atalho para "iter(proxy.keys())".

   len(proxy)

      Retorna o número de itens no mapeamento subjacente.

   copy()

      Retorna uma cópia rasa do mapeamento subjacente.

   get(key[, default])

      Retorna o valor para *key* se *key* estiver no mapeamento
      subjacente, caso contrário, *default*. Se *default* não for
      fornecido, o padrão é "None", de forma que este método nunca
      levante uma "KeyError".

   items()

      Retorna uma nova visão dos itens do mapeamento subjacente (pares
      "(chave, valor)").

   keys()

      Retorna uma nova visão das chaves do mapeamento subjacente.

   values()

      Retorna uma nova visão dos valores do mapeamento subjacente.


8.9.3. Classes e funções de utilidades adicionais
=================================================

class types.SimpleNamespace

   Uma subclasse "object" simples que fornece acesso de atributo ao
   seu espaço de nomes, bem como um repr significativo.

   Diferentemente de "object", com "SimpleNamespace" você pode
   adicionar e remover atributos. Se um objeto "SimpleNamespace" é
   inicializado com argumentos nomeados, eles são adicionados
   diretamente ao espaço de nomes subjacente.

   O tipo é aproximadamente equivalente ao seguinte código:

      class SimpleNamespace:
          def __init__(self, **kwargs):
              self.__dict__.update(kwargs)

          def __repr__(self):
              keys = sorted(self.__dict__)
              items = ("{}={!r}".format(k, self.__dict__[k]) for k in keys)
              return "{}({})".format(type(self).__name__, ", ".join(items))

          def __eq__(self, other):
              return self.__dict__ == other.__dict__

   "SimpleNamespace" pode ser útil como um substituto para "class NS:
   pass". No entanto, para um tipo de registro estruturado, use
   "namedtuple()".

   Novo na versão 3.3.

types.DynamicClassAttribute(fget=None, fset=None, fdel=None, doc=None)

   Roteia o acesso ao atributo em uma classe para __getattr__.

   Este é um descritor, usado para definir atributos que atuam de
   forma diferente quando acessados por meio de uma instância e por
   meio de uma classe. O acesso à instância permanece normal, mas o
   acesso a um atributo por meio de uma classe será roteado para o
   método __getattr__ da classe; isso é feito levantando
   AttributeError.

   This allows one to have properties active on an instance, and have
   virtual attributes on the class with the same name (see Enum for an
   example).

   Novo na versão 3.4.


8.9.4. Funções de utilidade de corrotina
========================================

types.coroutine(gen_func)

   Esta função transforma uma função *geradora* em uma *função de
   corrotina* que retorna uma corrotina baseada em gerador. A
   corrotina baseada em gerador ainda é um *iterador gerador*, mas
   também é considerada um objeto *corrotina* e é *aguardável*. No
   entanto, pode não necessariamente implementar o método
   "__await__()".

   Se *gen_func* for uma função geradora, ela será modificada no
   local.

   Se *gen_func* não for uma função geradora, ela será envolta. Se ele
   retornar uma instância de "Collections.abc.Generator", a instância
   será envolvida em um objeto proxy *aguardável*. Todos os outros
   tipos de objetos serão retornados como estão.

   Novo na versão 3.5.
