"__future__" --- Definições de instruções de future
***************************************************

**Código-fonte:** Lib/__future__.py

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

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

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

* Para garantir que instruções futuras sejam executadas em versões
  anteriores a 2.1, pelo menos, processe exceções de tempo de execução
  (a importação de "__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 "__future__" e examinando seus conteúdos.

Cada instrução em "__future__.py" é da forma:

   FeatureName = _Feature(OptionalRelease, MandatoryRelease,
                          CompilerFlag)

Onde, normalmente, *OptionalRelease* é inferior a *MandatoryRelease*,
e ambos são tuplas de 5 entradas da mesma forma que
"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 um *MandatoryRelease* que ainda não ocorreu,
*MandatoryRelease* prevê o lançamento em que o recurso se tornará
parte da linguagem.

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 instrução future 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 "_Feature" têm dois métodos correspondentes,
"getOptionalRelease()" e "getMandatoryRelease()".

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

Nenhuma descrição de característica será excluída de "__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*       |
+--------------------+---------------+----------------+-----------------------------------------------+
| generators         | 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*                                   |
+--------------------+---------------+----------------+-----------------------------------------------+
| annotations        | 3.7.0b1       | Para ser feito | **PEP 563**: *Postponed evaluation of         |
|                    |               | [1]            | annotations*                                  |
+--------------------+---------------+----------------+-----------------------------------------------+

[1] "from __future__ import annotations" foi programado anteriormente
    para se tornar obrigatório no Python 3.10, mas o Python Steering
    Council decidiu duas vezes adiar a mudança (anúncio para o Python
    3.10; anúncio para o Python 3.11). Nenhuma decisão final foi
    tomada ainda. Veja também **PEP 563** e **PEP 649**.

Ver também:

  Instruções future
     Como o compilador trata as importações de future.
