 |
 |
 |
Il manuale di riferimento di Python |  |
 |
 |
|
|
|
Il manuale di riferimento di Python | |
|
|
Un'istruzione future è una direttiva per il compilatore per un modulo particolare che dovrebbe essere compilato usando una sintassi o una semantica che sarà disponibile in una versione futura di Python. L'istruzione future è intesa per migrare facilmente ad una versione futura di Python che introduce cambiamenti incompatibili per il linguaggio. Permette l'uso delle nuove caratteristiche su una base di propri moduli, prima che la release in cui si trova la caratteristica diventi standard.
future_statement |
::= | "from" "__future__" "import" feature ["as" name] |
("," feature ["as" name])* | ||
feature |
::= | identifier |
name |
::= | identifier |
Un'istruzione future deve apparire vicino la parte alta del modulo. Le uniche righe che possono apparire prima di una dichiarazione future sono:
Le caratteristiche riconosciute da Python 2.3 sono "generators", "division" e "nested_scopes". I "generators" e i "nested_scopes" sono ridondanti in 2.3 perché sono sempre abilitati.
Un'istruzione future viene riconosciuta e trattata al momento della compilazione: i cambiamenti alla semantica del costrutto base vengono regolarmente implementati per generare codice differente. Potrebbe essere il caso che una nuova caratteristica introduca nuove incompatibilità sintattiche (come una nuova parola riservata), in quel caso il compilatore può avere bisogno di analizzare il modulo in modo differente. Queste decisioni non possono essere prese fino a che il programma è in esecuzione.
Per ogni release rilasciata, il compilatore sa quali nomi di caratteristiche sono stati definiti e solleva un'eccezione per la compilazione a runtime se una dichiarazione future contiene una caratteristica non conosciuta da esso.
Le semantiche di esecuzione diretta sono le stesse per ogni istruzione importante: c'è un modulo __future__ standard, descritto successivamente e verrà importato nel modo usuale al momento in cui l'istruzione future verrà eseguita.
La parte interessante della semantica a runtime dipende dalla specifica caratteristica abilitata dall'istruzione future.
Notare che non c'è niente di speciale nella dichiarazione:
import __future__ [as name]
Questa non è un'istruzione future, è un'istruzione di importazione ordinaria con nessuna speciale semantica o restrizione di sintassi.
Il codice compilato da un'istruzione exec o chiamato da una funzione buit-in compile() ed execfile(), che capitano nel modulo M, contenente una dichiarazione future, userà, in modo predefinito, la nuova sintassi o semantica associata con la dichiarazione future. Questo può, avviando Python 2.2, essere controllato dagli argomenti facoltativi per compile() -- per dettagli vedere la documentazione di questa funzione nella libreria di riferimento.
Una dichiarazione future scritta in un prompt interattivo resterà effettiva per il resto della sessione interpretata. Se un interprete viene avviato con l'opzione -i, verrà passato il nome di uno script da eseguire e se lo script include un'istruzione future, questa avrà effetto nelle sessione interattive avviate dopo l'esecuzione dello script.
|
|
|
Il manuale di riferimento di Python | |
|
|