__future__verschijnt vaak in Python-modules. Ik begrijp niet wat __future__is voor en hoe / wanneer u het wilt gebruiken, zelfs na het lezen van De Python’s __future__DOC .
Kan iemand uitleggen met voorbeelden?
Een paar antwoorden met betrekking tot het basisgebruik van __future__die ik heb ontvangen leek correct.
Ik moet echter nog een ding begrijpen over hoe __future__werkt:
Het meest verwarrende concept voor mij is hoe een huidige Python-release functies omvat voor toekomstige releases, en hoe een programma met behulp van een functie van een toekomstige release met succes kan worden samengesteld in de huidige versie van Python.
Ik gok dat de huidige release is verpakt met potentiële functies voor de toekomst. De functies zijn echter alleen beschikbaar door __future__te gebruiken omdat ze niet de huidige standaard zijn. Laat me weten of ik gelijk heb.
Antwoord 1, Autoriteit 100%
Met __future__MODULES INCLUSIE, kunt u langzaam gewend zijn aan incompatibele wijzigingen of aan dergelijke introductie van nieuwe zoekwoorden.
Bijvoorbeeld voor het gebruik van contextmanagers, moest u from __future__ import with_statementin 2.5, zoals de withtrefwoord is nieuw en mag niet worden gebruikt als variabele namen langer. Om withals Python-sleutelwoord in Python 2.5 of ouder te gebruiken, moet u de import van boven gebruiken.
Een ander voorbeeld is
from __future__ import division
print 8/7 # prints 1.1428571428571428
print 8//7 # prints 1
Zonder de __future__dingen, zouden beide printstatements 1afdrukken.
Het interne verschil is dat zonder die import /wordt toegewezen aan de methode __div__(), terwijl daarmee __truediv__()is gebruikt. (In ieder geval roept //__floordiv__()aan.)
Apropos print: printwordt een functie in 3.x en verliest zijn speciale eigenschap als trefwoord. Het is dus andersom.
>>> print
>>> from __future__ import print_function
>>> print
<built-in function print>
>>>
Antwoord 2, autoriteit 49%
Als je dat doet
from __future__ import whatever
Je gebruikt eigenlijk geen import-instructie, maar een toekomstige verklaring. Je leest de verkeerde documenten, omdat je die module niet echt importeert.
Toekomstige instructies zijn speciaal — ze veranderen hoe je Python-module wordt geparseerd, daarom moeten ze moetenbovenaan het bestand staan. Ze geven een nieuwe – of andere – betekenis aan woorden of symbolen in uw bestand. Uit de documenten:
Een toekomstige instructie is een instructie aan de compiler dat een bepaalde module moet worden gecompileerd met behulp van syntaxis of semantiek die beschikbaar zal zijn in een gespecificeerde toekomstige versie van Python. De toekomstige verklaring is bedoeld om de migratie naar toekomstige versies van Python te vergemakkelijken die onverenigbare wijzigingen in de taal introduceren. Het maakt het gebruik van de nieuwe functies per module mogelijk vóór de release waarin de functie standaard wordt.
Als u de module __future__daadwerkelijk wilt importeren, doet u dat gewoon
import __future__
en open het dan zoals gewoonlijk.
Antwoord 3, autoriteit 28%
__future__is een pseudo-module die programmeurs kunnen gebruiken om nieuwe taalfuncties in te schakelen die niet compatibel zijn met de huidige tolk. De uitdrukking 11/4evalueert momenteel bijvoorbeeld tot 2. Als de module waarin het wordt uitgevoerd ware deling had ingeschakeld door het uitvoeren van:
from __future__ import division
de uitdrukking 11/4zou resulteren in 2.75. Door de module __future__te importeren en de variabelen te evalueren, kunt u zien wanneer een nieuwe functie voor het eerst aan de taal is toegevoegd en wanneer deze de standaard wordt:
>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
Antwoord 4, autoriteit 14%
Het kan worden gebruikt om functies te gebruiken die in nieuwere versies verschijnen terwijl ze een oudere versie van Python hebben.
Bijvoorbeeld
>>> from __future__ import print_function
laat je toe om printals functie te gebruiken:
>>> print('# of entries', len(dictionary), file=sys.stderr)
Antwoord 5, autoriteit 13%
Er zijn al een aantal geweldige antwoorden, maar geen van hen behandelt een volledige lijst van wat de __future__-instructie momenteel ondersteunt.
Simpel gezegd, __future__verklaring krachten Python tolken naar nieuwere kenmerken van de taal te gebruiken.
De functies die het op dit moment ondersteunt zijn de volgende:
nested_scopes
Voorafgaand aan Python 2.1, de volgende code zou een NameError verhogen
def f():
...
def g(value):
...
return g(value-1) + 1
...
from __future__ import nested_scopesrichtlijn zal zorgen voor deze functie in te schakelen.
generators
Introductie generator functioneert zoals hieronder aan te geven tussen opeenvolgende functieaanroepen slaan:
def fib():
a, b = 0, 1
while 1:
yield b
a, b = b, a+b
division
Classic divisie wordt gebruikt in Python 2.x versies. Dit betekent dat sommige divisie uitspraken terug een redelijke benadering van divisie ( “true divisie”) en anderen de terugkeer van de verdieping ( “vloer divisie”). Vanaf Python 3.0, waar is gespecificeerd door deling x/y, terwijl verdieping deling wordt gespecificeerd door x//y.
from __future__ import divisionrichtlijn krachten het gebruik van Python 3.0 stijl divisie.
absolute_import
Maakt haakjes in te sluiten meerdere importstatements. Bijvoorbeeld:
from Tkinter import (Tk, Frame, Button, Entry, Canvas, Text,
LEFT, DISABLED, NORMAL, RIDGE, END)
in plaats van:
from Tkinter import Tk, Frame, Button, Entry, Canvas, Text, \
LEFT, DISABLED, NORMAL, RIDGE, END
Of:
from Tkinter import Tk, Frame, Button, Entry, Canvas, Text
from Tkinter import LEFT, DISABLED, NORMAL, RIDGE, END
with_statement
Voegt de instructie withtoe als sleutelwoord in Python om de noodzaak voor try/finally-instructies te elimineren. Veelvoorkomend gebruik hiervan is bij het uitvoeren van bestands-I/O, zoals:
with open('workfile', 'r') as f:
read_data = f.read()
print_function:
Dwingt het gebruik van de functieaanroep print()in de stijl van Python 3 in plaats van de print MESSAGE-stijlinstructie.
unicode_literals
Introduceert de letterlijke syntaxis voor het bytesobject. Dit betekent dat uitspraken als bytes('Hello world', 'ascii')eenvoudig kunnen worden uitgedrukt als b'Hello world'.
generator_stop
Vervangt het gebruik van de StopIteration-uitzondering die wordt gebruikt in generatorfuncties door de RuntimeError-uitzondering.
Een ander gebruik dat hierboven niet is genoemd, is dat de instructie __future__ook het gebruik van Python 2.1+-interpreters vereist, aangezien het gebruik van een oudere versie een runtime-uitzondering veroorzaakt.
Referenties
- https://docs.python.org/2/library/toekomst .html
- https://docs.python.org/3/library/toekomst .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 /
Antwoord 6, autoriteit 6%
Of is het alsof je zegt: “Aangezien dit python v2.7 is, gebruik die andere ‘print’-functie die ook is toegevoegd aan python v2.7, nadat deze was toegevoegd in python 3. Dus mijn ‘print’ zal niet meer statements zijn (bijv. print “message”) maar functies (bijv. print(“message”, options). Op die manier zal ‘print’ niet breken wanneer mijn code wordt uitgevoerd in python 3.”
In
from __future__ import print_function
print_function is de module die de nieuwe implementatie van ‘print’ bevat volgens hoe het zich gedraagt in python v3.
Dit heeft meer uitleg: http://python3porting.com/noconv.html
Antwoord 7
Een van de toepassingen die ik erg nuttig vond, is de print_functionvan de __future__-module.
In Python 2.7 wilde ik dat tekens van verschillende printinstructies op dezelfde regel zouden worden afgedrukt zonder spaties.
Het kan worden gedaan met een komma(“,”) aan het einde, maar het voegt ook een extra spatie toe.
De bovenstaande verklaring bij gebruik als:
from __future__ import print_function
...
print (v_num,end="")
...
Hierdoor drukt u de waarde van v_numvan elke iteratie in een enkele regel zonder spaties.
Antwoord 8
__future__is een python module . Er werd toegevoegd om te voorkomen dat de bestaande instrumenten die invoerinstructies hadden geanalyseerd en naar verwachting de modules die ze importeren te vinden. Het werd toegevoegd in versie 2.1, dus import van __future__falen indien gebruikt vóór de versie 2.1.
Zie nu deze code:
>>> from __future__ import division
>>> division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 131072)
De Divisie Geretourneerd in het formaat van _Feature(OptionalRelease, MandatoryRelease, CompilerFlag). Optimeerreeks en MandatoryRelease zijn beide 5-tuples in de vorm van:
(
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
)
Dus in ons geval, is optionele reelease 2.2.0A2 en verplichte reelease is 3.0.0A0.
Optionerreyease vertelt ons de eerste release wanneer de functie is geaccepteerd.
MandatoireElease voorspelt wanneer de functie deel uitmaakt van de taal of laat zien wanneer de functie deel uitmaakte van de taal; In releases bij of daarna hebben modules geen toekomstige verklaring meer nodig om de betreffende functie te gebruiken, maar kunnen deze invoer blijven gebruiken. Als MandatoryREase is er geen dan die geplande functie is gevallen.
COMPILERFLAG is de (Bitfield) -vlag die in het vierde argument moet worden doorgegeven aan de ingebouwde functie Compileer () om de functie in dynamisch gecompileerde code in te schakelen. Deze vlag is opgeslagen in het kenmerk COMPILER_FLAG op _feature-instanties.
Antwoord 9
Na Python 3.0 wordt afdruk niet langer alleen een verklaring, het is in plaats daarvan een functie. en is opgenomen in PEP 3105.
Ik denk ook dat het python 3.0-pakket nog steeds deze speciale functionaliteit heeft. Laten we de bruikbaarheid zien via een traditioneel “Pyramid-programma” in 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:
*
**
***
****
Als we normale afdrukfunctie gebruiken, kunnen we niet in staat zijn om dezelfde output te bereiken, want afdrukken () wordt geleverd met een extra nieuwlijn. Dus elke keer dat de innerlijke voor lus uitvoert, drukt deze * op de volgende regel af.