¿Para qué se utiliza __future__ en Python y cómo / cuándo usarlo, y cómo funciona?

Las personas que me incluyen saben que hay algo en Python llamado __future__ y aparece en unos cuantos módulos que leí. Y las personas aburridas como yo no saben por qué está ahí, y cómo / cuándo usarlo, incluso después de leer el __future__ doc del Python’s .

Entonces, ¿alguien explica con ejemplos para demostrarlo?

Tengo algunas respuestas rápidamente, que parecen correctas, en términos de uso básico.

Sin embargo, y también para comprender mejor cómo funciona __future__ :

Acabo de darme cuenta de una cosa clave que me estaba confundiendo cuando intenté entenderla, es decir, ¿cómo un lanzamiento de Python actual incluye algo que se lanzará en un lanzamiento futuro? y ¿cómo se puede comstackr con éxito un progtwig que use una nueva característica en una futura versión de python con la versión actual de python?

Entonces, supongo que ahora, la versión actual ya ha incluido algunas características potenciales que se incluirán en futuras versiones. ¿Es esto correcto? pero las funciones solo están disponibles para __future__ , eso es porque aún no se ha convertido en estándar, ¿verdad?

Con la inclusión del módulo __future__ , poco a poco puede estar acostumbrado a los cambios incompatibles oa introducir palabras clave nuevas.

Por ejemplo, para usar los administradores de contexto, tenía que hacer from __future__ import with_statement en 2.5, ya que la palabra clave with era nueva y ya no debía usarse como nombres de variables. Para poder usar un progtwig que usa variables nombradas with , se necesita la statement de importación anterior.

Otro ejemplo es

 from __future__ import division print 8/7 # prints 1.1428571428571428 print 8//7 # prints 1 

Sin las cosas de __future__ , ambas declaraciones de impresión se imprimirían 1 .

La diferencia interna es que sin esa importación, / se asigna al método __div__() , mientras que con él, se __truediv__() . (En cualquier caso, // llama a __floordiv__() .)

Una propuesta print : print convierte en una función en 3.x, perdiendo su propiedad especial como palabra clave. Así que es al revés.

 >>> print >>> from __future__ import print_function >>> print  >>> 

Cuando tu lo hagas

 from __future__ import whatever 

En realidad no estás usando una statement de import , sino una statement futura . Estás leyendo los documentos incorrectos, ya que en realidad no estás importando ese módulo.

Las declaraciones futuras son especiales: cambian la forma en que se analiza el módulo de Python, por lo que deben estar en la parte superior del archivo. Le dan un significado nuevo, o diferente, a las palabras o símbolos en su archivo. De los documentos:

Una statement futura es una directiva para el comstackdor de que un módulo en particular debe comstackrse utilizando la syntax o la semántica que estará disponible en una versión futura específica de Python. El objective de la statement futura es facilitar la migración a futuras versiones de Python que introducen cambios incompatibles en el idioma. Permite el uso de las nuevas funciones por módulo antes del lanzamiento en el que la característica se convierte en estándar.

Si realmente quiere importar el módulo __future__ , simplemente haga

 import __future__ 

y luego acceder a ella como de costumbre.

__future__ es un pseudo-módulo que los progtwigdores pueden usar para habilitar nuevas funciones de lenguaje que no son compatibles con el intérprete actual . Por ejemplo, la expresión 11/4 actualmente se evalúa como 2 . Si el módulo en el que se ejecuta ha habilitado la división verdadera ejecutando:

from __future__ import division

La expresión 11/4 se evaluaría a 2.75 . Al importar el módulo __future__ y evaluar sus variables, puede ver cuándo se agregó por primera vez una nueva característica al idioma y cuándo se convertirá en la predeterminada:

  >>> import __future__ >>> __future__.division _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192) 

Se puede usar para usar características que aparecerán en versiones más nuevas mientras se tiene una versión anterior de Python.

Por ejemplo

 >>> from __future__ import print_function 

le permitirá utilizar print como una función:

 >>> print('# of entries', len(dictionary), file=sys.stderr) 

O es como decir “Dado que esto es python v2.7, use esa función diferente de ‘imprimir’ que también se ha agregado a python v2.7, después de que se haya agregado en python 3. Así que mi ‘imprimir’ ya no será una statement (p. ej., imprimir “mensaje”) pero funciones (p. ej., imprimir (“mensaje”, opciones). De esa manera, cuando mi código se ejecuta en Python 3, ‘imprimir’ no se interrumpirá “.

En

 from __future__ import print_function 

print_function es el módulo que contiene la nueva implementación de ‘print’ según cómo se comporta en Python v3.

Esto tiene más explicación: http://python3porting.com/noconv.html

Ya hay algunas respuestas geniales, pero ninguna de ellas aborda una lista completa de lo que la statement __future__ admite actualmente.

En pocas palabras, la statement __future__ obliga a los intérpretes de Python a usar las características más nuevas del lenguaje.

Las características que soporta actualmente son las siguientes:

nested_scopes :

Antes de Python 2.1, el siguiente código generaría un NameError :

 def f(): ... def g(value): ... return g(value-1) + 1 ... 

La from __future__ import nested_scopes permitirá que se habilite esta característica.

generators

Se introdujeron funciones de generador como la que se muestra a continuación para guardar el estado entre llamadas de función sucesivas:

 def fib(): a, b = 0, 1 while 1: yield b a, b = b, a+b 

division

La división clásica se utiliza en las versiones de Python 2.x. Lo que significa que algunas declaraciones de división devuelven una aproximación razonable de división (“división verdadera”) y otras devuelven el piso (“división de piso”). Comenzando en Python 3.0, la división verdadera se especifica con x/y , mientras que la división de piso se especifica con x//y .

La directiva de from __future__ import division obliga al uso de la división de estilo Python 3.0.

absolute_import :

Permite que entre paréntesis incluya varias instrucciones de import . Por ejemplo:

 from Tkinter import (Tk, Frame, Button, Entry, Canvas, Text, LEFT, DISABLED, NORMAL, RIDGE, END) 

En lugar de:

 from Tkinter import Tk, Frame, Button, Entry, Canvas, Text, \ LEFT, DISABLED, NORMAL, RIDGE, END 

O:

 from Tkinter import Tk, Frame, Button, Entry, Canvas, Text from Tkinter import LEFT, DISABLED, NORMAL, RIDGE, END 

with_statement :

Agrega la statement “con” como palabra clave en Python para eliminar la necesidad de las declaraciones try/finally . Los usos comunes de esto son cuando se hace E / S de archivos como:

 with open('workfile', 'r') as f: read_data = f.read() 

print_function :

Fuerza el uso de print función de print estilo paréntesis Python 3 en lugar de la statement de impresión de estilo de print MESSAGE impresión.

unicode_literals

Introduce la syntax literal para el objeto bytes . Lo que significa que las declaraciones como bytes('Hello world', 'ascii') pueden expressse simplemente como b'Hello world' .

generator_stop :

Reemplaza el uso de la excepción StopIteration utilizada dentro de las funciones del generador con la excepción RuntimeError .

Otro uso no mencionado anteriormente es que la statement __future__ también fuerza el uso de los intérpretes de Python 2.1+, ya que el uso de una versión anterior generará una excepción de tiempo de ejecución.

Referencias:

Uno de los usos que me pareció muy útil es la print_function de __future__ módulo __future__ .

En Python 2.7, quería que los caracteres de diferentes declaraciones impresas se imprimieran en la misma línea sin espacios.

Se puede hacer usando una coma (“,”) al final, pero también agrega un espacio adicional. La statement anterior cuando se utiliza como:

 from __future__ import print_function ... print (v_num,end="") ... 

Esto imprimirá el valor de v_num de cada iteración en una sola línea sin espacios.

Explícito es mejor que implícito

 from __future__ import braces File "", line 1 SyntaxError: not a chance 

[Crédito: @mdeous]

Después de Python 3.0 en adelante, la impresión ya no es solo una statement, sino una función. y se incluye en PEP 3105.

También creo que el paquete Python 3.0 aún tiene estas funciones especiales. Veamos su usabilidad a través de un “progtwig piramidal” tradicional en Python:

 from __future__ import print_function class Star(object): def __init__(self,count): self.count = count def start(self): for i in range(1,self.count): for j in range (i): print('*', end='') # PEP 3105: print As a Function print() a = Star(5) a.start() Output: * ** *** **** 

Si usamos la función de impresión normal, no podremos lograr el mismo resultado, ya que print () viene con una nueva línea adicional. Por lo tanto, cada vez que se ejecute el bucle for interno, se imprimirá * en la siguiente línea.