Wofür wird __future__ in Python verwendet und wie / wann wird es verwendet und wie funktioniert es?

__future__erscheint häufig in Python-Modulen. Ich verstehe nicht, wofür __future__und wie / wann ich es verwenden soll, selbst nachdem ich das Python- __future__Dokument gelesen habe .

Kann jemand mit Beispielen erklären?

Ein paar Antworten bezüglich der grundlegenden Verwendung von, die __future__ich erhalten habe, schienen richtig zu sein.

Ich muss jedoch noch eines verstehen, wie es __future__funktioniert:

Das verwirrendste Konzept für mich ist, wie eine aktuelle Python-Version Funktionen für zukünftige Versionen enthält und wie ein Programm, das eine Funktion aus einer zukünftigen Version verwendet, in der aktuellen Version von Python erfolgreich kompiliert werden kann.

Ich vermute, dass die aktuelle Version mit potenziellen Funktionen für die Zukunft gepackt ist. Die Funktionen sind jedoch nur bei Verwendung verfügbar, __future__da sie nicht dem aktuellen Standard entsprechen. Lassen Sie mich wissen, ob ich recht habe.

Durch __future__die Aufnahme des Moduls können Sie sich langsam an inkompatible Änderungen oder an solche gewöhnen, die neue Schlüsselwörter einführen.

Für die Verwendung von Kontextmanagern mussten Sie beispielsweise from __future__ import with_statement2.5 ausführen, da das withSchlüsselwort neu war und nicht mehr als Variablennamen verwendet werden sollte. Um within Python 2.5 oder älter als Python-Schlüsselwort verwendet zu werden, müssen Sie den Import von oben verwenden.

Ein anderes Beispiel ist

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

Ohne das __future__Zeug printwürden beide Aussagen gedruckt 1.

Der interne Unterschied besteht darin, dass ohne diesen Import /die __div__()Methode zugeordnet wird, während sie __truediv__()verwendet wird. (Auf jeden Fall //Anrufe __floordiv__().)

Apropos print: printwird eine Funktion in 3.x und verliert seine spezielle Eigenschaft als Schlüsselwort. So ist es umgekehrt.

>>> print

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

Wenn Sie das tun

from __future__ import whatever

Sie verwenden eigentlich keine importAussage, sondern eine zukünftige Aussage . Sie lesen die falschen Dokumente, da Sie dieses Modul nicht importieren.

Zukünftige Anweisungen sind etwas Besonderes - sie ändern die Art und Weise, wie Ihr Python-Modul analysiert wird. Deshalb müssen sie oben in der Datei stehen. Sie geben Wörtern oder Symbolen in Ihrer Datei eine neue oder andere Bedeutung. Aus den Dokumenten:

Eine zukünftige Anweisung ist eine Anweisung an den Compiler, dass ein bestimmtes Modul unter Verwendung von Syntax oder Semantik kompiliert werden soll, die in einer bestimmten zukünftigen Version von Python verfügbar sein wird. Die zukünftige Anweisung soll die Migration auf zukünftige Versionen von Python erleichtern, die inkompatible Änderungen an der Sprache bewirken. Es ermöglicht die Verwendung der neuen Funktionen auf Modulbasis vor der Veröffentlichung, in der die Funktion zum Standard wird.

Wenn Sie das __future__Modul tatsächlich importieren möchten , tun Sie dies einfach

import __future__

und dann wie gewohnt darauf zugreifen.

__future__ ist ein Pseudomodul, mit dem Programmierer neue Sprachfunktionen aktivieren können, die nicht mit dem aktuellen Interpreter kompatibel sind . Beispielsweise wird der Ausdruck 11/4derzeit als ausgewertet 2. Wenn das Modul, in dem es ausgeführt wird, die wahre Division durch Ausführen aktiviert hat:

from __future__ import division

der Ausdruck 11/4würde zu bewerten 2.75. Durch Importieren des __future__Moduls und Auswerten seiner Variablen können Sie sehen, wann ein neues Feature zum ersten Mal zur Sprache hinzugefügt wurde und wann es zum Standard wird:

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

Es kann verwendet werden, um Funktionen zu verwenden, die in neueren Versionen mit einer älteren Version von Python angezeigt werden.

Zum Beispiel

>>> from __future__ import print_function

ermöglicht es Ihnen, printals Funktion zu verwenden:

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

Es gibt bereits einige gute Antworten, aber keine von ihnen enthält eine vollständige Liste dessen, was die __future__Aussage derzeit unterstützt.

Einfach ausgedrückt, zwingt die __future__Anweisung Python-Interpreter, neuere Funktionen der Sprache zu verwenden.

Folgende Funktionen werden derzeit unterstützt:

nested_scopes

Vor Python 2.1 löste der folgende Code einen NameError aus :

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

Die from __future__ import nested_scopesDirektive ermöglicht die Aktivierung dieser Funktion.

generators

Eingeführte Generatorfunktionen wie die folgende, um den Status zwischen aufeinanderfolgenden Funktionsaufrufen zu speichern:

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

division

Die klassische Unterteilung wird in Python 2.x-Versionen verwendet. Dies bedeutet, dass einige Divisionsanweisungen eine vernünftige Annäherung an die Division ("wahre Division") und andere den Floor ("Floor Division") zurückgeben. Ab Python 3.0 wird die wahre Division durch angegeben x/y, während die Bodenteilung durch angegeben wird x//y.

Die from __future__ import divisionDirektive erzwingt die Verwendung der Python 3.0-Stilteilung.

absolute_import

Ermöglicht es Klammern, mehrere importAnweisungen einzuschließen . Zum Beispiel:

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

Anstatt:

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

Oder:

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

with_statement

Fügt die Anweisung withals Schlüsselwort in Python hinzu, um die Notwendigkeit von try/finallyAnweisungen zu beseitigen . Dies wird häufig bei Datei-E / A verwendet, z. B.:

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

print_function::

Erzwingt die Verwendung des Funktionsaufrufs im Python 3-Klammerstil print()anstelle der print MESSAGEstyle-Anweisung.

unicode_literals

Führt die Literal-Syntax für das bytesObjekt ein. Dies bedeutet, dass Aussagen wie bytes('Hello world', 'ascii')einfach ausgedrückt werden können als b'Hello world'.

generator_stop

Ersetzt die Verwendung der StopIterationin Generatorfunktionen verwendeten Ausnahme durch die RuntimeErrorAusnahme.

Eine andere Verwendung, die oben nicht erwähnt wurde, ist, dass die __future__Anweisung auch die Verwendung von Python 2.1+ -Interpretern erfordert, da die Verwendung einer älteren Version eine Laufzeitausnahme auslöst.

Verweise

• 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/

Oder ist es so, als würde man sagen: "Da dies Python v2.7 ist, verwenden Sie diese andere 'print'-Funktion, die auch zu python v2.7 hinzugefügt wurde, nachdem sie in Python 3 hinzugefügt wurde. Mein' print 'wird also keine Anweisung mehr sein (z. B. "Nachricht" drucken), aber Funktionen (z. B. Drucken ("Nachricht", Optionen)). Wenn mein Code in Python 3 ausgeführt wird, wird "Drucken" auf diese Weise nicht unterbrochen. "

Im

from __future__ import print_function

print_function ist das Modul, das die neue Implementierung von 'print' enthält, wie es sich in Python v3 verhält.

Dies hat weitere Erklärungen: http://python3porting.com/noconv.html

Eine der Anwendungen, die ich als sehr nützlich empfand, ist das print_functionfrom- __future__Modul.

In Python 2.7 wollte ich, dass Zeichen aus verschiedenen Druckanweisungen in derselben Zeile ohne Leerzeichen gedruckt werden.

Dies kann durch ein Komma (",") am Ende erfolgen, es wird jedoch auch ein zusätzliches Leerzeichen angehängt. Die obige Aussage wird verwendet als:

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

Dadurch wird der Wert v_numjeder Iteration in einer einzelnen Zeile ohne Leerzeichen gedruckt .

Nach Python 3.0 ist print nicht mehr nur eine Anweisung, sondern eine Funktion. und ist in PEP 3105 enthalten.

Ich denke auch, dass das Python 3.0-Paket immer noch diese speziellen Funktionen hat. Sehen wir uns die Benutzerfreundlichkeit anhand eines traditionellen "Pyramid-Programms" in Python an:

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:
*
**
***
****

Wenn wir die normale Druckfunktion verwenden, können wir nicht dieselbe Ausgabe erzielen, da print () mit einem zusätzlichen Zeilenumbruch geliefert wird. Jedes Mal, wenn die innere for-Schleife ausgeführt wird, wird * in die nächste Zeile gedruckt.