GNU Info

(python2.1-ref.info)Future statements

---

Next: __future__ Prev: Future statements and nested scopes Up: Future statements and nested scopes

---

Enter node , (file) or (file)node

Future statements
=================

A "future statement"  is 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 only feature recognized by Python 2.1 is `nested_scopes'.

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 use the new syntax or semantics associated with
the future statement.

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.