29.10. : mod: *__future__* --- Definições de declaração futura
**************************************************************

**Código-fonte:** Lib/__ future __.py

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

: mod: *__future__* é um módulo real, e serve três propósitos:

* Para evitar confundir as ferramentas existentes que analisam as
  declarações de importação e esperam encontrar os módulos que estão
  importando.

* Para garantir que: ref: *future statements 1 'executado em versões
  anteriores a 2.1, pelo menos, processar exceções de tempo de
  execução (a importação de: mod:* __future__` falhará, porque não
  havia nenhum módulo desse nome antes de 2.1).

* Para documentar quando as mudanças incompatíveis foram introduzidas,
  e quando elas serão --- ou foram --- obrigatórias. Esta é uma forma
  de documentação executável e pode ser inspecionada programaticamente
  através da importação: mod: *__future__* e examinando seus
  conteúdos.

Cada declaração em: file:. *__future __ py* é da forma

   FeatureName = _Feature(OptionalRelease, MandatoryRelease,
                          CompilerFlag)

Onde, normalmente, * OpcionalRelease * é inferior a
*MandatoryRelease*, e ambos são 5-tuplas da mesma forma que: dados:
*sys.version_info*

   (PY_MAJOR_VERSION, # the 2 in 2.1.0a3; an int
    PY_MINOR_VERSION, # the 1; an int
    PY_MICRO_VERSION, # the 0; an int
    PY_RELEASE_LEVEL, # "alpha", "beta", "candidate" or "final"; string
    PY_RELEASE_SERIAL # the 3; an int
   )

*OptionalRelease* registra o primeiro lançamento no qual o recurso foi
aceito.

No caso de * *MandatoryRelease* que ainda não ocorreu,
*MandatoryRelease* prevê o lançamento em que o recurso se tornará
parte do idioma.

Senão *MandatoryRelease* registra quando o recurso se tornou parte do
idioma; Em versões em ou depois disso, os módulos não precisam mais de
uma declaração futura para usar o recurso em questão, mas podem
continuar a usar essas importações.

*MandatoryRelease* também pode ser `` None``, o que significa que uma
característica planejada foi descartada.

Instâncias de classe: classe: *_Feature* tem dois métodos
correspondentes,: meth:` getOptionalRelease` e: meth:
*getMandatoryRelease*.

*CompilerFlag* é o sinalizador (bitfield) que deve ser passado no
quarto argumento para a função incorporada: func: *compile* para
habilitar o recurso no código compilado dinamicamente. Este
sinalizador é armazenado em: attr: *compiler_flag* atributo em:
classe:` _Feature` instâncias.

Nenhuma descrição de característica será excluída de: mod:
*__future__*. Desde a sua introdução no Python 2.1, os seguintes
recursos encontraram o caminho para o idioma usando esse mecanismo:

+--------------------+---------------+----------------+-----------------------------------------------+
| característica     | Opcional em   | Obrigatório em | efeito                                        |
|====================|===============|================|===============================================|
| nested_scopes      | 2.1.0b1       | 2.2            | **PEP 227**: *Statically Nested Scopes*       |
+--------------------+---------------+----------------+-----------------------------------------------+
| Geradores          | 2.2.0a1       | 2.3            | **PEP 255**: *Simple Generators*              |
+--------------------+---------------+----------------+-----------------------------------------------+
| divisão            | 2.2.0a2       | 3.0            | **PEP 238**: *Changing the Division Operator* |
+--------------------+---------------+----------------+-----------------------------------------------+
| absolute_import    | 2.5.0a1       | 3.0            | **PEP 328**: *Imports: Multi-Line and         |
|                    |               |                | Absolute/Relative*                            |
+--------------------+---------------+----------------+-----------------------------------------------+
| with_statement     | 2.5.0a1       | 2.6            | **PEP 343**: *The "with" Statement*           |
+--------------------+---------------+----------------+-----------------------------------------------+
| print_function     | 2.6.0a2       | 3.0            | **PEP 3105**: *Make print a function*         |
+--------------------+---------------+----------------+-----------------------------------------------+
| unicode_literals   | 2.6.0a2       | 3.0            | **PEP 3112**: *Bytes literals in Python 3000* |
+--------------------+---------------+----------------+-----------------------------------------------+
| generator_stop     | 3.5.0b1       | 3.7            | **PEP 479**: *StopIteration handling inside   |
|                    |               |                | generators*                                   |
+--------------------+---------------+----------------+-----------------------------------------------+

Ver também:

  Future statements
     Como o compilador trata as importações futuras.
