__future__ — Definitioner av framtidsuttalanden

Källkod: Lib/__future__.py

Import av formen from __future__ import feature kallas future statements. Dessa är specialanpassade av Python-kompilatorn för att tillåta användning av nya Python-funktioner i moduler som innehåller framtidsuttalandet före den utgåva där funktionen blir standard.

Även om dessa future-satser ges ytterligare speciell betydelse av Python-kompilatorn, exekveras de fortfarande som vilken annan importsats som helst och __future__ existerar och hanteras av importsystemet på samma sätt som vilken annan Python-modul som helst. Denna design tjänar tre syften:

  • För att undvika förvirring hos befintliga verktyg som analyserar importmeddelanden och förväntar sig att hitta de moduler som de importerar.

  • För att dokumentera när inkompatibla ändringar infördes och när de kommer att bli — eller var — obligatoriska. Detta är en form av körbar dokumentation och kan inspekteras programmatiskt genom att importera __future__ och undersöka dess innehåll.

  • För att säkerställa att future statements som körs under utgåvor före Python 2.1 åtminstone ger upphov till körtidsundantag (importen av __future__ kommer att misslyckas, eftersom det inte fanns någon modul med det namnet före 2.1).

Modulens innehåll

Ingen funktionsbeskrivning kommer någonsin att tas bort från __future__. Sedan introduktionen i Python 2.1 har följande funktioner hittat sin väg in i språket med hjälp av denna mekanism:

funktion

valfritt i

obligatorisk i

effekt
__future__.nested_scopes

2.1.0b1

2.2

PEP 227: Statiskt nästlade scopes
__future__.generators

2.2.0a1

2.3

PEP 255: Enkla generatorer
__future__.division

2.2.0a2

3.0

PEP 238: Byte av divisionsoperator
__future__.absolute_import

2.5.0a1

3.0

PEP 328: Importerar: Flera rader och absolut/relativ
__future__.with_statement

2.5.0a1

2.6

PEP 343: ”with”-uttalandet
__future__.print_function

2.6.0a2

3.0

PEP 3105: Gör print till en funktion
__future__.unicode_literals

2.6.0a2

3.0

PEP 3112: Byteslitteraler i Python 3000
__future__.generator_stop

3.5.0b1

3.7

PEP 479: StopIteration-hantering i generatorer
__future__.annotations

3.7.0b1

Never [1]

PEP 563: Uppskjuten utvärdering av anteckningar, PEP 649: Uppskjuten utvärdering av anteckningar med hjälp av deskriptorer
class __future__._Feature

Varje uttalande i __future__.py är av formen:

FeatureName = _Feature(OptionalRelease, MandatoryRelease,
                       CompilerFlag)

där normalt OptionalRelease är mindre än MandatoryRelease, och båda är 5-tupler av samma form som sys.version_info:

(PY_MAJOR_VERSION, # den 2 i 2.1.0a3; ett int
 PY_MINOR_VERSION, # den 1; ett int
 PY_MICRO_VERSION, # den 0; ett int
 PY_RELEASE_LEVEL, # "alpha", "beta", "candidate" eller "final"; sträng
 PY_RELEASE_SERIAL # 3; ett int
)
_Feature.getOptionalRelease()

OptionalRelease registrerar den första utgåvan i vilken funktionen accepterades.

_Feature.getMandatoryRelease()

När det gäller en MandatoryRelease som ännu inte har inträffat, förutspår MandatoryRelease den version där funktionen kommer att bli en del av språket.

Else MandatoryRelease registrerar när funktionen blev en del av språket; i utgåvor från och med den tidpunkten behöver moduler inte längre ett framtida uttalande för att använda funktionen i fråga, men kan fortsätta att använda sådana importer.

MandatoryRelease kan också vara None, vilket innebär att en planerad funktion har strukits eller att den ännu inte är beslutad.

_Feature.compiler_flag

CompilerFlag är den (bitfield) flagga som ska skickas i det fjärde argumentet till den inbyggda funktionen compile() för att aktivera funktionen i dynamiskt kompilerad kod. Denna flagga lagras i attributet _Feature.compiler_flag på _Feature-instanser.

Se även

Framtida uttalanden

Hur kompilatorn behandlar framtida import.

PEP 236 - Tillbaka till __future__

Det ursprungliga förslaget till mekanismen __future__.