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.