"__future__" --- Definiciones de declaraciones futuras
******************************************************

**Código fuente:** Lib/__future__.py

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

"__future__" es un módulo real y tiene tres propósitos:

* Para evitar confundir las herramientas existentes que analizan las
  declaraciones de importación y esperan encontrar los módulos que
  están importando.

* Para garantizar que las declaraciones futuras se ejecuten en
  versiones anteriores a 2.1 al menos produzcan excepciones en tiempo
  de ejecución (la importación de "__future__" fallará, porque no
  había ningún módulo con ese nombre antes de 2.1).

* Documentar cuándo se introdujeron cambios incompatibles y cuándo
  serán --- o fueron --- obligatorios. Esta es una forma de
  documentación ejecutable y se puede inspeccionar mediante
  programación importando "__future__" y examinando su contenido.

Cada declaración en "__future__.py" tiene la forma:

   FeatureName = _Feature(OptionalRelease, MandatoryRelease,
                          CompilerFlag)

donde, normalmente, *OptionalRelease* es menor que *MandatoryRelease*
y ambos son 5-tuplas de la misma 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 la primera versión en la que se aceptó la
característica.

En el caso de un *MandatoryRelease* que aún no se ha producido,
*MandatoryRelease* predice el lanzamiento en el que la característica
pasará a formar parte del lenguaje.

De otro modo, *MandatoryRelease* registra cuándo la característica se
convirtió en parte del lenguaje; en versiones en o después de este,
los módulos ya no necesitan una declaración futura para usar la
característica en cuestión, pero pueden continuar usando dichas
importaciones.

*MandatoryRelease* también puede ser "None", lo que significa que se
eliminó una característica planificada.

Las instancias de la clase "_Feature" tienen dos métodos
correspondientes, "getOptionalRelease()" y "getMandatoryRelease()".

*CompilerFlag* es el indicador (campo de bits) que debe pasarse en el
cuarto argumento a la función incorporada "compile()" para habilitar
la característica en código compilado dinámicamente. Esta bandera se
almacena en el atributo "compiler_flag" en las instancias "_Feature".

Ninguna descripción de característica se eliminará de "__future__".
Desde su introducción en Python 2.1, las siguientes características
han encontrado su camino en el lenguaje usando este mecanismo:

+--------------------+---------------+----------------+-----------------------------------------------+
| característica     | opcional en   | obligatorio en | efecto                                        |
|====================|===============|================|===============================================|
| nested_scopes      | 2.1.0b1       | 2.2            | **PEP 227**: *Ámbitos anidados estáticamente* |
+--------------------+---------------+----------------+-----------------------------------------------+
| generadores        | 2.2.0a1       | 2.3            | **PEP 255**: *Generadores simples*            |
+--------------------+---------------+----------------+-----------------------------------------------+
| división           | 2.2.0a2       | 3.0            | **PEP 238**: *Cambio de operador de división* |
+--------------------+---------------+----------------+-----------------------------------------------+
| absolute_import    | 2.5.0a1       | 3.0            | **PEP 328**: *Importaciones: Multilínea y     |
|                    |               |                | Absoluto/Relativo*                            |
+--------------------+---------------+----------------+-----------------------------------------------+
| with_statement     | 2.5.0a1       | 2.6            | **PEP 343**: *La declaración "with"*          |
+--------------------+---------------+----------------+-----------------------------------------------+
| print_function     | 2.6.0a2       | 3.0            | **PEP 3105**: *Hacer de print una función*    |
+--------------------+---------------+----------------+-----------------------------------------------+
| unicode_literals   | 2.6.0a2       | 3.0            | **PEP 3112**: *Bytes literales en Python      |
|                    |               |                | 3000*                                         |
+--------------------+---------------+----------------+-----------------------------------------------+
| generator_stop     | 3.5.0b1       | 3.7            | **PEP 479**: *Manejo de StopIteration dentro  |
|                    |               |                | de generadores*                               |
+--------------------+---------------+----------------+-----------------------------------------------+
| anotaciones        | 3.7.0b1       | TBD [1]        | **PEP 563**: *Evaluación pospuesta de         |
|                    |               |                | anotaciones*                                  |
+--------------------+---------------+----------------+-----------------------------------------------+

[1] "from __future__ import annotations" was previously scheduled to
    become mandatory in Python 3.10, but the Python Steering Council
    twice decided to delay the change (announcement for Python 3.10;
    announcement for Python 3.11). No final decision has been made
    yet. See also **PEP 563** and **PEP 649**.

Ver también:

  Declaraciones Futuras
     Cómo trata el compilador las importaciones futuras.
