A.1 Future statements

A future statementis a directive to
the compiler that a particular module should be compiled using syntax
or semantics that will be available in a specified future release of
Python. The future statement is intended to ease migration to future
versions of Python that introduce incompatible changes to the
language. It allows use of the new features on a per-module basis
before the release in which the feature becomes standard.

future_statement

::=

"from" "__future__" "import" feature ["as" name]

("," feature ["as" name])*

feature

::=

identifier

name

::=

identifier

A future statement must appear near the top of the module. The only
lines that can appear before a future statement are:

the module docstring (if any),

comments,

blank lines, and

other future statements.

The features recognized by Python 2.2 are "generators",
"division" and "nested_scopes". "nested_scopes"
is redundant in 2.2 as the nested scopes feature is active by default.

A future statement is recognized and treated specially at compile
time: Changes to the semantics of core constructs are often
implemented by generating different code. It may even be the case
that a new feature introduces new incompatible syntax (such as a new
reserved word), in which case the compiler may need to parse the
module differently. Such decisions cannot be pushed off until
runtime.

For any given release, the compiler knows which feature names have been
defined, and raises a compile-time error if a future statement contains
a feature not known to it.

The direct runtime semantics are the same as for any import statement:
there is a standard module __future__, described later, and
it will be imported in the usual way at the time the future statement
is executed.

The interesting runtime semantics depend on the specific feature
enabled by the future statement.

Note that there is nothing special about the statement:

import __future__ [as name]

That is not a future statement; it's an ordinary import statement with
no special semantics or syntax restrictions.

Code compiled by an exec statement or calls to the builtin functions
compile() and execfile() that occur in a module
M containing a future statement will, by default, use the new
syntax or semantics associated with the future statement. This can,
starting with Python 2.2 be controlled by optional arguments to
compile() -- see the documentation of that function in the
library reference for details.

A future statement typed at an interactive interpreter prompt will
take effect for the rest of the interpreter session. If an
interpreter is started with the -i option, is passed a
script name to execute, and the script includes a future statement, it
will be in effect in the interactive session started after the script
is executed.