4. Modèle d'exécution
*********************


4.1. Structure d'un programme
=============================

Un programme Python est construit à partir de blocs de code. Un *bloc*
est un morceau de texte de programme Python qui est exécuté en tant
qu'unité. Les éléments suivants sont des blocs : un module, un corps
de fonction et une définition de classe. Chaque commande écrite dans
l'interpréteur interactif de Python est un bloc. Un fichier de script
(un fichier donné en entrée standard à l'interpréteur ou spécifié en
tant qu'argument de ligne de commande à l'interpréteur) est un bloc de
code. Une commande de script (une commande spécifiée en ligne de
commande à l'interpréteur avec l'option "-c") est un bloc de code. Un
module exécuté en tant que script principal (module "__main__") depuis
la ligne de commande en utilisant l'option "-m" est aussi un bloc de
code. La chaîne passée en argument aux fonctions natives "eval()" et
"exec()" est un bloc de code.

Un bloc de code est exécuté dans un *cadre d'exécution*. Un cadre
contient des informations administratives (utilisées pour le débogage)
et détermine où et comment l'exécution se poursuit après la fin de
l'exécution du bloc de code.


4.2. Noms et liaisons
=====================


4.2.1. Liaisons des noms
------------------------

Les *noms* sont des références aux objets. Ils sont créés lors des
opérations de liaisons de noms (*name binding* en anglais).

Les noms sont liés *via* les constructions suivantes :

* paramètres formels de fonctions,

* définitions de classes,

* définitions de fonctions,

* expressions d'affectation,

* cibles qui sont des identifiants, lorsque c'est une affectation :

  * de l'entête d'une boucle "for",

  * after "as" in a "with" statement, "except" clause, "except*"
    clause, or in the as-pattern in structural pattern matching,

  * dans un champ de recherche d'un filtrage par motifs

* des instructions "import".

* "type" statements.

* type parameter lists.

L'instruction "import" sous la forme "from ... import *" lie tous les
noms définis dans le module importé, sauf ceux qui commencent par le
caractère souligné. Cette écriture ne peut être utilisée qu'au niveau
du module.

Une cible qui apparaît dans une instruction "del" est aussi considérée
comme une liaison à un nom dans ce cadre (bien que la sémantique
véritable soit de délier le nom).

Chaque affectation ou instruction *import* a lieu dans un bloc défini
par une définition de classe ou de fonction, ou au niveau du module
(le bloc de code de plus haut niveau).

Si un nom est lié dans un bloc, c'est une variable locale de ce bloc,
à moins qu'il ne soit déclaré "nonlocal" ou "global". Si un nom est
lié au niveau du module, c'est une variable globale (les variables du
bloc de code de niveau module sont locales et globales). Si une
variable est utilisée dans un bloc de code alors qu'elle n'y est pas
définie, c'est une *variable libre*.

Chaque occurrence d'un nom dans un programme fait référence à la
*liaison* de ce nom établie par les règles de résolution des noms
suivantes.


4.2.2. Résolution des noms
--------------------------

La *portée* définit la visibilité d'un nom dans un bloc. Si une
variable locale est définie dans un bloc, sa portée comprend ce bloc.
Si la définition intervient dans le bloc d'une fonction, la portée
s'étend à tous les blocs contenus dans celui qui comprend la
définition, à moins qu'un bloc intérieur ne définisse une autre
liaison pour ce nom.

Quand un nom est utilisé dans un bloc de code, la résolution utilise
la portée la plus petite. L'ensemble de toutes les portées visibles
dans un bloc de code s'appelle *l'environnement* du bloc.

Quand un nom n'est trouvé nulle part, une exception "NameError" est
levée. Si la portée courante est celle d'une fonction et que le nom
fait référence à une variable locale qui n'a pas encore été liée au
moment où le nom est utilisé, une exception "UnboundLocalError" est
levée. "UnboundLocalError" est une sous-classe de "NameError".

If a name binding operation occurs anywhere within a code block, all
uses of the name within the block are treated as references to the
current block.  This can lead to errors when a name is used within a
block before it is bound.  This rule is subtle.  Python lacks
declarations and allows name binding operations to occur anywhere
within a code block.  The local variables of a code block can be
determined by scanning the entire text of the block for name binding
operations. See the FAQ entry on UnboundLocalError for examples.

If the "global" statement occurs within a block, all uses of the names
specified in the statement refer to the bindings of those names in the
top-level namespace.  Names are resolved in the top-level namespace by
searching the global namespace, i.e. the namespace of the module
containing the code block, and the builtins namespace, the namespace
of the module "builtins".  The global namespace is searched first.  If
the names are not found there, the builtins namespace is searched
next. If the names are also not found in the builtins namespace, new
variables are created in the global namespace. The global statement
must precede all uses of the listed names.

L'instruction "global" a la même porte qu'une opération de liaison du
même bloc. Si la portée englobante la plus petite pour une variable
libre contient une instruction *global*, la variable libre est
considérée globale.

The "nonlocal" statement causes corresponding names to refer to
previously bound variables in the nearest enclosing function scope.
"SyntaxError" is raised at compile time if the given name does not
exist in any enclosing function scope. Type parameters cannot be
rebound with the "nonlocal" statement.

L'espace de nommage pour un module est créé automatiquement la
première fois que le module est importé. Le module principal d'un
script s'appelle toujours "__main__".

Class definition blocks and arguments to "exec()" and "eval()" are
special in the context of name resolution. A class definition is an
executable statement that may use and define names. These references
follow the normal rules for name resolution with an exception that
unbound local variables are looked up in the global namespace. The
namespace of the class definition becomes the attribute dictionary of
the class. The scope of names defined in a class block is limited to
the class block; it does not extend to the code blocks of methods.
This includes comprehensions and generator expressions, but it does
not include annotation scopes, which have access to their enclosing
class scopes. This means that the following will fail:

   class A:
       a = 42
       b = list(a + i for i in range(10))

However, the following will succeed:

   class A:
       type Alias = Nested
       class Nested: pass

   print(A.Alias.__value__)  # <type 'A.Nested'>


4.2.3. Annotation scopes
------------------------

Type parameter lists and "type" statements introduce *annotation
scopes*, which behave mostly like function scopes, but with some
exceptions discussed below. *Annotations* currently do not use
annotation scopes, but they are expected to use annotation scopes in
Python 3.13 when **PEP 649** is implemented.

Annotation scopes are used in the following contexts:

* Type parameter lists for generic type aliases.

* Type parameter lists for generic functions. A generic function's
  annotations are executed within the annotation scope, but its
  defaults and decorators are not.

* Type parameter lists for generic classes. A generic class's base
  classes and keyword arguments are executed within the annotation
  scope, but its decorators are not.

* The bounds and constraints for type variables (lazily evaluated).

* The value of type aliases (lazily evaluated).

Annotation scopes differ from function scopes in the following ways:

* Annotation scopes have access to their enclosing class namespace. If
  an annotation scope is immediately within a class scope, or within
  another annotation scope that is immediately within a class scope,
  the code in the annotation scope can use names defined in the class
  scope as if it were executed directly within the class body. This
  contrasts with regular functions defined within classes, which
  cannot access names defined in the class scope.

* Expressions in annotation scopes cannot contain "yield", "yield
  from", "await", or ":=" expressions. (These expressions are allowed
  in other scopes contained within the annotation scope.)

* Names defined in annotation scopes cannot be rebound with "nonlocal"
  statements in inner scopes. This includes only type parameters, as
  no other syntactic elements that can appear within annotation scopes
  can introduce new names.

* While annotation scopes have an internal name, that name is not
  reflected in the *qualified name* of objects defined within the
  scope. Instead, the "__qualname__" of such objects is as if the
  object were defined in the enclosing scope.

Ajouté dans la version 3.12: Annotation scopes were introduced in
Python 3.12 as part of **PEP 695**.


4.2.4. Lazy evaluation
----------------------

The values of type aliases created through the "type" statement are
*lazily evaluated*. The same applies to the bounds and constraints of
type variables created through the type parameter syntax. This means
that they are not evaluated when the type alias or type variable is
created. Instead, they are only evaluated when doing so is necessary
to resolve an attribute access.

Exemple :

   >>> type Alias = 1/0
   >>> Alias.__value__
   Traceback (most recent call last):
     ...
   ZeroDivisionError: division by zero
   >>> def func[T: 1/0](): pass
   >>> T = func.__type_params__[0]
   >>> T.__bound__
   Traceback (most recent call last):
     ...
   ZeroDivisionError: division by zero

Here the exception is raised only when the "__value__" attribute of
the type alias or the "__bound__" attribute of the type variable is
accessed.

This behavior is primarily useful for references to types that have
not yet been defined when the type alias or type variable is created.
For example, lazy evaluation enables creation of mutually recursive
type aliases:

   from typing import Literal

   type SimpleExpr = int | Parenthesized
   type Parenthesized = tuple[Literal["("], Expr, Literal[")"]]
   type Expr = SimpleExpr | tuple[SimpleExpr, Literal["+", "-"], Expr]

Lazily evaluated values are evaluated in annotation scope, which means
that names that appear inside the lazily evaluated value are looked up
as if they were used in the immediately enclosing scope.

Ajouté dans la version 3.12.


4.2.5. Noms natifs et restrictions d'exécution
----------------------------------------------

L'utilisateur ne doit pas toucher à "__builtins__" ; c'est et cela
doit rester réservé aux besoins de l'implémentation. Les utilisateurs
qui souhaitent surcharger des valeurs dans l'espace de nommage natif
doivent "importer" le module "builtins" et modifier ses attributs
judicieusement.

L'espace de nommage natif associé à l'exécution d'un bloc de code est
effectivement trouvé en cherchant le nom "__builtins__" dans l'espace
de nommage globaux ; ce doit être un dictionnaire ou un module (dans
ce dernier cas, le dictionnaire du module est utilisé). Par défaut,
lorsque l'on se trouve dans le module "__main__", "__builtins__" est
le module natif "builtins" ; lorsque l'on se trouve dans tout autre
module, "__builtins__" est un pseudonyme du dictionnaire du module
"builtins" lui-même.


4.2.6. Interaction avec les fonctionnalités dynamiques
------------------------------------------------------

La résolution des noms de variables libres intervient à l'exécution,
pas à la compilation. Cela signifie que le code suivant affiche 42 :

   i = 10
   def f():
       print(i)
   i = 42
   f()

Les fonctions "eval()" et "exec()" n'ont pas accès à l'environnement
complet pour résoudre les noms. Les noms doivent être résolus dans les
espaces de nommage locaux et globaux de l'appelant. Les variables
libres ne sont pas résolues dans l'espace de nommage englobant le plus
proche mais dans l'espace de nommage globaux [1]. Les fonctions
"eval()" et "exec()" possèdent des arguments optionnels pour
surcharger les espaces de nommage globaux et locaux. Si seulement un
espace de nommage est spécifié, il est utilisé pour les deux.


4.3. Exceptions
===============

Les exceptions sont un moyen de sortir du flot normal d'exécution d'un
bloc de code de manière à gérer des erreurs ou des conditions
exceptionnelles. Une exception est *levée* au moment où l'erreur est
détectée ; elle doit être *gérée* par le bloc de code qui l'entoure ou
par tout bloc de code qui a, directement ou indirectement, invoqué le
bloc de code où l'erreur s'est produite.

L'interpréteur Python lève une exception quand il détecte une erreur à
l'exécution (telle qu'une division par zéro). Un programme Python peut
aussi lever explicitement une exception avec l'instruction "raise".
Les gestionnaires d'exception sont spécifiés avec l'instruction "try"
… "except". La clause "finally" d'une telle instruction peut être
utilisée pour spécifier un code de nettoyage qui ne gère pas
l'exception mais qui est exécuté quoi qu'il arrive (exception ou pas).

Python utilise le modèle par *terminaison* de gestion des erreurs : un
gestionnaire d'exception peut trouver ce qui est arrivé et continuer
l'exécution à un niveau plus élevé, mais il ne peut pas réparer
l'origine de l'erreur et ré-essayer l'opération qui a échoué (sauf à
entrer à nouveau dans le code en question par le haut).

Quand une exception n'est pas du tout gérée, l'interpréteur termine
l'exécution du programme ou retourne à la boucle interactive. Dans ces
cas, il affiche une trace de la pile d'appels, sauf si l'exception est
"SystemExit".

Les exceptions sont identifiées par des instances de classe. La clause
"except" sélectionnée dépend de la classe de l'instance : elle doit
faire référence à la classe de l'instance ou à une de ses *classes
ancêtres non virtuelles*. L'instance peut être transmise au
gestionnaire et peut apporter des informations complémentaires sur les
conditions de l'exception.

Note:

  Les messages d'exception ne font pas partie de l'API Python. Leur
  contenu peut changer d'une version de Python à une autre sans
  avertissement et le code ne doit pas reposer sur ceux-ci s'il doit
  fonctionner sur plusieurs versions de l'interpréteur.

Reportez-vous aussi aux descriptions de l'instruction "try" dans la
section L'instruction try et de l'instruction "raise" dans la section
L'instruction raise.

-[ Notes ]-

[1] En effet, le code qui est exécuté par ces opérations n'est pas
    connu au moment où le module est compilé.
