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" définit 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
                     | match_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" assignment_expression ":" suite
               ("elif" assignment_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" assignment_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 *n*-uplet ou une liste) ou un
autre objet itérable :

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

L'expression "starred_list" n'est évaluée qu'une seule fois ; elle
doit produire un objet *iterable*. Un *iterator* est créé pour cet
itérable. Le premier élément produit par l'itérateur est assigné à la
liste cible (*target_list* dans la grammaire ci-dessus) en utilisant
les règles des affectations (voir Les assignations), puis la « suite »
est exécutée. Lorsque les éléments de l'itérateur sont épuisés, 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 : le type natif "range()"
représente des suites arithmétiques immuables de nombres entiers ; par
exemple, itérer sur "range(3)" renvoie successivement les entiers 0, 1
et 2.

Modifié dans la version 3.11: les éléments étoilés sont maintenant
autorisés dans l'expression liste.


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

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

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

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.4.1. clause "except"
----------------------

The "except" clause(s) specify one or more exception handlers. When no
exception occurs in the "try" clause, no exception handler is
executed. When an exception occurs in the "try" suite, a search for an
exception handler is started. This search inspects the "except"
clauses in turn until one is found that matches the exception. An
expression-less "except" clause, if present, must be last; it matches
any exception.

For an "except" clause with an expression, the expression must
evaluate to an exception type or a tuple of exception types. The
raised exception matches an "except" clause whose expression evaluates
to the class or a *non-virtual base class* of the exception object, or
to a tuple that contains such a class.

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 "except" correspond, l'exception est affectée à la
cible précisé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é affecté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 qu'une suite de clauses "except" ne soit exécutée, l'exception
est stockée dans le module "sys", où elle est accessible depuis le
corps de la clause "except" en appelant "sys.exception()". Lorsque
vous quittez un gestionnaire d'exceptions, l'exception stockée dans le
module "sys" est réinitialisée à sa valeur précédente :

   >>> print(sys.exception())
   None
   >>> try:
   ...     raise TypeError
   ... except:
   ...     print(repr(sys.exception()))
   ...     try:
   ...          raise ValueError
   ...     except:
   ...         print(repr(sys.exception()))
   ...     print(repr(sys.exception()))
   ...
   TypeError()
   ValueError()
   TypeError()
   >>> print(sys.exception())
   None


8.4.2. clause "except*"
-----------------------

Les clauses "except*" sont utilisées pour gérer des "ExceptionGroup".
Le type de l'exception pour la correspondance est interprété de la
même manière que dans le cas d'un "except" mais, dans le cas d'un
groupe d'exceptions, il est possible d'avoir une correspondance
partielle quand le type correspond à une ou plusieurs exceptions dans
le groupe. Cela veut dire que plusieurs clauses "except*" peuvent être
exécutées, chacune gérant une partie du groupe d'exceptions. Chaque
clause ne s'exécute (au maximum) qu'une fois et gère un groupe
d'exception constitué des exceptions qui correspondent. Chaque
exception du groupe est gérée par une clause "except*" au plus, la
première à laquelle elle correspond.

   >>> try:
   ...     raise ExceptionGroup("eg",
   ...         [ValueError(1), TypeError(2), OSError(3), OSError(4)])
   ... except* TypeError as e:
   ...     print(f'caught {type(e)} with nested {e.exceptions}')
   ... except* OSError as e:
   ...     print(f'caught {type(e)} with nested {e.exceptions}')
   ...
   caught <class 'ExceptionGroup'> with nested (TypeError(2),)
   caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))
     + Exception Group Traceback (most recent call last):
     |   File "<stdin>", line 2, in <module>
     | ExceptionGroup: eg
     +-+---------------- 1 ----------------
       | ValueError: 1
       +------------------------------------

Any remaining exceptions that were not handled by any "except*" clause
are re-raised at the end, along with all exceptions that were raised
from within the "except*" clauses. If this list contains more than one
exception to reraise, they are combined into an exception group.

Si l'exception levée n'est pas un groupe d'exceptions et que son type
correspond à l'une des clauses "except*", elle est interceptée et
encapsulée par un groupe d'exceptions avec une chaîne de message vide.
:

   >>> try:
   ...     raise BlockingIOError
   ... except* BlockingIOError as e:
   ...     print(repr(e))
   ...
   ExceptionGroup('', (BlockingIOError()))

An "except*" clause must have a matching expression; it cannot be
"except*:". Furthermore, this expression cannot contain exception
group types, because that would have ambiguous semantics.

It is not possible to mix "except" and "except*" in the same "try".
"break", "continue" and "return" cannot appear in an "except*" clause.


8.4.3. clause "else"
--------------------

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.


8.4.4. clause "finally"
-----------------------

Si "finally" est présente, elle définit 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", "break" ou "continue",
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
».

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'

Modifié dans la version 3.8: Avant Python 3.8, une instruction
"continue" n'était pas licite dans une clause "finally" en raison d'un
problème dans l'implémentation.


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_stmt_contents ","? ")" | with_stmt_contents ) ":" suite
   with_stmt_contents ::= with_item ("," with_item)*
   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. The context manager's "__enter__()" is loaded for later use.

3. The context manager's "__exit__()" is loaded for later use.

4. The context manager's "__enter__()" method is invoked.

5. If a target was included in the "with" statement, the return value
   from "__enter__()" is assigned to it.

   Note:

     The "with" statement guarantees that if the "__enter__()" method
     returns without an error, then "__exit__()" will always be
     called. Thus, if an error occurs during the assignment to the
     target list, it will be treated the same as an error occurring
     within the suite would be. See step 7 below.

6. La suite est exécutée.

7. The context manager's "__exit__()" method is invoked.  If an
   exception caused the suite to be exited, its type, value, and
   traceback are passed as arguments to "__exit__()". Otherwise, three
   "None" arguments are supplied.

   If the suite was exited due to an exception, and the return value
   from the "__exit__()" method was false, the exception is reraised.
   If the return value was true, the exception is suppressed, and
   execution continues with the statement following the "with"
   statement.

   If the suite was exited for any reason other than an exception, the
   return value from "__exit__()" is ignored, and execution proceeds
   at the normal location for the kind of exit that was taken.

Le code suivant :

   with EXPRESSION as TARGET:
       SUITE

est sémantiquement équivalent à :

   manager = (EXPRESSION)
   enter = type(manager).__enter__
   exit = type(manager).__exit__
   value = enter(manager)
   hit_except = False

   try:
       TARGET = value
       SUITE
   except:
       hit_except = True
       if not exit(manager, *sys.exc_info()):
           raise
   finally:
       if not hit_except:
           exit(manager, None, None, None)

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 sémantiquement équivalent à :

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

Vous pouvez aussi écrire des gestionnaires de contexte sur plusieurs
lignes pour plus d'un élément si ceux-ci sont placés entre
parenthèses. Par exemple :

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

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

Modifié dans la version 3.10: prise en charge des parenthèses pour
pouvoir écrire l'instruction sur plusieurs lignes.

Voir aussi:

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


8.6. L'instruction "match"
==========================

Ajouté dans la version 3.10.

L'instruction *match* est utilisée pour le filtrage par motif. Sa
syntaxe est :

   match_stmt   ::= 'match' subject_expr ":" NEWLINE INDENT case_block+ DEDENT
   subject_expr ::= star_named_expression "," star_named_expressions?
                    | named_expression
   case_block   ::= 'case' patterns [guard] ":" block

Note:

  cette section utilise les guillemets simples pour désigner les mots-
  clés ad-hoc.

Le filtrage par motif prend un motif en entrée ("pattern" après
"case") et un champ de recherche ("subject_expr" après "match"). Le
motif du filtre (qui peut contenir des sous-motifs de filtrage) est
confronté au contenu du champ de recherche. La sortie est composée de
:

* un indicateur de réussite ou d'échec pour le filtrage (on peut aussi
  dire que le motif a réussi ou échoué) ;

* la possibilité de lier les valeurs filtrées à un nom. Les pré-requis
  sont indiqués plus bas.

Les mots-clés "match" et "case" sont des mots-clés ad-hoc.

Voir aussi:

  * **PEP 634** — Spécifications pour le filtrage par motif

  * **PEP 636** — Tutoriel pour le filtrage par motif


8.6.1. Aperçu
-------------

Voici un aperçu du déroulement logique d'un filtrage par motif :

1. L'expression confrontée aux filtres, "subject_expr", est évaluée
   pour obtenir la valeur résultante. Si l'expression contient une
   virgule, un *n*-uplet est construit en utilisant les règles
   classiques.

2. Chaque filtre des blocs "case_block" est confronté à la valeur
   résultante du champ de recherche. Les règles particulières pour la
   réussite ou l'échec sont décrites plus bas. La confrontation du
   filtre peut aussi conduire à lier un ou plusieurs noms présents
   dans le motif. Les règles pour lier les noms des motifs dépendent
   du type de filtre et sont décrites plus bas. **Le nommage effectué
   lors d'un filtrage par motif qui a réussi persiste à l'extérieur du
   bloc et le nom peut être utilisé après l'instruction** "match".

   Note:

     en cas d'échec de la recherche, certains sous-filtres peuvent
     avoir réussi. Ne vous fiez pas aux nommages faits lors d'un
     filtrage qui a échoué. Inversement, ne vous fiez pas aux
     variables qui restent inchangées après un filtrage infructueux.
     Le comportement exact dépend de l'implémentation et peut varier.
     Il s'agit d'un choix intentionnel afin de permettre aux
     implémentations d'ajouter des optimisations.

3. Si la recherche réussit, la garde correspondante (si elle existe)
   est évaluée. Dans ce cas, on est sûr que les nommages ont bien eu
   lieu.

   * Si la garde s'évalue à vrai ou s'il n'y a pas de garde, le
     "block" à l'intérieur du "case_block" est exécuté.

   * Sinon, le "case_block" est testé comme décrit ci-dessus.

   * S'il n'y a plus de bloc "case_block", l'instruction est terminée.

Note:

  l'utilisateur ne doit jamais faire confiance à un filtre en cours
  d'évaluation. En fonction de l'implémentation, l'interpréteur peut
  mettre des valeurs en cache ou utiliser des optimisations qui
  évitent des réévaluations.

Voici un exemple d'instruction de filtrage par motif :

   >>> flag = False
   >>> match (100, 200):
   ...    case (100, 300):  # Mismatch: 200 != 300
   ...        print('Case 1')
   ...    case (100, 200) if flag:  # Successful match, but guard fails
   ...        print('Case 2')
   ...    case (100, y):  # Matches and binds y to 200
   ...        print(f'Case 3, y: {y}')
   ...    case _:  # Pattern not attempted
   ...        print('Case 4, I match anything!')
   ...
   Case 3, y: 200

Dans cet exemple, "if flag" est une garde. Plus de détails sont
fournis dans la prochaine section.


8.6.2. Gardes
-------------

   guard ::= "if" named_expression

Une garde ("guard" qui fait partie du "case") doit s'évaluer à vrai
pour que le code à l'intérieur du bloc "case" soit exécuté. Elle
s'écrit sous la forme du mot-clé "if" suivi d'une expression.

Le déroulement logique d'un bloc "case" qui comprend une garde est le
suivant :

1. Vérification que le filtrage dans le bloc "case" est fructueux. Si
   le filtrage échoue, la garde n'est pas évaluée et on passe au bloc
   "case" suivant.

2. Si le filtrage est fructueux, évaluation de la garde.

   * Si la garde s'évalue à *vrai*, le bloc est sélectionné.

   * Si la garde s'évalue à *faux*, le bloc n'est pas sélectionné.

   * Si une exception est levée lors de l'évaluation de la garde,
     cette exception est propagée.

Les gardes étant des expressions, il est possible qu'elles aient des
effets secondaires. L'ordre d'évaluation des gardes est du premier au
dernier bloc "case", un à la fois, en sautant les blocs "case" dont la
recherche de motif échouent. L'évaluation des gardes s'arrête dès
qu'un bloc "case" est sélectionné.


8.6.3. Bloc "case" attrape-tout
-------------------------------

Un bloc "case" attrape-tout est un bloc qui réussit toujours. Une
instruction "match" ne peut avoir qu'un seul bloc attrape-tout, et ce
doit être le dernier.

Un bloc "case" est considéré attrape-tout s'il n'y a pas de garde et
que le motif est attrape-tout. Un motif est attrape-tout si l'on peut
déterminer, simplement à partir de sa syntaxe, qu'il correspond
toujours. Seuls les motifs suivants sont attrape-tout :

* Les Filtres AS pour lesquels la partie gauche est attrape-tout

* Les Filtres OU contenant au moins un filtre attrape-tout

* Les Filtres de capture

* Les Filtres attrape-tout

* les filtres attrape-tout entre parenthèses


8.6.4. Filtres
--------------

Note:

  Cette section utilise des notations grammaticales qui ne font pas
  partie du standard EBNF :

  * la notation "SEP.REGLE+" désigne "REGLE (SEP REGLE)*"

  * la notation "!REGLE" désigne la négation logique de l'assertion
    "REGLE"

La syntaxe générale pour les filtres "patterns" est :

   patterns       ::= open_sequence_pattern | pattern
   pattern        ::= as_pattern | or_pattern
   closed_pattern ::= | literal_pattern
                      | capture_pattern
                      | wildcard_pattern
                      | value_pattern
                      | group_pattern
                      | sequence_pattern
                      | mapping_pattern
                      | class_pattern

Les explications ci-dessous décrivent « en termes simples » ce qu'un
modèle fait (merci à Raymond Hettinger pour son document qui a inspiré
la plupart des descriptions). Notez que ces descriptions sont purement
à fin d'illustration et peuvent ne **pas** être strictement conformes
à l'implémentation sous-jacente. De plus, nous ne couvrons pas toutes
les formes valides.


8.6.4.1. Filtres OU
~~~~~~~~~~~~~~~~~~~

Un filtre OU est composé de deux filtres ou plus séparés par des
barres verticales "|". La syntaxe est :

   or_pattern ::= "|".closed_pattern+

Seul le dernier sous-filtre peut être attrape-tout et chaque sous-
filtre doit être lié au même ensemble de noms pour éviter toute
ambigüité.

Un filtre OU confronte chacun des sous-filtres à tour de rôle à la
valeur du champ de recherche, jusqu'à ce que l'un d'eux réussisse. Le
filtre OU réussit si l'un des sous-filtres a réussi, sinon il échoue.

En termes plus simples, "M1 | M2 | ..." teste le filtre par motif
"M1", s'il échoue il teste le filtre par motif "M2", réussit
immédiatement si l'un d'eux réussit, échoue dans le cas contraire.


8.6.4.2. Filtres AS
~~~~~~~~~~~~~~~~~~~

Un filtre AS confronte un filtre OU sur la gauche du mot-clé "as" au
champ de recherche. La syntaxe est la suivante :

   as_pattern ::= or_pattern "as" capture_pattern

Si le filtre OU échoue, le filtre AS échoue. Sinon, le filtre AS lie
le champ de recherche au nom sur la droite du mot-clé "as" et réussit.
"capture_pattern" ne peut pas être un "_".

En termes simples, "M as NOM" filtre avec le motif "M" et, s'il
réussit, définit "NOM = <subject>".


8.6.4.3. Filtres littéraux
~~~~~~~~~~~~~~~~~~~~~~~~~~

Un filtre littéral effectue une correspondance avec la plupart des
littéraux en Python. La syntaxe est la suivante :

   literal_pattern ::= signed_number
                       | signed_number "+" NUMBER
                       | signed_number "-" NUMBER
                       | strings
                       | "None"
                       | "True"
                       | "False"
   signed_number   ::= ["-"] NUMBER

La règle "strings" et le lexème "NUMBER" sont définis dans la
grammaire de Python standard. Les chaînes avec triples guillemets sont
gérées. Les chaînes brutes et les chaînes d'octets sont gérées. Les
f-strings ne sont pas gérées.

Les formes "signed_number '+' NUMBER" et "signed_number '-' NUMBER"
permettent d'exprimer des nombres complexes ; vous devez indiquer un
nombre réel sur la gauche et un nombre imaginaire sur la droite. Par
exemple, "3 + 4j".

En termes simples, "LITERAL" réussit seulement si "<subject> ==
LITERAL". Pour les singletons "None", "True" et "False", l'opérateur
"is" est utilisé.


8.6.4.4. Filtres de capture
~~~~~~~~~~~~~~~~~~~~~~~~~~~

Un filtre de capture lie la valeur du champ de recherche à un nom. La
syntaxe est la suivante :

   capture_pattern ::= !'_' NAME

Un simple caractère souligné "_" n'est pas un filtre de capture (c'est
ce que "!'_'" veut dire). C'est le motif pour désigner un filtre
attrape-tout (lexème "wilcard_pattern", voir plus bas).

Dans un filtre donné, un nom ne peut être lié qu'une seule fois. Par
exemple, "case x, x: ..." est invalide mais "case [x] | x: ..." est
autorisé.

Les filtres de capture réussissent toujours. La portée du lien est
conforme aux règles définies pour l'opérateur d'affectation indiquées
dans la **PEP 572** ; le nom devient une variable locale dans la
fonction la plus intérieure à moins qu'il n'y ait une instruction
"global" ou "nonlocal" qui s'applique.

En termes simples, "NAME" réussit toujours et définit "NAME =
<subject>".


8.6.4.5. Filtres attrape-tout
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Un filtre attrape-tout réussit toujours (quel que soit le champ de
recherche) et ne lie aucun nom. La syntaxe est la suivante :

   wildcard_pattern ::= '_'

"_" est un mot-clé ad-hoc dans un filtre par motif, mais seulement
dans un filtre. Ailleurs, c'est un identifiant, comme d'habitude, même
à l'intérieur d'une expression champ de recherche de "match", d'une
garde ou d'un bloc "case".

En termes simples, "_" réussit toujours.


8.6.4.6. Filtres par valeurs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Un filtre par valeur représente une valeur nommée de Python. Sa
syntaxe est la suivante :

   value_pattern ::= attr
   attr          ::= name_or_attr "." NAME
   name_or_attr  ::= attr | NAME

Le nom qualifié dans le filtre est recherché en utilisant la méthode
de résolution des noms standard de Python. Le filtrage réussit si la
valeur trouvée vérifie l'égalité avec la valeur du champ de recherche
(en utilisant l'opérateur d'égalité "==").

En termes plus simples, "NOM1.NOM2" réussit seulement si "<subject> ==
NOM1.NOM2"

Note:

  si la même valeur apparaît plusieurs fois dans la même instruction
  "match", l'interpréteur peut mettre en cache la première valeur
  trouvée et la réutiliser plutôt que de refaire une recherche. Ce
  cache est strictement limité à l'exécution de l'instruction "match"
  donnée.


8.6.4.7. Filtres de groupes
~~~~~~~~~~~~~~~~~~~~~~~~~~~

Un filtre de groupe permet au programmeur de souligner l’intention de
regrouper des motifs en plaçant ceux-ci entre parenthèses. À part ça,
il n’introduit aucune syntaxe supplémentaire. Sa syntaxe est la
suivante :

   group_pattern ::= "(" pattern ")"

En termes plus simples, "(P)" équivaut à "P".


8.6.4.8. Filtres de séquences
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Un filtre de séquence contient des sous-filtres par motif dont chacun
doit correspondre à un élément d’une séquence. La syntaxe est
similaire au déballage d’une liste ou d’un *n*-uplet.

   sequence_pattern       ::= "[" [maybe_sequence_pattern] "]"
                              | "(" [open_sequence_pattern] ")"
   open_sequence_pattern  ::= maybe_star_pattern "," [maybe_sequence_pattern]
   maybe_sequence_pattern ::= ",".maybe_star_pattern+ ","?
   maybe_star_pattern     ::= star_pattern | pattern
   star_pattern           ::= "*" (capture_pattern | wildcard_pattern)

Vous pouvez utiliser indifféremment des parenthèses "(...)" ou des
crochets "[...]" pour encadrer les filtres à regrouper.

Note:

  un filtre seul entre parenthèses qui ne se termine pas par une
  virgule (par exemple "(3 | 4)") est un filtre de groupe. En
  revanche, un filtre seul entre crochets (par exemple "[3 | 4]")
  reste un filtre de séquence.

Il peut y avoir au plus un sous-filtre étoilé (lexème "star_pattern")
dans un filtre de séquence. Le filtre étoilé peut se trouver à
n’importe quelle position. S’il n’y en a pas, le filtre de séquence
est un filtre de séquence à longueur fixe, sinon c’est un filtre de
séquence à longueur variable.

Voici le déroulement logique d’un filtrage par motif de séquence sur
une valeur du champ de recherche :

1. Si la valeur du champ de recherche n’est pas une séquence [2], le
   filtre de séquence échoue.

2. Si la valeur du champ de recherche est une instance de "str",
   "bytes" ou "bytearray", le filtre de séquence échoue.

3. Les étapes suivantes dépendent de la longueur fixe ou non du filtre
   de séquence.

   Si le filtre de séquence est de longueur fixe :

   1. Si la longueur de la séquence champ de recherche n’est pas égale
      au nombre de sous-filtres, le filtre de séquence échoue.

   2. Les sous-filtres de la séquence sont confrontés aux éléments
      correspondants dans la séquence champ de recherche, de la gauche
      vers la droite. La recherche de correspondance s’arrête dès
      qu’un sous-filtre échoue. Si tous les sous-filtres réussissent
      la confrontation à l’élément du champ de recherche
      correspondant, le filtre de séquence réussit.

   Sinon, si le filtre de séquence est de longueur variable :

   1. Si la longueur de la séquence champ de recherche est plus petite
      que le nombre de sous-filtres sans étoile, le filtre de séquence
      échoue.

   2. Les sous-filtres sans étoile du début sont confrontés aux
      éléments correspondants comme pour un filtre de séquences de
      longueur fixe.

   3. Si les étapes précédentes ont réussi, le sous-filtre étoilé
      correspond à une liste formée des éléments restants du champ de
      recherche, en excluant les éléments restants qui correspondent à
      des sous-filtres sans étoile qui suivent le sous-filtre étoilé.

   4. Les sous-filtres sans étoile qui restent sont confrontés aux
      éléments restants du champ de recherche, comme pour un filtre de
      séquences de longueur fixe.

   Note:

     la longueur de la séquence champ de recherche est obtenue par
     "len()" (c.-à-d. avec le protocole "__len__()"). Cette longueur
     peut être mise en cache par l’interpréteur de la même manière que
     pour les filtres par valeur.

En termes plus simples, "[M1, M2, M3," … ", M<N>]" réussit seulement
si tout ce qui suit a lieu :

* vérification que "<subject>" est une séquence,

* "len(subject) == <N>",

* "M1" correspond à "<subject>[0]" (notez que cette correspondance
  peut lier des noms),

* "M2" correspond à "<subject>[1]" (notez que cette correspondance
  peut lier des noms),

* et ainsi de suite pour chaque filtre par motif / élément.


8.6.4.9. Filtres associatifs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Un filtre associatif contient un ou plusieurs motifs clé-valeur. La
syntaxe est similaire à la construction d’un dictionnaire :

   mapping_pattern     ::= "{" [items_pattern] "}"
   items_pattern       ::= ",".key_value_pattern+ ","?
   key_value_pattern   ::= (literal_pattern | value_pattern) ":" pattern
                           | double_star_pattern
   double_star_pattern ::= "**" capture_pattern

Un seul sous-filtre doublement étoilé peut être présent dans le filtre
associatif. Le filtre doublement étoilé doit être le dernier sous-
filtre du filtre associatif.

Il est interdit d’avoir des clés en double dans les filtres
associatifs. Une clé en double sous forme littérale lève une "Syntax
Error". Deux clés qui ont la même valeur lèvent une "ValueError" à
l’exécution.

Voici le déroulement d’un filtrage associatif sur la valeur du champ
de recherche :

1. Si la valeur du champ de recherche n'est pas un tableau associatif
   [3], le filtre associatif échoue.

2. Si chaque clé donnée dans le filtre associatif est présente dans le
   tableau associatif du champ de recherche, et que le filtre pour
   chaque clé correspond aux éléments du tableau associatif champ de
   recherche, le filtre associatif réussit.

3. Si des clés identiques sont détectées dans le filtre par motif, le
   filtre est déclaré invalide. Une "SyntaxError" est levée pour les
   valeurs littérales dupliquées ou une "ValueError" pour des clés
   s'évaluant à la même valeur.

Note:

  Key-value pairs are matched using the two-argument form of the
  mapping subject's "get()" method.  Matched key-value pairs must
  already be present in the mapping, and not created on-the-fly via
  "__missing__()" or "__getitem__()".

En termes simples, "{CLÉ1: M1, CLÉ2: M2, ... }" réussit seulement si
tout ce qui suit a lieu :

* vérification que "<subject>" est un tableau associatif,

* "CLÉ1 in <subject>",

* "M1" correspond à "<subject>[CLÉ1]",

* et ainsi de suite pour chaque paire CLÉ/Motif.


8.6.4.10. Filtres de classes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Un filtre de classe représente une classe et ses arguments
positionnels et par mots-clés (s'il y en a). La syntaxe est la
suivante :

   class_pattern       ::= name_or_attr "(" [pattern_arguments ","?] ")"
   pattern_arguments   ::= positional_patterns ["," keyword_patterns]
                           | keyword_patterns
   positional_patterns ::= ",".pattern+
   keyword_patterns    ::= ",".keyword_pattern+
   keyword_pattern     ::= NAME "=" pattern

Le même mot-clé ne doit pas être répété dans les filtres de classes.

Voici le déroulement d’un filtrage de classe sur la valeur du champ de
recherche :

1. Si "name_or_attr" n'est pas une instance de la classe native
   "type", lève une "TypeError".

2. Si la valeur du champ de recherche n'est pas une instance de
   "name_or_attr" (testé *via* "isinstance()"), le filtre de classe
   échoue.

3. S'il n'y a pas d'argument au filtre, le filtre réussit. Sinon, les
   étapes suivantes dépendent de la présence ou non de motifs pour les
   arguments positionnels ou par mot-clé.

   Pour un certain nombre de types natifs (indiqués ci-dessous), un
   motif positionnel seul est accepté, qui est confronté au champ de
   recherche en entier ; pour ces types, les motifs par mots-clés
   fonctionnent comme les autres types.

   S'il n'y a que des motifs par mot-clé (NdT : dans le sens «
   argument par mot-clé »), ils sont évalués comme ceci, un par un :

   I. Le mot-clé est recherché en tant qu'attribut du champ de
   recherche.

      * Si cela lève une exception autre que "AttributeError",
        l'exception est propagée vers le haut.

      * Si cela lève l'exception "AttributeError", le filtre échoue.

      * Sinon, le motif associé au mot-clé est confronté à la valeur
        de l'attribut du champ de recherche. Si cela échoue, le filtre
        de classe échoue ; si cela réussit, le filtre passe au mot-clé
        suivant.

   II. Si tous les motifs par mot-clé ont réussi, le filtre de classe
   réussit.

   Si des motifs positionnels sont présents, ils sont convertis en
   motifs par mot-clé en utilisant l'attribut "__match_args__" de la
   classe "name_or_attr" avant le filtrage :

   I. L'équivalent de "getattr(cls, "__match_args__", ())" est appelé.

      * Si cela lève une exception, elle est propagée vers le haut.

      * Si la valeur de retour n'est pas un *n*-uplet, la conversion
        échoue et une "TypeError" est levée.

      * S'il y a plus de motifs positionnels que
        "len(cls.__match_args__)", une "TypeError" est levée.

      * Sinon, le motif positionnel "i" est converti en motif par mot-
        clé (le mot-clé sera "__match_args__[i]"). "__match_args__[i]"
        doit être une chaîne, sinon une "TypeError" est levée.

      * Si un mot-clé est dupliqué, une "TypeError" est levée.

      Voir aussi:

        Arguments positionnels dans le filtrage par motif sur les
        classes

   II. Une fois que tous les motifs positionnels ont été convertis en
   motifs par mot-clé,
      le filtre se déroule comme si tous les motifs étaient des motifs
      par mots-clés.

   Pour les types natifs suivants, le traitement des motifs
   positionnels est différent :

   * "bool"

   * "bytearray"

   * "bytes"

   * "dict"

   * "float"

   * "frozenset"

   * "int"

   * "list"

   * "set"

   * "str"

   * "tuple"

   Ces classes acceptent un argument positionnel seul et le filtre
   s'applique alors sur l'ensemble de l'objet plutôt que sur un simple
   attribut. Par exemple, "int(0|1)" réussit lorsqu'il est confronté à
   la valeur "0", mais pas lorsque c'est la valeur "0.0".

En termes simples, "CLS(P1, attr=P2)" réussit seulement si la séquence
suivante est déroulée :

* "isinstance(<subject>, CLS)"

* convertit "P1" vers un motif par mot-clé en utilisant
  "CLS.__match_args__"

* Pour chaque argument par mot-clé "attr=P2" :

  * "hasattr(<subject>, "attr")"

  * "P2" correspond à "<subject>.attr"

* … et ainsi de suite pour les paires motif/argument par mot-clé.

Voir aussi:

  * **PEP 634** — Spécifications pour le filtrage par motif

  * **PEP 636** — Tutoriel pour le filtrage par motif


8.7. Définition de fonctions
============================

Une définition de fonction définit un objet fonction défini par
l'utilisateur (voir la section Hiérarchie des types standards) :

   funcdef                   ::= [decorators] "def" funcname [type_params] "(" [parameter_list] ")"
                                 ["->" expression] ":" suite
   decorators                ::= decorator+
   decorator                 ::= "@" assignment_expression NEWLINE
   parameter_list            ::= defparameter ("," defparameter)* "," "/" ["," [parameter_list_no_posonly]]
                                 | parameter_list_no_posonly
   parameter_list_no_posonly ::= defparameter ("," defparameter)* ["," [parameter_list_starargs]]
                                 | parameter_list_starargs
   parameter_list_starargs   ::= "*" [star_parameter] ("," defparameter)* ["," [parameter_star_kwargs]]
                                 | "*" ("," defparameter)+ ["," [parameter_star_kwargs]]
                                 | parameter_star_kwargs
   parameter_star_kwargs     ::= "**" parameter [","]
   parameter                 ::= identifier [":" expression]
   star_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. [4]

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".

Modifié dans la version 3.9: les fonctions peuvent être décorées par
toute "expression d'affectation" valide. Auparavant, la grammaire
était beaucoup plus restrictive ; voir la **PEP 614** pour obtenir les
détails.

A list of type parameters may be given in square brackets between the
function's name and the opening parenthesis for its parameter list.
This indicates to static type checkers that the function is generic.
At runtime, the type parameters can be retrieved from the function's
"__type_params__" attribute. See Generic functions for more.

Modifié dans la version 3.12: Type parameter lists are new in Python
3.12.

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
lorsque la valeur d'un paramètre par défaut est un objet mutable (cas
d'une liste ou un dictionnaire par exemple) : 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 *n*-uplet recevant les paramètres positionnels
en surplus, la valeur par défaut étant le *n*-uplet 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 du
même type. 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é. Au contraire, ceux avant "/" ne peuvent
être passés qu'avec des arguments positionnels.

Modifié dans la version 3.8: ajout de la syntaxe avec "/" pour
indiquer les paramètre exclusivement positionnels (voir la **PEP
570**).

Parameters may have an *annotation* of the form "": expression""
following the parameter name.  Any parameter may have an annotation,
even those of the form "*identifier" or "**identifier". (As a special
case, parameters of the form "*identifier" may have an annotation "":
*expression"".) Functions may have "return" annotation of the form
""-> expression"" after the parameter list.  These annotations can be
any valid Python expression.  The presence of annotations does not
change the semantics of a function.  The annotation values are
available as values of a dictionary keyed by the parameters' names in
the "__annotations__" attribute of the function object.  If the
"annotations" import from "__future__" is used, annotations are
preserved as strings at runtime which enables postponed evaluation.
Otherwise, they are evaluated when the function definition is
executed.  In this case annotations may be evaluated in a different
order than they appear in the source code.

Modifié dans la version 3.11: Parameters of the form ""*identifier""
may have an annotation "": *expression"". See **PEP 646**.

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
     Ability to type hint variable declarations, including class
     variables and instance variables.

  **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.

  **PEP 318** - Decorators for Functions and Methods
     Function and method decorators were introduced. Class decorators
     were introduced in **PEP 3129**.


8.8. 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 [type_params] [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 mères (voir
Métaclasses 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 mère "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é [5]. Un objet classe est alors créé en utilisant la liste
d'héritage pour les classes mères 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.

The order in which attributes are defined in the class body is
preserved in the new class's "__dict__".  Note that this is reliable
only right after the class is created and only for classes that were
defined using the definition syntax.

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.

Modifié dans la version 3.9: les classes peuvent être décorées par
toute "expression d'affectation" valide. Auparavant, la grammaire
était beaucoup plus restrictive ; voir la **PEP 614** pour obtenir les
détails.

A list of type parameters may be given in square brackets immediately
after the class's name. This indicates to static type checkers that
the class is generic. At runtime, the type parameters can be retrieved
from the class's "__type_params__" attribute. See Generic classes for
more.

Modifié dans la version 3.12: Type parameter lists are new in Python
3.12.

**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.9. Coroutines
===============

Ajouté dans la version 3.5.


8.9.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*). 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()

Modifié dans la version 3.7: "await" et "async" sont dorénavant des
mots-clés ; auparavant, ils n'étaient traités comme tels que dans le
corps d'une fonction coroutine.


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

   async_for_stmt ::= "async" for_stmt

Un *itérable asynchrone* fournit une méthode "__aiter__" qui renvoie
directement un *itérateur asynchrone*, celui-ci pouvant appeler du
code asynchrone dans sa méthode "__anext__".

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

Le code suivant :

   async for TARGET in ITER:
       SUITE
   else:
       SUITE2

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:
           SUITE
   else:
       SUITE2

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.9.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 EXPRESSION as TARGET:
       SUITE

est sémantiquement équivalent à :

   manager = (EXPRESSION)
   aenter = type(manager).__aenter__
   aexit = type(manager).__aexit__
   value = await aenter(manager)
   hit_except = False

   try:
       TARGET = value
       SUITE
   except:
       hit_except = True
       if not await aexit(manager, *sys.exc_info()):
           raise
   finally:
       if not hit_except:
           await aexit(manager, 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.


8.10. Type parameter lists
==========================

Ajouté dans la version 3.12.

   type_params  ::= "[" type_param ("," type_param)* "]"
   type_param   ::= typevar | typevartuple | paramspec
   typevar      ::= identifier (":" expression)?
   typevartuple ::= "*" identifier
   paramspec    ::= "**" identifier

Functions (including coroutines), classes and type aliases may contain
a type parameter list:

   def max[T](args: list[T]) -> T:
       ...

   async def amax[T](args: list[T]) -> T:
       ...

   class Bag[T]:
       def __iter__(self) -> Iterator[T]:
           ...

       def add(self, arg: T) -> None:
           ...

   type ListOrSet[T] = list[T] | set[T]

Semantically, this indicates that the function, class, or type alias
is generic over a type variable. This information is primarily used by
static type checkers, and at runtime, generic objects behave much like
their non-generic counterparts.

Type parameters are declared in square brackets ("[]") immediately
after the name of the function, class, or type alias. The type
parameters are accessible within the scope of the generic object, but
not elsewhere. Thus, after a declaration "def func[T](): pass", the
name "T" is not available in the module scope. Below, the semantics of
generic objects are described with more precision. The scope of type
parameters is modeled with a special function (technically, an
annotation scope) that wraps the creation of the generic object.

Generic functions, classes, and type aliases have a "__type_params__"
attribute listing their type parameters.

Type parameters come in three kinds:

* "typing.TypeVar", introduced by a plain name (e.g., "T").
  Semantically, this represents a single type to a type checker.

* "typing.TypeVarTuple", introduced by a name prefixed with a single
  asterisk (e.g., "*Ts"). Semantically, this stands for a tuple of any
  number of types.

* "typing.ParamSpec", introduced by a name prefixed with two asterisks
  (e.g., "**P"). Semantically, this stands for the parameters of a
  callable.

"typing.TypeVar" declarations can define *bounds* and *constraints*
with a colon (":") followed by an expression. A single expression
after the colon indicates a bound (e.g. "T: int"). Semantically, this
means that the "typing.TypeVar" can only represent types that are a
subtype of this bound. A parenthesized tuple of expressions after the
colon indicates a set of constraints (e.g. "T: (str, bytes)"). Each
member of the tuple should be a type (again, this is not enforced at
runtime). Constrained type variables can only take on one of the types
in the list of constraints.

For "typing.TypeVar"s declared using the type parameter list syntax,
the bound and constraints are not evaluated when the generic object is
created, but only when the value is explicitly accessed through the
attributes "__bound__" and "__constraints__". To accomplish this, the
bounds or constraints are evaluated in a separate annotation scope.

"typing.TypeVarTuple"s and "typing.ParamSpec"s cannot have bounds or
constraints.

The following example indicates the full set of allowed type parameter
declarations:

   def overly_generic[
      SimpleTypeVar,
      TypeVarWithBound: int,
      TypeVarWithConstraints: (str, bytes),
      *SimpleTypeVarTuple,
      **SimpleParamSpec,
   ](
      a: SimpleTypeVar,
      b: TypeVarWithBound,
      c: Callable[SimpleParamSpec, TypeVarWithConstraints],
      *d: SimpleTypeVarTuple,
   ): ...


8.10.1. Generic functions
-------------------------

Generic functions are declared as follows:

   def func[T](arg: T): ...

This syntax is equivalent to:

   annotation-def TYPE_PARAMS_OF_func():
       T = typing.TypeVar("T")
       def func(arg: T): ...
       func.__type_params__ = (T,)
       return func
   func = TYPE_PARAMS_OF_func()

Here "annotation-def" indicates an annotation scope, which is not
actually bound to any name at runtime. (One other liberty is taken in
the translation: the syntax does not go through attribute access on
the "typing" module, but creates an instance of "typing.TypeVar"
directly.)

The annotations of generic functions are evaluated within the
annotation scope used for declaring the type parameters, but the
function's defaults and decorators are not.

The following example illustrates the scoping rules for these cases,
as well as for additional flavors of type parameters:

   @decorator
   def func[T: int, *Ts, **P](*args: *Ts, arg: Callable[P, T] = some_default):
       ...

Except for the lazy evaluation of the "TypeVar" bound, this is
equivalent to:

   DEFAULT_OF_arg = some_default

   annotation-def TYPE_PARAMS_OF_func():

       annotation-def BOUND_OF_T():
           return int
       # In reality, BOUND_OF_T() is evaluated only on demand.
       T = typing.TypeVar("T", bound=BOUND_OF_T())

       Ts = typing.TypeVarTuple("Ts")
       P = typing.ParamSpec("P")

       def func(*args: *Ts, arg: Callable[P, T] = DEFAULT_OF_arg):
           ...

       func.__type_params__ = (T, Ts, P)
       return func
   func = decorator(TYPE_PARAMS_OF_func())

The capitalized names like "DEFAULT_OF_arg" are not actually bound at
runtime.


8.10.2. Generic classes
-----------------------

Generic classes are declared as follows:

   class Bag[T]: ...

This syntax is equivalent to:

   annotation-def TYPE_PARAMS_OF_Bag():
       T = typing.TypeVar("T")
       class Bag(typing.Generic[T]):
           __type_params__ = (T,)
           ...
       return Bag
   Bag = TYPE_PARAMS_OF_Bag()

Here again "annotation-def" (not a real keyword) indicates an
annotation scope, and the name "TYPE_PARAMS_OF_Bag" is not actually
bound at runtime.

Generic classes implicitly inherit from "typing.Generic". The base
classes and keyword arguments of generic classes are evaluated within
the type scope for the type parameters, and decorators are evaluated
outside that scope. This is illustrated by this example:

   @decorator
   class Bag(Base[T], arg=T): ...

This is equivalent to:

   annotation-def TYPE_PARAMS_OF_Bag():
       T = typing.TypeVar("T")
       class Bag(Base[T], typing.Generic[T], arg=T):
           __type_params__ = (T,)
           ...
       return Bag
   Bag = decorator(TYPE_PARAMS_OF_Bag())


8.10.3. Generic type aliases
----------------------------

The "type" statement can also be used to create a generic type alias:

   type ListOrSet[T] = list[T] | set[T]

Except for the lazy evaluation of the value, this is equivalent to:

   annotation-def TYPE_PARAMS_OF_ListOrSet():
       T = typing.TypeVar("T")

       annotation-def VALUE_OF_ListOrSet():
           return list[T] | set[T]
       # In reality, the value is lazily evaluated
       return typing.TypeAliasType("ListOrSet", VALUE_OF_ListOrSet(), type_params=(T,))
   ListOrSet = TYPE_PARAMS_OF_ListOrSet()

Here, "annotation-def" (not a real keyword) indicates an annotation
scope. The capitalized names like "TYPE_PARAMS_OF_ListOrSet" are not
actually bound at runtime.

-[ 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] Dans le filtrage par motif, une séquence est définie comme suit :

    * une classe qui hérite de "collections.abc.Sequence"

    * une classe Python qui a été enregistrée en tant que
      "collections.abc.Sequence"

    * une classe native dont le bit (CPython) "Py_TPFLAGS_SEQUENCE"
      est à 1

    * une classe qui hérite d'une classe citée ci-dessus

    Les classes suivantes de la bibliothèque standard sont des
    séquences :

    * "array.array"

    * "collections.deque"

    * "list"

    * "memoryview"

    * "range"

    * "tuple"

    Note:

      Les champs de recherche du type "str", "bytes" et "bytearray" ne
      correspondent pas avec des filtres de séquence.

[3] Dans le filtrage par motif, un tableau associatif est défini comme
    suit :

    * une classe qui hérite de "collections.abc.Mapping"

    * une classe Python qui a été enregistrée en tant que
      "collections.abc.Mapping"

    * une classe native dont le bit (CPython) "Py_TPFLAGS_MAPPING" est
      à 1

    * une classe qui hérite d'une classe citée ci-dessus

    Les classes  "dict" et "types.MappingProxyType" de la bibliothèque
    standard sont des tableaux associatifs.

[4] A string literal appearing as the first statement in the function
    body is transformed into the function's "__doc__" attribute and
    therefore the function's *docstring*.

[5] A string literal appearing as the first statement in the class
    body is transformed into the namespace's "__doc__" item and
    therefore the class's *docstring*.
