Question À quoi sert __future__ en Python et comment / quand l'utiliser, et comment cela fonctionne


Les gens, y compris moi, savent qu'il y a quelque chose en Python appelé __future__ et il apparaît dans un bon nombre de modules que j'ai lus. Et les gens sourds comme moi ne savent pas pourquoi c'est là, et comment / quand l'utiliser, même après avoir lu le python __future__ doc.

Alors tout explique avec des exemples pour le démontrer?

J'ai rapidement reçu quelques réponses, qui ont toutes l'air correctes, en termes d'utilisation de base.

Cependant et aussi pour mieux comprendre comment __future__ travaux:

Je viens de réaliser une chose qui me déroutait quand j'ai essayé de le comprendre, c'est-à-dire comment une version actuelle de Python inclut quelque chose qui sera publié dans une future version? et comment un programme utilisant une nouvelle fonctionnalité dans une future version python peut-il être compilé avec succès par la version actuelle de python?

Donc, je suppose que maintenant, la version actuelle a déjà empaqueté certaines fonctionnalités potentielles qui seront incluses dans les futures versions - est-ce exact? mais les fonctionnalités ne sont disponibles que par __future__C'est parce que ça n'est pas encore devenu standard - j'ai raison?


411
2017-08-16 07:52


origine


Réponses:


Avec __future__ l'inclusion du module, vous pouvez vous habituer lentement aux changements incompatibles ou à ceux qui introduisent de nouveaux mots-clés.

Par exemple, pour utiliser les gestionnaires de contexte, vous deviez faire from __future__ import with_statement en 2.5, comme with mot-clé était nouveau et ne devrait plus être utilisé comme nom de variable. Afin de pouvoir utiliser un programme qui utilise des variables nommées with, la déclaration d'importation ci-dessus est nécessaire.

Un autre exemple est

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

Sans le __future__ des choses, à la fois print les déclarations imprimeraient 1.

La différence interne est que sans cette importation, / est mappé à la __div__() méthode, avec elle, __truediv__() est utilisé. (Dans tout les cas, // appels __floordiv__().)

À propos de print: print devient une fonction dans 3.x, perdant sa propriété spéciale en tant que mot-clé. Donc, c'est l'inverse.

>>> print

>>> from __future__ import print_function
>>> print
<built-in function print>
>>>

234
2017-08-16 07:56



Quand tu fais

from __future__ import whatever

Vous n'utilisez pas réellement un import déclaration, mais un déclaration future. Vous lisez les mauvais documents, car vous n'importez pas ce module.

Les futures instructions sont spéciales - elles modifient la façon dont votre module Python est analysé, ce qui explique pourquoi elles doit être en haut du fichier. Ils donnent une signification nouvelle ou différente aux mots ou aux symboles de votre fichier. De la docs:

Une instruction future est une directive au compilateur qu'un module particulier doit être compilé en utilisant la syntaxe ou la sémantique qui sera disponible dans une future version de Python. La déclaration future est destinée à faciliter la migration vers les futures versions de Python qui introduisent des modifications incompatibles avec le langage. Il permet d'utiliser les nouvelles fonctionnalités par module avant la version dans laquelle la fonctionnalité devient standard.

Si vous voulez importer le __future__ module, faites juste

import __future__

et ensuite y accéder comme d'habitude.


129
2017-08-16 08:00



__future__  est un pseudo-module que les programmeurs peuvent utiliser pour activer de nouvelles fonctionnalités de langage qui ne sont pas compatibles avec l'interpréteur en cours. Par exemple, l'expression 11/4 évalue actuellement à 2. Si le module dans lequel il est exécuté a activé la vraie division en exécutant:

from __future__ import division

l'expression 11/4 évaluerait à 2.75. En important le __future__ module et l'évaluation de ses variables, vous pouvez voir quand une nouvelle fonctionnalité a été ajoutée pour la première fois à la langue et quand elle deviendra la valeur par défaut:

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

87
2018-02-20 20:38



Il peut être utilisé pour utiliser des fonctionnalités qui apparaîtront dans les versions plus récentes tout en ayant une ancienne version de Python.

Par exemple

>>> from __future__ import print_function

vous permettra d'utiliser print en tant que fonction:

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

33
2017-08-16 08:02



Ou est-ce comme dire "Puisque ceci est python v2.7, utilisez cette fonction" print "différente qui a également été ajoutée à python v2.7, après son ajout dans python 3. Donc mon" print "ne sera plus des instructions (par exemple, imprimer "message") mais les fonctions (par exemple, print ("message", options). Ainsi, lorsque mon code est exécuté en python 3, "print" ne sera pas interrompu. "

Dans

from __future__ import print_function

print_function est le module contenant la nouvelle implémentation de 'print' en fonction de son comportement dans python v3.

Cela a plus d'explications: http://python3porting.com/noconv.html


15
2017-11-15 14:36



L'un des usages que j'ai trouvés très utiles est le print_function de __future__ module.

Dans Python 2.7, je voulais que les caractères de différentes instructions d'impression soient imprimés sur la même ligne sans espaces.

Cela peut être fait en utilisant une virgule (",") à la fin, mais cela ajoute aussi un espace supplémentaire. La déclaration ci-dessus utilisée comme:

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

Cela imprimera la valeur de v_num de chaque itération dans une seule ligne sans espaces.


3
2018-01-05 15:14



Il y a déjà d'excellentes réponses, mais aucune d'entre elles n'aborde une liste complète de ce que __future__ déclaration supporte actuellement.

Mettre tout simplement, L'instruction __future__ force les interpréteurs Python à utiliser les nouvelles fonctionnalités du langage. 

Les fonctionnalités prises en charge sont les suivantes:

nested_scopes:

Avant Python 2.1, le code suivant soulève un NameError:

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

le from __future__ import nested_scopes directive permettra à cette fonctionnalité d'être activée.

generators:

Introduit des fonctions de générateur telles que celle ci-dessous pour sauvegarder l’état entre les appels de fonction successifs:

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

division:

La division classique est utilisée dans les versions Python 2.x. Cela signifie que certaines déclarations de division renvoient une approximation raisonnable de la division («division vraie») et que d'autres retournent le plancher («division de plancher»). À partir de Python 3.0, la division vraie est spécifiée par x/y, alors que la division de sol est spécifiée par x//y.

le from __future__ import division La directive force l'utilisation de la division de style Python 3.0.

absolute_import:

Permet aux parenthèses de joindre plusieurs import déclarations. Par exemple:

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

Au lieu de:

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

Ou:

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

with_statement:

Ajoute l'instruction "with" en tant que mot clé en Python pour éliminer le besoin de try/finally déclarations. Les utilisations courantes de ceci sont quand faire des E / S de fichier telles que:

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

print_function:

Force l'utilisation de Python 3 parenthèse print appel de fonction au lieu de print MESSAGE déclaration d'impression de style.

unicode_literals:

Introduit la syntaxe littérale du bytes objet. Ce qui signifie que les déclarations telles que bytes('Hello world', 'ascii')peut être simplement exprimé comme b'Hello world'.

generator_stop:

Remplace l'utilisation de StopIteration exception utilisée à l'intérieur des fonctions du générateur avec le RuntimeError exception.

Une autre utilisation non mentionnée ci-dessus est que le __future__ statement force également l'utilisation des interpréteurs Python 2.1+, car l'utilisation d'une version plus ancienne provoquera une exception d'exécution.

Les références:


2
2018-03-11 17:19



Après Python 3.0, print n'est plus une simple instruction, mais une fonction. et est inclus dans PEP 3105.

Aussi je pense que le paquet Python 3.0 a toujours ces fonctionnalités spéciales. Voyons sa facilité d'utilisation grâce à un «programme Pyramid» traditionnel 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 nous utilisons la fonction d'impression normale, nous ne pourrons pas obtenir la même sortie, car print () est fourni avec un retour à la ligne supplémentaire. Ainsi, à chaque exécution de la boucle interne for, elle s'imprime * sur la ligne suivante.


-3
2018-04-05 11:33