lenguaje - python tutorial

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

Question

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é entenderlo, es decir, ¿cómo un lanzamiento de Python actual incluye algo que se lanzará en un lanzamiento futuro? y ¿cómo se puede compilar con éxito un programa 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?

Answer 1

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 nombre de variable. Para poder usar un programa que usa variables nombradas with , se necesita la declaración 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
<built-in function print>
>>>

Answer 2

Cuando tu lo hagas

from __future__ import whatever

En realidad no estás usando una declaración de import , sino una declaración 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 la documentación:

Una declaración futura es una directiva para el compilador de que un módulo en particular debe compilarse utilizando la sintaxis o la semántica que estará disponible en una versión futura específica de Python. El objetivo de la declaración 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.

Answer 3

Después de Python 3.0 en adelante, la impresión ya no es solo una declaración, 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 "programa 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.

Answer 4

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 agregó en python 3. Así que mi ''imprimir'' ya no será una declaración (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

Answer 5

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)

Answer 6

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 declaración 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.

Answer 7

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

En pocas palabras, la declaración __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 declaración "con" como palabra clave en Python para eliminar la necesidad de las declaraciones try/finally . Los usos comunes de esto son cuando se realiza la 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 declaración de impresión de estilo de print MESSAGE impresión.

unicode_literals

Introduce la sintaxis literal para el objeto bytes . Lo que significa que las declaraciones como bytes(''Hello world'', ''ascii'') se pueden expresar 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 declaración __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:

• https://docs.python.org/2/library/future.html
• https://docs.python.org/3/library/future.html
• https://docs.python.org/2.2/whatsnew/node9.html
• https://www.python.org/dev/peps/pep-0255/
• https://www.python.org/dev/peps/pep-0238/
• https://www.python.org/dev/peps/pep-0328/
• https://www.python.org/dev/peps/pep-3112/
• https://www.python.org/dev/peps/pep-0479/

Answer 8

__future__ es un pseudo-módulo que los programadores 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 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)