6. Les instructions simples
***************************

Simple statements are comprised within a single logical line. Several
simple statements may occur on a single line separated by semicolons.
The syntax for simple statements is:

   simple_stmt ::= expression_stmt
                   | assert_stmt
                   | assignment_stmt
                   | augmented_assignment_stmt
                   | pass_stmt
                   | del_stmt
                   | print_stmt
                   | return_stmt
                   | yield_stmt
                   | raise_stmt
                   | break_stmt
                   | continue_stmt
                   | import_stmt
                   | future_stmt
                   | global_stmt
                   | exec_stmt


6.1. Les expressions
====================

Les expressions sont utilisées (généralement de manière interactive)
comme instructions pour calculer et écrire des valeurs, appeler une
procédure (une fonction dont le résultat renvoyé n’a pas d’importance
; en Python, les procédures renvoient la valeur "None"). D’autres
utilisations des expressions sont autorisées et parfois utiles. La
syntaxe pour une expression en tant qu’instruction est :

   expression_stmt ::= expression_list

Ce genre d’instruction évalue la liste d’expressions (qui peut se
limiter à une seule expression).

In interactive mode, if the value is not "None", it is converted to a
string using the built-in "repr()" function and the resulting string
is written to standard output (see section The print statement) on a
line by itself.  (Expression statements yielding "None" are not
written, so that procedure calls do not cause any output.)


6.2. Les assignations
=====================

Les assignations sont utilisées pour lier ou relier des noms à des
valeurs et modifier des attributs ou des éléments d’objets muables :

   assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression)
   target_list     ::= target ("," target)* [","]
   target          ::= identifier
              | "(" target_list ")"
              | "[" [target_list] "]"
              | attributeref
              | subscription
              | slicing

(See section Primaires for the syntax definitions for the last three
symbols.)

Une assignation évalue la liste d’expressions (gardez en mémoire que
ce peut être une simple expression ou une liste dont les éléments sont
séparés par des virgules, cette dernière produisant un n-uplet) et
assigne l’unique objet résultant à chaque liste cible, de la gauche
vers la droite.

Une assignation est définie récursivement en fonction de la forme de
la cible (une liste). Quand la cible est une partie d’un objet muable
(une référence à un attribut, une sélection ou une tranche), l’objet
muable doit effectuer l’assignation au final et décider de sa
validité, voire lever une exception si l’assignation n’est pas
acceptable. Les règles suivies par les différents types et les
exceptions levées sont données dans les définitions des types d’objets
(voir la section Hiérarchie des types standards).

Assignment of an object to a target list is recursively defined as
follows.

* If the target list is a single target: The object is assigned to
  that target.

* If the target list is a comma-separated list of targets: The
  object must be an iterable with the same number of items as there
  are targets in the target list, and the items are assigned, from
  left to right, to the corresponding targets.

L’assignation d’un objet vers une cible unique est définie
récursivement comme suit.

* Si la cible est une variable (un nom) :

  * If the name does not occur in a "global" statement in the
    current code block: the name is bound to the object in the current
    local namespace.

  * Otherwise: the name is bound to the object in the current global
    namespace.

  Le lien du nom est modifié si le nom était déjà lié. Ceci peut faire
  que le compteur de références de l’objet auquel le nom était
  précédemment lié tombe à zéro, entrainant la dé-allocation de
  l’objet et l’appel de son destructeur (s’il existe).

* If the target is a target list enclosed in parentheses or in
  square brackets: The object must be an iterable with the same number
  of items as there are targets in the target list, and its items are
  assigned, from left to right, to the corresponding targets.

* Si la cible est une référence à un attribut : l’expression
  primaire de la référence est évaluée. Elle doit produire un objet
  avec des attributs que l’on peut assigner : si ce n’est pas le cas,
  une "TypeError" est levée. Python demande alors à cet objet
  d’assigner l’attribut donné ; si ce n’est pas possible, une
  exception est levée (habituellement, mais pas nécessairement,
  "AttributeError").

  Note : si l’objet est une instance de classe et que la référence à
  l’attribut apparaît des deux côtés de l’opérateur d’assignation,
  l’expression « à droite », "a.x" peut accéder soit à l’attribut
  d’instance ou (si cet attribut d’instance n’existe pas) à l’attribut
  de classe. L’expression cible « à gauche » "a.x" est toujours
  définie comme un attribut d’instance, en le créant si nécessaire.
  Ainsi, les deux occurrences de "a.x" ne font pas nécessairement
  référence au même attribut : si l’expression « à droite » fait
  référence à un attribut de classe, l’expression « à gauche » crée un
  nouvel attribut d’instance comme cible de l’assignation :

     class Cls:
         x = 3             # class variable
     inst = Cls()
     inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

  Cette description ne s’applique pas nécessairement aux attributs des
  descripteurs, telles que les propriétés créées avec "property()".

* If the target is a subscription: The primary expression in the
  reference is evaluated.  It should yield either a mutable sequence
  object (such as a list) or a mapping object (such as a dictionary).
  Next, the subscript expression is evaluated.

  If the primary is a mutable sequence object (such as a list), the
  subscript must yield a plain integer.  If it is negative, the
  sequence’s length is added to it. The resulting value must be a
  nonnegative integer less than the sequence’s length, and the
  sequence is asked to assign the assigned object to its item with
  that index.  If the index is out of range, "IndexError" is raised
  (assignment to a subscripted sequence cannot add new items to a
  list).

  Si la primaire est un objet tableau de correspondances (tel qu’un
  dictionnaire), la sélection doit être d’un type compatible avec le
  type des clés ; Python demande alors au tableau de correspondances
  de créer un couple clé-valeur qui associe la sélection à l’objet
  assigné. Ceci peut remplacer une correspondance déjà existante pour
  une clé donnée ou insérer un nouveau couple clé-valeur.

* If the target is a slicing: The primary expression in the
  reference is evaluated.  It should yield a mutable sequence object
  (such as a list).  The assigned object should be a sequence object
  of the same type.  Next, the lower and upper bound expressions are
  evaluated, insofar they are present; defaults are zero and the
  sequence’s length.  The bounds should evaluate to (small) integers.
  If either bound is negative, the sequence’s length is added to it.
  The resulting bounds are clipped to lie between zero and the
  sequence’s length, inclusive.  Finally, the sequence object is asked
  to replace the slice with the items of the assigned sequence.  The
  length of the slice may be different from the length of the assigned
  sequence, thus changing the length of the target sequence, if the
  object allows it.

Dans l’implémentation actuelle, la syntaxe pour les cibles est
similaire à celle des expressions. Toute syntaxe invalide est rejetée
pendant la phase de génération de code, ce qui produit des messages
d’erreurs moins détaillés.

WARNING: Although the definition of assignment implies that overlaps
between the left-hand side and the right-hand side are “safe” (for
example "a, b = b, a" swaps two variables), overlaps *within* the
collection of assigned-to variables are not safe!  For instance, the
following program prints "[0, 2]":

   x = [0, 1]
   i = 0
   i, x[i] = 1, 2
   print x


6.2.1. Les assignations augmentées
----------------------------------

Une assignation augmentée est la combinaison, dans une seule
instruction, d’une opération binaire et d’une assignation :

   augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)
   augtarget                 ::= identifier | attributeref | subscription | slicing
   augop                     ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="
             | ">>=" | "<<=" | "&=" | "^=" | "|="

(See section Primaires for the syntax definitions for the last three
symbols.)

Une assignation augmentée évalue la cible (qui, au contraire des
assignations normales, ne peut pas être un dépaquetage) et la liste
d’expressions, effectue l’opération binaire (spécifique au type
d’assignation) sur les deux opérandes et assigne le résultat à la
cible originale. La cible n’est évaluée qu’une seule fois.

Une assignation augmentée comme "x += 1" peut être ré-écrite en "x = x
+ 1" pour obtenir un effet similaire, mais pas exactement équivalent.
Dans la version augmentée. "x" n’est évalué qu’une seule fois. Aussi,
lorsque c’est possible, l’opération concrète est effectuée *sur
place*, c’est-à-dire que plutôt que de créer un nouvel objet et
l’assigner à la cible, c’est le vieil objet qui est modifié.

À l’exception de l’assignation de tuples et de cibles multiples dans
une seule instruction, l’assignation effectuée par une assignation
augmentée est traitée de la même manière qu’une assignation normale.
De même, à l’exception du comportement possible *sur place*,
l’opération binaire effectuée par assignation augmentée est la même
que les opérations binaires normales.

Pour les cibles qui sont des références à des attributs, la même mise
en garde sur les attributs de classe et d’instances s’applique que
pour les assignations normales.


6.3. L’instruction "assert"
===========================

Les instructions "assert" sont une manière pratique d’insérer des
tests de débogage au sein d’un programme :

   assert_stmt ::= "assert" expression ["," expression]

La forme la plus simple, "assert expression", est équivalente à :

   if __debug__:
       if not expression: raise AssertionError

La forme étendue, "assert expression1, expression2", est équivalente à
:

   if __debug__:
       if not expression1: raise AssertionError(expression2)

Ces équivalences supposent que "__debug__" et "AssertionError" font
référence aux variables natives ainsi nommées. Dans l’implémentation
actuelle, la variable native "__debug__" vaut "True" dans des
circonstances normales, "False" quand les optimisations sont demandées
(ligne de commande avec l’option *-O*). Le générateur de code actuel
ne produit aucun code pour une instruction "assert" quand vous
demandez les optimisations à la compilation. Notez qu’il est superflu
d’inclure le code source dans le message d’erreur pour l’expression
qui a échoué : il est affiché dans la pile d’appels.

Assigner vers  "__debug__" est illégal. La valeur de cette variable
native est déterminée au moment où l’interpréteur démarre.


6.4. L’instruction  "pass"
==========================

   pass_stmt ::= "pass"

"pass" est une opération vide — quand elle est exécutée, rien ne se
passe. Elle est utile comme bouche-trou lorsqu’une instruction est
syntaxiquement requise mais qu’aucun code ne doit être exécuté. Par
exemple :

   def f(arg): pass    # a function that does nothing (yet)

   class C: pass       # a class with no methods (yet)


6.5. L’instruction "del"
========================

   del_stmt ::= "del" target_list

La suppression est récursivement définie de la même manière que
l’assignation. Plutôt que de détailler cela de manière approfondie,
voici quelques indices.

La suppression d’une liste cible (*target_list* dans la grammaire ci-
dessus) supprime récursivement chaque cible, de la gauche vers la
droite.

Deletion of a name removes the binding of that name  from the local or
global namespace, depending on whether the name occurs in a "global"
statement in the same code block.  If the name is unbound, a
"NameError" exception will be raised.

It is illegal to delete a name from the local namespace if it occurs
as a free variable in a nested block.

La suppression d’une référence à un attribut, une sélection ou une
tranche est passée à l’objet primaire concerné : la suppression d’une
tranche est en général équivalente à l’assignation d’une tranche vide
du type adéquat (mais ceci est au final déterminé par l’objet que l’on
tranche).


6.6. The "print" statement
==========================

   print_stmt ::= "print" ([expression ("," expression)* [","]]
                  | ">>" expression [("," expression)+ [","]])

"print" evaluates each expression in turn and writes the resulting
object to standard output (see below).  If an object is not a string,
it is first converted to a string using the rules for string
conversions.  The (resulting or original) string is then written.  A
space is written before each object is (converted and) written, unless
the output system believes it is positioned at the beginning of a
line.  This is the case (1) when no characters have yet been written
to standard output, (2) when the last character written to standard
output is a whitespace character except "' '", or (3) when the last
write operation on standard output was not a "print" statement. (In
some cases it may be functional to write an empty string to standard
output for this reason.)

Note: Objects which act like file objects but which are not the
  built-in file objects often do not properly emulate this aspect of
  the file object’s behavior, so it is best not to rely on this.

A "'\n'" character is written at the end, unless the "print" statement
ends with a comma.  This is the only action if the statement contains
just the keyword "print".

Standard output is defined as the file object named "stdout" in the
built-in module "sys".  If no such object exists, or if it does not
have a "write()" method, a "RuntimeError" exception is raised.

"print" also has an extended form, defined by the second portion of
the syntax described above. This form is sometimes referred to as «
"print" chevron. » In this form, the first expression after the ">>"
must evaluate to a « file-like » object, specifically an object that
has a "write()" method as described above.  With this extended form,
the subsequent expressions are printed to this file object.  If the
first expression evaluates to "None", then "sys.stdout" is used as the
file for output.


6.7. L’instruction "return"
===========================

   return_stmt ::= "return" [expression_list]

"return" ne peut être placée qu’à l’intérieur d’une définition de
fonction, pas à l’intérieur d’une définition de classe.

Si une liste d’expressions (*expression_list* dans la grammaire ci-
dessus) est présente, elle est évaluée, sinon "None" est utilisée
comme valeur par défaut.

"return" quitte l’appel à la fonction courante avec la liste
d’expressions (ou "None") comme valeur de retour.

Quand "return" fait sortir d’une instruction "try" avec une clause
"finally", cette clause "finally" est exécutée avant de réellement
quitter la fonction.

In a generator function, the "return" statement is not allowed to
include an "expression_list".  In that context, a bare "return"
indicates that the generator is done and will cause "StopIteration" to
be raised.


6.8. L’instruction "yield"
==========================

   yield_stmt ::= yield_expression

The "yield" statement is only used when defining a generator function,
and is only used in the body of the generator function. Using a
"yield" statement in a function definition is sufficient to cause that
definition to create a generator function instead of a normal
function.

When a generator function is called, it returns an iterator known as a
generator iterator, or more commonly, a generator.  The body of the
generator function is executed by calling the generator’s "next()"
method repeatedly until it raises an exception.

When a "yield" statement is executed, the state of the generator is
frozen and the value of "expression_list" is returned to "next()"”s
caller.  By « frozen » we mean that all local state is retained,
including the current bindings of local variables, the instruction
pointer, and the internal evaluation stack: enough information is
saved so that the next time "next()" is invoked, the function can
proceed exactly as if the "yield" statement were just another external
call.

As of Python version 2.5, the "yield" statement is now allowed in the
"try" clause of a "try" …  "finally" construct.  If the generator is
not resumed before it is finalized (by reaching a zero reference count
or by being garbage collected), the generator-iterator’s "close()"
method will be called, allowing any pending "finally" clauses to
execute.

Pour tous les détails sur la sémantique de "yield", reportez-vous à la
section Expressions yield.

Note: In Python 2.2, the "yield" statement was only allowed when the
  "generators" feature has been enabled.  This "__future__" import
  statement was used to enable the feature:

     from __future__ import generators

Voir aussi:

  **PEP 255**: Générateurs simples
     La proposition d’ajouter à Python des générateurs et
     l’instruction "yield".

  **PEP 342** – Coroutines *via* des générateurs améliorés
     The proposal that, among other generator enhancements, proposed
     allowing "yield" to appear inside a "try" … "finally" block.


6.9. L’instruction "raise"
==========================

   raise_stmt ::= "raise" [expression ["," expression ["," expression]]]

If no expressions are present, "raise" re-raises the last exception
that was active in the current scope.  If no exception is active in
the current scope, a "TypeError" exception is raised indicating that
this is an error (if running under IDLE, a "Queue.Empty" exception is
raised instead).

Otherwise, "raise" evaluates the expressions to get three objects,
using "None" as the value of omitted expressions.  The first two
objects are used to determine the *type* and *value* of the exception.

If the first object is an instance, the type of the exception is the
class of the instance, the instance itself is the value, and the
second object must be "None".

If the first object is a class, it becomes the type of the exception.
The second object is used to determine the exception value: If it is
an instance of the class, the instance becomes the exception value. If
the second object is a tuple, it is used as the argument list for the
class constructor; if it is "None", an empty argument list is used,
and any other object is treated as a single argument to the
constructor.  The instance so created by calling the constructor is
used as the exception value.

If a third object is present and not "None", it must be a traceback
object (see section Hiérarchie des types standards), and it is
substituted instead of the current location as the place where the
exception occurred.  If the third object is present and not a
traceback object or "None", a "TypeError" exception is raised.  The
three-expression form of "raise" is useful to re-raise an exception
transparently in an except clause, but "raise" with no expressions
should be preferred if the exception to be re-raised was the most
recently active exception in the current scope.

Des informations complémentaires sur les exceptions sont disponibles
dans la section Exceptions et sur la gestion des exceptions dans la
section L’instruction try.


6.10. L’instruction "break"
===========================

   break_stmt ::= "break"

Une instruction "break" ne peut apparaître qu’à l’intérieur d’une
boucle "for" ou "while", mais pas dans une définition de fonction ou
de classe à l’intérieur de cette boucle.

Elle termine la boucle la plus imbriquée, shuntant l’éventuelle clause
"else" de la boucle.

Si une boucle "for" est terminée par un "break", la cible qui contrôle
la boucle garde sa valeur.

Quand "break" passe le contrôle en dehors d’une instruction "try" qui
comporte une clause "finally", cette clause "finally" est exécutée
avant de quitter la boucle.


6.11. L’instruction "continue"
==============================

   continue_stmt ::= "continue"

L’instruction "continue" ne peut apparaître qu’à l’intérieur d’une
boucle "for" ou "while", mais pas dans une définition de fonction ou
de classe ni dans une clause "finally", à l’intérieur de cette boucle.
Elle fait continuer le flot d’exécution au prochain cycle de la boucle
la plus imbriquée.

Quand "continue" passe le contrôle en dehors d’une instruction "try"
qui comporte une clause "finally", cette clause "finally" est exécutée
avant de commencer le cycle suivant de la boucle.


6.12. L’instruction "import"
============================

   import_stmt     ::= "import" module ["as" name] ( "," module ["as" name] )*
                   | "from" relative_module "import" identifier ["as" name]
                   ( "," identifier ["as" name] )*
                   | "from" relative_module "import" "(" identifier ["as" name]
                   ( "," identifier ["as" name] )* [","] ")"
                   | "from" module "import" "*"
   module          ::= (identifier ".")* identifier
   relative_module ::= "."* module | "."+
   name            ::= identifier

Import statements are executed in two steps: (1) find a module, and
initialize it if necessary; (2) define a name or names in the local
namespace (of the scope where the "import" statement occurs). The
statement comes in two forms differing on whether it uses the "from"
keyword. The first form (without "from") repeats these steps for each
identifier in the list. The form with "from" performs step (1) once,
and then performs step (2) repeatedly.

To understand how step (1) occurs, one must first understand how
Python handles hierarchical naming of modules. To help organize
modules and provide a hierarchy in naming, Python has a concept of
packages. A package can contain other packages and modules while
modules cannot contain other modules or packages. From a file system
perspective, packages are directories and modules are files.

Once the name of the module is known (unless otherwise specified, the
term « module » will refer to both packages and modules), searching
for the module or package can begin. The first place checked is
"sys.modules", the cache of all modules that have been imported
previously. If the module is found there then it is used in step (2)
of import.

If the module is not found in the cache, then "sys.meta_path" is
searched (the specification for "sys.meta_path" can be found in **PEP
302**). The object is a list of *finder* objects which are queried in
order as to whether they know how to load the module by calling their
"find_module()" method with the name of the module. If the module
happens to be contained within a package (as denoted by the existence
of a dot in the name), then a second argument to "find_module()" is
given as the value of the "__path__" attribute from the parent package
(everything up to the last dot in the name of the module being
imported). If a finder can find the module it returns a *loader*
(discussed later) or returns "None".

If none of the finders on "sys.meta_path" are able to find the module
then some implicitly defined finders are queried. Implementations of
Python vary in what implicit meta path finders are defined. The one
they all do define, though, is one that handles "sys.path_hooks",
"sys.path_importer_cache", and "sys.path".

The implicit finder searches for the requested module in the « paths »
specified in one of two places (« paths » do not have to be file
system paths). If the module being imported is supposed to be
contained within a package then the second argument passed to
"find_module()", "__path__" on the parent package, is used as the
source of paths. If the module is not contained in a package then
"sys.path" is used as the source of paths.

Once the source of paths is chosen it is iterated over to find a
finder that can handle that path. The dict at
"sys.path_importer_cache" caches finders for paths and is checked for
a finder. If the path does not have a finder cached then
"sys.path_hooks" is searched by calling each object in the list with a
single argument of the path, returning a finder or raises
"ImportError". If a finder is returned then it is cached in
"sys.path_importer_cache" and then used for that path entry. If no
finder can be found but the path exists then a value of "None" is
stored in "sys.path_importer_cache" to signify that an implicit, file-
based finder that handles modules stored as individual files should be
used for that path. If the path does not exist then a finder which
always returns "None" is placed in the cache for the path.

If no finder can find the module then "ImportError" is raised.
Otherwise some finder returned a loader whose "load_module()" method
is called with the name of the module to load (see **PEP 302** for the
original definition of loaders). A loader has several responsibilities
to perform on a module it loads. First, if the module already exists
in "sys.modules" (a possibility if the loader is called outside of the
import machinery) then it is to use that module for initialization and
not a new module. But if the module does not exist in "sys.modules"
then it is to be added to that dict before initialization begins. If
an error occurs during loading of the module and it was added to
"sys.modules" it is to be removed from the dict. If an error occurs
but the module was already in "sys.modules" it is left in the dict.

The loader must set several attributes on the module. "__name__" is to
be set to the name of the module. "__file__" is to be the « path » to
the file unless the module is built-in (and thus listed in
"sys.builtin_module_names") in which case the attribute is not set. If
what is being imported is a package then "__path__" is to be set to a
list of paths to be searched when looking for modules and packages
contained within the package being imported. "__package__" is optional
but should be set to the name of package that contains the module or
package (the empty string is used for module not contained in a
package). "__loader__" is also optional but should be set to the
loader object that is loading the module.

If an error occurs during loading then the loader raises "ImportError"
if some other exception is not already being propagated. Otherwise the
loader returns the module that was loaded and initialized.

When step (1) finishes without raising an exception, step (2) can
begin.

The first form of "import" statement binds the module name in the
local namespace to the module object, and then goes on to import the
next identifier, if any.  If the module name is followed by "as", the
name following "as" is used as the local name for the module.

The "from" form does not bind the module name: it goes through the
list of identifiers, looks each one of them up in the module found in
step (1), and binds the name in the local namespace to the object thus
found.  As with the first form of "import", an alternate local name
can be supplied by specifying « "as" localname ».  If a name is not
found, "ImportError" is raised.  If the list of identifiers is
replaced by a star ("'*'"), all public names defined in the module are
bound in the local namespace of the "import" statement..

The *public names* defined by a module are determined by checking the
module’s namespace for a variable named "__all__"; if defined, it must
be a sequence of strings which are names defined or imported by that
module.  The names given in "__all__" are all considered public and
are required to exist.  If "__all__" is not defined, the set of public
names includes all names found in the module’s namespace which do not
begin with an underscore character ("'_'"). "__all__" should contain
the entire public API. It is intended to avoid accidentally exporting
items that are not part of the API (such as library modules which were
imported and used within the module).

The "from" form with "*" may only occur in a module scope.  If the
wild card form of import — "import *" — is used in a function and the
function contains or is a nested block with free variables, the
compiler will raise a "SyntaxError".

Quand vous spécifiez les modules à importer, vous n’avez pas besoin de
spécifier les noms absolus des modules. Quand un module ou un paquet
est contenu dans un autre paquet, il est possible d’effectuer une
importation relative à l’intérieur du même paquet de plus haut niveau
sans avoir à mentionner le nom du paquet. En utilisant des points en
entête du module ou du paquet spécifié après "from", vous pouvez
spécifier combien de niveaux vous souhaitez remonter dans la
hiérarchie du paquet courant sans spécifier de nom exact. Un seul
point en tête signifie le paquet courant où se situe le module qui
effectue l’importation. Deux points signifient de remonter d’un
niveau. Trois points, remonter de deux niveaux et ainsi de suite.
Ainsi, si vous exécutez "from . import mod" dans un module du paquet
"pkg", vous importez finalement "pkg.mod". Et si vous exécutez "from
..souspkg2 import mod" depuis "pkg.souspkg1", vous importez finalement
"pkg.souspkg2.mod". La spécification des importations relatives se
situe dans la  **PEP 328**.

"importlib.import_module()" is provided to support applications that
determine which modules need to be loaded dynamically.


6.12.1. L’instruction future
----------------------------

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])*
                        | "from" "__future__" "import" "(" feature ["as" name]
                        ("," feature ["as" name])* [","] ")"
   feature          ::= identifier
   name             ::= identifier

Une instruction *future* doit apparaître en haut du module. Les seules
lignes autorisées avant une instruction *future* sont :

* la chaîne de documentation du module (si elle existe),

* des commentaires,

* des lignes vides et

* d’autres instructions *future*.

The features recognized by Python 2.6 are "unicode_literals",
"print_function", "absolute_import", "division", "generators",
"nested_scopes" and "with_statement".  "generators", "with_statement",
"nested_scopes" are redundant in Python version 2.6 and above because
they are always enabled.

Une instruction *future* est reconnue et traitée spécialement au
moment de la compilation : les modifications à la sémantique des
constructions de base sont souvent implémentées en générant un code
différent. Il peut même arriver qu’une nouvelle fonctionnalité ait une
syntaxe incompatible (tel qu’un nouveau mot réservé) ; dans ce cas, le
compilateur a besoin d’analyser le module de manière différente. De
telles décisions ne peuvent pas être différées au moment de
l’exécution.

Pour une version donnée, le compilateur sait quelles fonctionnalités
ont été définies et lève une erreur à la compilation si une
instruction *future* contient une fonctionnalité qui lui est inconnue.

La sémantique à l’exécution est la même que pour toute autre
instruction d’importation : il existe un module standard "__future__",
décrit plus loin, qui est importé comme les autres au moment ou
l’instruction *future* est exécutée.

La sémantique particulière à l’exécution dépend des fonctionnalités
apportées par l’instruction *future*.

Notez que l’instruction suivante est tout à fait normale :

   import __future__ [as name]

Ce n’est pas une instruction *future* ; c’est une instruction
d’importation ordinaire qui n’a aucune sémantique particulière ou
restriction de syntaxe.

Code compiled by an "exec" statement or calls to the built-in
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 for details.

Une instruction *future* entrée à l’invite de l’interpréteur
interactif est effective pour le reste de la session de
l’interpréteur. Si l’interpréteur est démarré avec l’option  "-i",
qu’un nom de script est passé pour être exécuté et que ce script
contient une instruction *future*, elle est effective pour la session
interactive qui démarre après l’exécution du script.

Voir aussi:

  **PEP 236** – retour vers le __future__
     La proposition originale pour le mécanisme de __future__.


6.13. L’instruction "global"
============================

   global_stmt ::= "global" identifier ("," identifier)*

L’instruction "global" est une déclaration qui couvre l’ensemble du
bloc de code courant. Elle signifie que les noms (*identifier* dans la
grammaire ci-dessus) listés doivent être interprétés comme globaux. Il
est impossible d’assigner une variable globale sans "global", mais
rappelez-vous que les variables libres peuvent faire référence à des
variables globales sans avoir été déclarées en tant que telles.

Les noms listés dans l’instruction "global" ne doivent pas être
utilisés, dans le même bloc de code, avant l’instruction "global".

Names listed in a "global" statement must not be defined as formal
parameters or in a "for" loop control target, "class" definition,
function definition, or "import" statement.

**CPython implementation detail:** The current implementation does not
enforce the latter two restrictions, but programs should not abuse
this freedom, as future implementations may enforce them or silently
change the meaning of the program.

**Programmer’s note:** "global" is a directive to the parser.  It
applies only to code parsed at the same time as the "global"
statement. In particular, a "global" statement contained in an "exec"
statement does not affect the code block *containing* the "exec"
statement, and code contained in an "exec" statement is unaffected by
"global" statements in the code containing the "exec" statement.  The
same applies to the "eval()", "execfile()" and "compile()" functions.


6.14. The "exec" statement
==========================

   exec_stmt ::= "exec" or_expr ["in" expression ["," expression]]

This statement supports dynamic execution of Python code.  The first
expression should evaluate to either a Unicode string, a *Latin-1*
encoded string, an open file object, a code object, or a tuple.  If it
is a string, the string is parsed as a suite of Python statements
which is then executed (unless a syntax error occurs). [1] If it is an
open file, the file is parsed until EOF and executed. If it is a code
object, it is simply executed.  For the interpretation of a tuple, see
below.  In all cases, the code that’s executed is expected to be valid
as file input (see section Fichier d’entrée).  Be aware that the
"return" and "yield" statements may not be used outside of function
definitions even within the context of code passed to the "exec"
statement.

In all cases, if the optional parts are omitted, the code is executed
in the current scope.  If only the first expression after "in" is
specified, it should be a dictionary, which will be used for both the
global and the local variables.  If two expressions are given, they
are used for the global and local variables, respectively. If
provided, *locals* can be any mapping object. Remember that at module
level, globals and locals are the same dictionary. If two separate
objects are given as *globals* and *locals*, the code will be executed
as if it were embedded in a class definition.

The first expression may also be a tuple of length 2 or 3.  In this
case, the optional parts must be omitted.  The form "exec(expr,
globals)" is equivalent to "exec expr in globals", while the form
"exec(expr, globals, locals)" is equivalent to "exec expr in globals,
locals".  The tuple form of "exec" provides compatibility with Python
3, where "exec" is a function rather than a statement.

Modifié dans la version 2.4: Formerly, *locals* was required to be a
dictionary.

As a side effect, an implementation may insert additional keys into
the dictionaries given besides those corresponding to variable names
set by the executed code.  For example, the current implementation may
add a reference to the dictionary of the built-in module "__builtin__"
under the key "__builtins__" (!).

**Programmer’s hints:** dynamic evaluation of expressions is supported
by the built-in function "eval()".  The built-in functions "globals()"
and "locals()" return the current global and local dictionary,
respectively, which may be useful to pass around for use by "exec".

-[ Notes ]-

[1] Note that the parser only accepts the Unix-style end of line
    convention. If you are reading the code from a file, make sure to
    use *universal newlines* mode to convert Windows or Mac-style
    newlines.
