8. Instructions composées
*************************

Les instructions composées contiennent d'autres (groupes d’)
instructions ; elles affectent ou contrôlent l'exécution de ces autres
instructions d'une manière ou d'une autre. En général, une instruction
composée couvre plusieurs lignes bien que, dans sa forme la plus
simple, une instruction composée peut tenir sur une seule ligne.

Les instructions "if", "while" et "for" implémentent les constructions
classiques de contrôle de flux. "try" spécifie des gestionnaires
d'exception et du code de nettoyage pour un groupe d'instructions,
tandis que l'instruction "with" permet l'exécution de code
d'initialisation et de finalisation autour d'un bloc de code. Les
définitions de fonctions et de classes sont également, au sens
syntaxique, des instructions composées.

Une instruction composée comporte une ou plusieurs « clauses ». Une
clause se compose d'un en-tête et d'une « suite ». Les en-têtes des
clauses d'une instruction composée particulière sont toutes placées au
même niveau d'indentation. Chaque en-tête de clause commence par un
mot-clé spécifique et se termine par le caractère deux-points (*:*) ;
une suite est un groupe d'instructions contrôlées par une clause ; une
suite se compose, après les deux points de l'en-tête, soit d'une ou
plusieurs instructions simples séparées par des points-virgules si
elles sont sur la même ligne que l'en-tête, soit d'une ou plusieurs
instructions en retrait sur les lignes suivantes. Seule cette dernière
forme d'une suite peut contenir des instructions composées ; ce qui
suit n'est pas licite, principalement parce qu'il ne serait pas clair
de savoir à quelle clause "if" se rapporterait une clause "else"
placée en fin de ligne :

   if test1: if test2: print(x)

Notez également que le point-virgule se lie plus étroitement que le
deux-points dans ce contexte, de sorte que dans l'exemple suivant,
soit tous les appels "print()" sont exécutés, soit aucun ne l'est :

   if x < y < z: print(x); print(y); print(z)

En résumé :

   compound_stmt ::= if_stmt
                     | while_stmt
                     | for_stmt
                     | try_stmt
                     | with_stmt
                     | funcdef
                     | classdef
                     | async_with_stmt
                     | async_for_stmt
                     | async_funcdef
   suite         ::= stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT
   statement     ::= stmt_list NEWLINE | compound_stmt
   stmt_list     ::= simple_stmt (";" simple_stmt)* [";"]

Notez que ces instructions se terminent toujours par un lexème
"NEWLINE" suivi éventuellement d'un "DEDENT". Notez également que les
clauses facultatives qui suivent commencent toujours par un mot-clé
qui ne peut pas commencer une instruction. Ainsi, il n'y a pas
d'ambiguïté (le problème du "else" dont on ne sait pas à quel "if" il
est relié est résolu en Python en exigeant que des instructions "if"
imbriquées soient indentées les unes par rapport aux autres).

L'agencement des règles de grammaire dans les sections qui suivent
place chaque clause sur une ligne séparée pour plus de clarté.


8.1. L'instruction "if"
=======================

L'instruction "if" est utilisée pour exécuter des instructions en
fonction d'une condition :

   if_stmt ::= "if" expression ":" suite
               ("elif" expression ":" suite)*
               ["else" ":" suite]

Elle sélectionne exactement une des suites en évaluant les expressions
une par une jusqu'à ce qu'une soit vraie (voir la section Opérations
booléennes pour la définition de vrai et faux) ; ensuite cette suite
est exécutée (et aucune autre partie de l'instruction "if" n'est
exécutée ou évaluée). Si toutes les expressions sont fausses, la suite
de la clause "else", si elle existe, est exécutée.


8.2. L'instruction "while"
==========================

L'instruction "while" est utilisée pour exécuter des instructions de
manière répétée tant qu'une expression est vraie :

   while_stmt ::= "while" expression ":" suite
                  ["else" ":" suite]

Python évalue l'expression de manière répétée et, tant qu'elle est
vraie, exécute la première suite ; si l'expression est fausse (ce qui
peut arriver même lors du premier test), la suite de la clause "else",
si elle existe, est exécutée et la boucle se termine.

Une instruction "break" exécutée dans la première suite termine la
boucle sans exécuter la suite de la clause "else". Une instruction
"continue" exécutée dans la première suite saute le reste de la suite
et retourne au test de l'expression.


8.3. L'instruction "for"
========================

L'instruction "for" est utilisée pour itérer sur les éléments d'une
séquence (par exemple une chaîne, un tuple ou une liste) ou un autre
objet itérable :

   for_stmt ::= "for" target_list "in" expression_list ":" suite
                ["else" ":" suite]

La liste des expressions (*expression_list* dans la grammaire ci-
dessus) est évaluée une seule fois ; elle doit produire un objet
itérable. Un itérateur est créé pour le résultat de cette liste
d'expression. La suite est ensuite exécutée une fois pour chaque
élément fourni par l'itérateur, dans l'ordre renvoyé par l'itérateur.
Chaque élément est assigné, à tour de rôle, à la liste cible
(*target_list* dans la grammaire ci-dessus) en utilisant les règles
des assignations (voir Les assignations), et ensuite la suite est
exécutée. Lorsque les éléments sont épuisés (ce qui est immédiat
lorsque la séquence est vide ou si un itérateur lève une exception
"StopIteration"), la suite de la clause "else", si elle existe, est
exécutée et la boucle se termine.

Une instruction "break" exécutée dans la première suite termine la
boucle sans exécuter la suite de la clause "else". Une instruction
"continue" exécutée dans la première suite saute le reste de la suite
et continue avec l'élément suivant, ou avec la clause "else" s'il n'y
a pas d'élément suivant.

La boucle "for" effectue des affectations aux variables de la liste
cible, ce qui écrase toutes les affectations antérieures de ces
variables, y compris celles effectuées dans la suite de la boucle
"for" :

   for i in range(10):
       print(i)
       i = 5             # this will not affect the for-loop
                         # because i will be overwritten with the next
                         # index in the range

Les noms dans la liste cible ne sont pas supprimés lorsque la boucle
est terminée mais, si la séquence est vide, ils n'auront pas du tout
été assignés par la boucle. Petite astuce : la fonction native
"range()" renvoie un itérateur sur des entiers approprié pour émuler
la boucle classique en Pascal sur des entiers "for i := a to b do" ;
par exemple, "list(range(3))" renvoie la liste "[0, 1, 2]".

Note:

  Il y a une subtilité lorsque la séquence est modifiée par la boucle
  (cela ne peut se produire que pour les séquences mutables,
  c'est-à-dire les listes). Un compteur interne est utilisé pour
  savoir quel est l'élément suivant, et ce compteur est incrémenté à
  chaque itération. Lorsqu'il a atteint la longueur de la séquence, la
  boucle se termine. Cela signifie que si la suite supprime l'élément
  courant (ou un élément précédent) de la séquence, l'élément suivant
  est sauté (puisqu'il reçoit l'indice de l'élément courant qui a déjà
  été traité). De même, si la suite insère un élément avant l'élément
  courant, l'élément courant est traité une deuxième fois à la
  prochaine itération. Ceci peut conduire à de méchants bugs, que vous
  pouvez éviter en effectuant une copie temporaire d'une tranche ou de
  la séquence complète, par exemple

     for x in a[:]:
         if x < 0: a.remove(x)


8.4. L'instruction "try"
========================

L'instruction "try" spécifie les gestionnaires d'exception ou le code
de nettoyage pour un groupe d'instructions :

   try_stmt  ::= try1_stmt | try2_stmt
   try1_stmt ::= "try" ":" suite
                 ("except" [expression ["as" identifier]] ":" suite)+
                 ["else" ":" suite]
                 ["finally" ":" suite]
   try2_stmt ::= "try" ":" suite
                 "finally" ":" suite

La ou les clauses "except" spécifient un ou plusieurs gestionnaires
d'exceptions. Si aucune exception ne se produit dans la clause "try",
aucun gestionnaire d'exception n'est exécuté. Lorsqu'une exception se
produit dans la suite de "try", Python recherche un gestionnaire
d'exception. Cette recherche inspecte les clauses "except", l'une
après l'autre, jusqu'à trouver une correspondance. Une clause "except"
vide (c'est-à-dire sans expression), si elle est présente, doit être
la dernière ; elle correspond à toute exception. Pour une clause
"except" avec une expression, cette expression est évaluée et la
clause correspond si l'objet résultant est « compatible » avec
l'exception. Un objet est réputé compatible avec une exception s'il
est la classe ou une classe de base de l'objet exception ou si c'est
un tuple contenant un élément qui est compatible avec l'exception.

Si aucune clause "except" ne correspond à l'exception, la recherche
d'un gestionnaire d'exception se poursuit dans le code englobant et
dans la pile d'appels. [1]

Si l'évaluation d'une expression dans l'en-tête d'une clause "except"
lève une exception, la recherche initiale d'un gestionnaire est
annulée et une recherche commence pour la nouvelle exception dans le
code englobant et dans la pile d'appels (c'est traité comme si
l'instruction "try" avait levé l'exception).

Lorsqu'une clause d'exception correspond, l'exception est assignée à
la cible spécifiée après le mot-clé "as" dans cette clause "except",
si cette cible existe, et la suite de clause "except" est exécutée.
Toutes les clauses "except" doivent avoir un bloc exécutable. Lorsque
la fin de ce bloc est atteinte, l'exécution continue normalement après
l'ensemble de l'instruction "try" (cela signifie que si deux
gestionnaires imbriqués existent pour la même exception, et que
l'exception se produit dans la clause "try" du gestionnaire interne,
le gestionnaire externe ne gère pas l'exception).

Lorsqu'une exception a été assignée en utilisant "as cible", elle est
effacée à la fin de la clause "except". C'est comme si

   except E as N:
       foo

avait été traduit en

   except E as N:
       try:
           foo
       finally:
           del N

Cela veut dire que l'exception doit être assignée à un nom différent
pour pouvoir s'y référer après la clause "except". Les exceptions sont
effacées parce qu'avec la trace de la pile d'appels qui leur est
attachée, elles créent un cycle dans les pointeurs de références (avec
le cadre de la pile), ce qui conduit à conserver tous les noms locaux
de ce cadre en mémoire jusqu'au passage du ramasse-miettes.

Avant l'exécution de la suite d'une clause "except", les détails de
l'exception sont stockés dans le module "sys" et sont accessibles
*via* "sys.exc_info()". "sys.exc_info()" renvoie un triplet composé de
la classe de l'exception, de l'instance d'exception et d'un objet
trace (voir la section Hiérarchie des types standards) identifiant le
point du programme où l'exception est survenue. Les valeurs de
"sys.exc_info()" sont remises à leurs anciennes valeurs (celles
d'avant l'appel) au retour d'une fonction qui a géré une exception.

La clause optionnelle "else" n'est exécutée que si l'exécution atteint
la fin de la clause "try", aucune exception n'a été levée, et aucun
"return", "continue", ou "break" ont étés exécutés. Les exceptions
dans la clause "else" ne sont pas gérées par les clauses "except"
précédentes.

Si "finally" est présente, elle spécifie un gestionnaire de
"nettoyage". La clause "try" est exécutée, y compris les clauses
"except" et "else". Si une exception se produit dans l'une des clauses
et n'est pas traitée, l'exception est temporairement sauvegardée. La
clause "finally" est exécutée. S'il y a une exception sauvegardée,
elle est levée à nouveau à la fin de la clause "finally". Si la clause
"finally" lève une autre exception, l'exception sauvegardée est
définie comme le contexte de la nouvelle exception. Si la clause
"finally" exécute une instruction "return" ou "break", l'exception
sauvegardée est jetée :

   >>> def f():
   ...     try:
   ...         1/0
   ...     finally:
   ...         return 42
   ...
   >>> f()
   42

L'information relative à l'exception n'est pas disponible pour le
programme pendant l'exécution de la clause "finally".

Lorsqu'une instruction "return", "break" ou "continue" est exécutée
dans la suite d'une instruction "try" d'une construction
"try"..."finally", la clause "finally" est aussi exécutée à la sortie.
Une instruction "continue" est illégale dans une clause "finally" (la
raison est que l'implémentation actuelle pose problème --- il est
possible que cette restriction soit levée dans le futur).

La valeur de retour d'une fonction est déterminée par la dernière
instruction "return" exécutée. Puisque la clause "finally" s'exécute
toujours, une instruction "return" exécutée dans le "finally" sera
toujours la dernière clause exécutée :

   >>> def foo():
   ...     try:
   ...         return 'try'
   ...     finally:
   ...         return 'finally'
   ...
   >>> foo()
   'finally'

Vous trouvez des informations supplémentaires relatives aux exceptions
dans la section Exceptions et, dans la section L'instruction raise,
des informations relatives à l'utilisation de l'instruction "raise"
pour produire des exceptions.


8.5. L'instruction "with"
=========================

L'instruction "with" est utilisée pour encapsuler l'exécution d'un
bloc avec des méthodes définies par un gestionnaire de contexte (voir
la section Gestionnaire de contexte With). Cela permet d'utiliser de
manière simple le patron de conception classique
"try"…"except"…"finally".

   with_stmt ::= "with" with_item ("," with_item)* ":" suite
   with_item ::= expression ["as" target]

L'exécution de l'instruction "with" avec un seul « élément » (*item*
dans la grammaire) se déroule comme suit :

1. L'expression de contexte (l'expression donnée dans le "with_item")
   est évaluée pour obtenir un gestionnaire de contexte.

2. La méthode "__exit__()" du gestionnaire de contexte est chargée
   pour une utilisation ultérieure.

3. La méthode "__enter__()" du gestionnaire de contexte est invoquée.

4. Si une cible (*target* dans la grammaire ci-dessus) a été incluse
   dans l'instruction "with", la valeur de retour de "__enter__()" lui
   est assignée.

   Note:

     L'instruction "with" garantit que si la méthode "__enter__()" se
     termine sans erreur, alors la méthode "__exit__()" est toujours
     appelée. Ainsi, si une erreur se produit pendant l'assignation à
     la liste cible, elle est traitée de la même façon qu'une erreur
     se produisant dans la suite. Voir l'étape 6 ci-dessous.

5. La suite est exécutée.

6. La méthode "__exit__()" du gestionnaire de contexte est invoquée.
   Si une exception a causé la sortie de la suite, son type, sa valeur
   et sa pile d'appels sont passés en arguments à "__exit__()". Sinon,
   trois arguments "None" sont fournis.

   Si l'on est sorti de la suite en raison d'une exception et que la
   valeur de retour de la méthode "__exit__()" était fausse,
   l'exception est levée à nouveau. Si la valeur de retour était
   vraie, l'exception est supprimée et l'exécution continue avec
   l'instruction qui suit l'instruction "with".

   Si l'on est sorti de la suite pour une raison autre qu'une
   exception, la valeur de retour de "__exit__()" est ignorée et
   l'exécution se poursuit à l'endroit normal pour le type de sortie
   prise.

Avec plus d'un élément, les gestionnaires de contexte sont traités
comme si plusieurs instructions "with" étaient imbriquées :

   with A() as a, B() as b:
       suite

est équivalente à

   with A() as a:
       with B() as b:
           suite

Modifié dans la version 3.1: Prise en charge de multiples expressions
de contexte.

Voir aussi:

  **PEP 343** — L'instruction « *with* »
     La spécification, les motivations et des exemples de
     l'instruction "with" en Python.


8.6. Définition de fonctions
============================

Une définition de fonction définit un objet fonction allogène (voir la
section Hiérarchie des types standards) :

   funcdef                 ::= [decorators] "def" funcname "(" [parameter_list] ")"
               ["->" expression] ":" suite
   decorators              ::= decorator+
   decorator               ::= "@" dotted_name ["(" [argument_list [","]] ")"] NEWLINE
   dotted_name             ::= identifier ("." identifier)*
   parameter_list          ::= defparameter ("," defparameter)* ["," [parameter_list_starargs]]
                      | parameter_list_starargs
   parameter_list_starargs ::= "*" [parameter] ("," defparameter)* ["," ["**" parameter [","]]]
                               | "**" parameter [","]
   parameter               ::= identifier [":" expression]
   defparameter            ::= parameter ["=" expression]
   funcname                ::= identifier

Une définition de fonction est une instruction qui est exécutée. Son
exécution lie le nom de la fonction, dans l'espace de nommage local
courant, à un objet fonction (un objet qui encapsule le code
exécutable de la fonction). Cet objet fonction contient une référence
à l'espace des noms globaux courant comme espace des noms globaux à
utiliser lorsque la fonction est appelée.

La définition de la fonction n'exécute pas le corps de la fonction ;
elle n'est exécutée que lorsque la fonction est appelée. [2]

Une définition de fonction peut être encapsulée dans une ou plusieurs
expressions *decorator* ; les décorateurs sont évalués lorsque la
fonction est définie, dans la portée qui contient la définition de
fonction ; le résultat doit être un appelable, qui est invoqué avec
l'objet fonction comme seul argument ; la valeur renvoyée est liée au
nom de la fonction en lieu et place de l'objet fonction. Lorsqu'il y a
plusieurs décorateurs, ils sont appliqués par imbrication ; par
exemple, le code suivant

   @f1(arg)
   @f2
   def func(): pass

est à peu près équivalent à

   def func(): pass
   func = f1(arg)(f2(func))

sauf que la fonction originale n'est pas temporairement liée au nom
"func".

Lorsqu'un ou plusieurs *paramètres* sont de la forme *parameter* "="
*expression*, on dit que la fonction a des « valeurs de paramètres par
défaut ». Pour un paramètre avec une valeur par défaut, l’*argument*
correspondant peut être omis lors de l'appel, la valeur par défaut du
paramètre est alors utilisée. Si un paramètre a une valeur par défaut,
tous les paramètres suivants jusqu'à ""*"" doivent aussi avoir une
valeur par défaut — ceci est une restriction syntaxique qui n'est pas
exprimée dans la grammaire.

**Les valeurs par défaut des paramètres sont évaluées de la gauche
vers la droite quand la définition de la fonction est exécutée**. Cela
signifie que l'expression est évaluée une fois, lorsque la fonction
est définie, et que c'est la même valeur « pré-calculée » qui est
utilisée à chaque appel. C'est particulièrement important à comprendre
lorsqu'un paramètre par défaut est un objet mutable, tel qu'une liste
ou un dictionnaire : si la fonction modifie l'objet (par exemple en
ajoutant un élément à une liste), la valeur par défaut est modifiée.
En général, ce n'est pas l'effet voulu. Une façon d'éviter cet écueil
est d'utiliser "None" par défaut et de tester explicitement la valeur
dans le corps de la fonction. Par exemple :

   def whats_on_the_telly(penguin=None):
       if penguin is None:
           penguin = []
       penguin.append("property of the zoo")
       return penguin

La sémantique de l'appel de fonction est décrite plus en détail dans
la section Appels. Un appel de fonction assigne toujours des valeurs à
tous les paramètres mentionnés dans la liste des paramètres, soit à
partir d'arguments positionnels, d'arguments par mots-clés ou de
valeurs par défaut. S'il y a un paramètre de la forme ""*identifier"",
il est initialisé à un tuple recevant les paramètres positionnels en
surplus, la valeur par défaut étant le tuple vide. S'il y a un
paramètre de la forme ""**identifier"", il est initialisé à un nouveau
tableau associatif ordonné qui récupère tous les arguments par mot-clé
en surplus, la valeur par défaut étant un tableau associatif vide. Les
paramètres après ""*"" ou ""*identifier"" sont forcément des
paramètres par mot-clé et ne peuvent être passés qu'en utilisant des
arguments par mot-clé.

Les paramètres peuvent avoir une *annotation* sous la forme "":
expression"" après le nom du paramètre. Tout paramètre peut avoir une
annotation, même ceux de la forme "*identifier" ou "**identifier". Les
fonctions peuvent avoir une annotation pour la valeur de retour, sous
la forme ""-> expression"" après la liste des paramètres. Ces
annotations peuvent prendre la forme de toute expression Python
valide. Leur présence ne change pas la sémantique de la fonction. Les
valeurs des annotations sont accessibles comme valeurs d'un
dictionnaire dont les clés sont les noms des paramètres et défini
comme attribut "__annotations__" de l'objet fonction. Si "annotations"
est importé de "__future__", les annotations sont conservées sous la
forme de chaînes de caractères, permettant leur évaluation différée.
Autrement, elles sont interprétées en même temps que la déclaration
des fonctions. Dans le premier cas, les annotations peuvent être
interprétées dans un ordre différent de l'ordre dans lequel elles
apparaissent dans le fichier.

Il est aussi possible de créer des fonctions anonymes (fonctions non
liées à un nom), pour une utilisation immédiate dans des expressions.
Utilisez alors des expressions lambda, décrites dans la section
Expressions lambda. Notez qu'une expression lambda est simplement un
raccourci pour définir une fonction simple ; une fonction définie par
une instruction ""def"" peut être passée (en argument) ou assignée à
un autre nom, tout comme une fonction définie par une expression
lambda. La forme ""def"" est en fait plus puissante puisqu'elle permet
l'exécution de plusieurs instructions et les annotations.

**Note pour les programmeurs :** les fonctions sont des objets de
première classe. Une instruction ""def"" exécutée à l'intérieur d'une
définition de fonction définit une fonction locale qui peut être
renvoyée ou passée en tant qu'argument. Les variables libres utilisées
dans la fonction imbriquée ont accès aux variables locales de la
fonction contenant le ""def"".  Voir la section Noms et liaisons pour
plus de détails.

Voir aussi:

  **PEP 3107** — Annotations de fonctions
     La spécification originale pour les annotations de fonctions.

  **PEP 484** — Indications de types
     Définition de la signification standard pour les annotations :
     indications de types.

  **PEP 526** — Syntaxe pour les annotations de variables
     Capacité d'indiquer des types pour les déclarations de variables,
     y compris les variables de classes et les variables d'instances

  **PEP 563** — Évaluation différée des annotations
     Gestion des références postérieures à l'intérieur des annotations
     en préservant les annotations sous forme de chaînes à l'exécution
     au lieu d'une évaluation directe.


8.7. Définition de classes
==========================

Une définition de classe définit un objet classe (voir la section
Hiérarchie des types standards) :

   classdef    ::= [decorators] "class" classname [inheritance] ":" suite
   inheritance ::= "(" [argument_list] ")"
   classname   ::= identifier

Une définition de classe est une instruction qui est exécutée. La
liste d'héritage (*inheritance* entre crochets dans la grammaire ci-
dessus) donne habituellement une liste de classes de base (voir Méta-
classes pour des utilisations plus avancées). Donc chaque élément de
la liste doit pouvoir être évalué comme un objet classe qui autorise
les sous-classes. Les classes sans liste d'héritage héritent, par
défaut, de la classe de base "object" ; d'où

   class Foo:
       pass

est équivalente à

   class Foo(object):
       pass

La suite de la classe est ensuite exécutée dans un nouveau cadre
d'exécution (voir Noms et liaisons), en utilisant un espace de nommage
local nouvellement créé et l'espace de nommage global d'origine
(habituellement, la suite contient principalement des définitions de
fonctions). Lorsque la suite de la classe termine son exécution, son
cadre d'exécution est abandonné mais son espace des noms locaux est
sauvegardé [3]. Un objet classe est alors créé en utilisant la liste
d'héritage pour les classes de base et l'espace de nommage sauvegardé
comme dictionnaire des attributs. Le nom de classe est lié à l'objet
classe dans l'espace de nommage local original.

L'ordre dans lequel les attributs sont définis dans le corps de la
classe est préservé dans le "__dict__" de la nouvelle classe. Notez
que ceci n'est fiable que juste après la création de la classe et
seulement pour les classes qui ont été définies en utilisant la
syntaxe de définition.

La création de classes peut être fortement personnalisée en utilisant
les métaclasses.

Les classes peuvent aussi être décorées : comme pour les décorateurs
de fonctions,

   @f1(arg)
   @f2
   class Foo: pass

est à peu près équivalent à

   class Foo: pass
   Foo = f1(arg)(f2(Foo))

Les règles d'évaluation pour les expressions de décorateurs sont les
mêmes que pour les décorateurs de fonctions. Le résultat est alors lié
au nom de la classe.

**Note pour les programmeurs :** les variables définies dans la
définition de classe sont des attributs de classe ; elles sont
partagées par les instances. Les attributs d'instance peuvent être
définis dans une méthode en utilisant "self.name = value". Les
attributs de classe et d'instance sont accessibles par la notation
""self.name"", et un attribut d'instance masque un attribut de classe
de même nom lorsqu'on y accède de cette façon. Les attributs de classe
peuvent être utilisés comme valeurs par défaut pour les attributs
d'instances, mais l'utilisation de valeurs mutables peut conduire à
des résultats inattendus. Les descripteurs peuvent être utilisés pour
créer des variables d'instances avec des détails d'implémentation
différents.

Voir aussi:

  **PEP 3115** — Métaclasses dans Python 3000
     La proposition qui a modifié la déclaration de métaclasses à la
     syntaxe actuelle, et la sémantique pour la façon dont les classes
     avec métaclasses sont construites.

  **PEP 3129** — Décorateurs de classes
     La proposition qui a ajouté des décorateurs de classe. Les
     décorateurs de fonction et de méthode ont été introduits dans
     **PEP 318**.


8.8. Coroutines
===============

Nouveau dans la version 3.5.


8.8.1. Définition de fonctions coroutines
-----------------------------------------

   async_funcdef ::= [decorators] "async" "def" funcname "(" [parameter_list] ")"
                     ["->" expression] ":" suite

L'exécution de coroutines Python peut être suspendue et reprise à
plusieurs endroits (voir *coroutine*). Dans le corps d'une coroutine,
tout identificateur "await" ou "async" devient un mots-clé réservé ;
les expressions "await", "async for" et "async with" ne peuvent être
utilisées que dans les corps de coroutines.

Les fonctions définies avec la syntaxe "async def" sont toujours des
fonctions coroutines, même si elles ne contiennent aucun mot-clé
"await" ou "async".

C'est une "SyntaxError" d'utiliser une expression "yield from" dans
une coroutine.

Un exemple de fonction coroutine :

   async def func(param1, param2):
       do_stuff()
       await some_coroutine()


8.8.2. L'instruction "async for"
--------------------------------

   async_for_stmt ::= "async" for_stmt

Un *itérable asynchrone* est capable d'appeler du code asynchrone dans
l'implémentation de sa méthode *iter* ; un *itérateur asynchrone* peut
appeler du code asynchrone dans sa méthode *next*.

L'instruction "async for" permet d'itérer facilement sur des
itérateurs asynchrones.

Le code suivant :

   async for TARGET in ITER:
       BLOCK
   else:
       BLOCK2

est sémantiquement équivalent à :

   iter = (ITER)
   iter = type(iter).__aiter__(iter)
   running = True
   while running:
       try:
           TARGET = await type(iter).__anext__(iter)
       except StopAsyncIteration:
           running = False
       else:
           BLOCK
   else:
       BLOCK2

Voir aussi "__aiter__()" et "__anext__()" pour plus de détails.

C'est une "SyntaxError" d'utiliser une instruction "async for" en
dehors d'une fonction coroutine.


8.8.3. L'instruction "async with"
---------------------------------

   async_with_stmt ::= "async" with_stmt

Un *gestionnaire de contexte asynchrone* est un *gestionnaire de
contexte* qui est capable de suspendre l'exécution dans ses méthodes
*enter* et *exit*.

Le code suivant :

   async with EXPR as VAR:
       BLOCK

est sémantiquement équivalent à :

   mgr = (EXPR)
   aexit = type(mgr).__aexit__
   aenter = type(mgr).__aenter__(mgr)

   VAR = await aenter
   try:
       BLOCK
   except:
       if not await aexit(mgr, *sys.exc_info()):
           raise
   else:
       await aexit(mgr, None, None, None)

Voir aussi "__aenter__()" et "__aexit__()" pour plus de détails.

C'est une "SyntaxError" d'utiliser l'instruction "async with" en
dehors d'une fonction coroutine.

Voir aussi:

  **PEP 492** — Coroutines avec les syntaxes *async* et *await*
     La proposition qui a fait que les coroutines soient un concept
     propre en Python, et a ajouté la syntaxe de prise en charge de
     celles-ci.

-[ Notes ]-

[1] L'exception est propagée à la pile d'appels à moins qu'il n'y ait
    une clause "finally" qui lève une autre exception, ce qui entraîne
    la perte de l'ancienne exception. Cette nouvelle exception
    entraîne la perte pure et simple de l'ancienne.

[2] Une chaîne littérale apparaissant comme première instruction dans
    le corps de la fonction est transformée en attribut "__doc__" de
    la fonction et donc en *docstring* de la fonction.

[3] Une chaîne littérale apparaissant comme première instruction dans
    le corps de la classe est transformée en élément "__doc__" de
    l'espace de nommage et donc en *docstring* de la classe.
