# Copyright (C) 2001-2018, Python Software Foundation

# For licence information, see README file.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2023-07-23 14:38+0200\n"

"PO-Revision-Date: 2023-12-05 22:58+0100\n"

"Last-Translator: Christophe Nanteuil <christophe.nanteuil@gmail.com>\n"

"Language-Team: FRENCH <traductions@lists.afpy.org>\n"

"Language: fr\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"X-Generator: Poedit 3.2.2\n"

#: reference/compound_stmts.rst:5

msgid "Compound statements"

msgstr "Instructions composées"

#: reference/compound_stmts.rst:9

msgid ""

"Compound statements contain (groups of) other statements; they affect or "

"control the execution of those other statements in some way. In general, "

"compound statements span multiple lines, although in simple incarnations a "

"whole compound statement may be contained in one line."

msgstr ""

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

#: reference/compound_stmts.rst:14

msgid ""

"The :keyword:`if`, :keyword:`while` and :keyword:`for` statements implement "

"traditional control flow constructs. :keyword:`try` specifies exception "

"handlers and/or cleanup code for a group of statements, while the :keyword:"

"`with` statement allows the execution of initialization and finalization "

"code around a block of code. Function and class definitions are also "

"syntactically compound statements."

msgstr ""

"Les instructions :keyword:`if`, :keyword:`while` et :keyword:`for` "

"implémentent les constructions classiques de contrôle de flux. :keyword:"

"`try` définit des gestionnaires d'exception et du code de nettoyage pour un "

"groupe d'instructions, tandis que l'instruction :keyword:`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."

#: reference/compound_stmts.rst:26

msgid ""

"A compound statement consists of one or more 'clauses.' A clause consists "

"of a header and a 'suite.' The clause headers of a particular compound "

"statement are all at the same indentation level. Each clause header begins "

"with a uniquely identifying keyword and ends with a colon. A suite is a "

"group of statements controlled by a clause. A suite can be one or more "

"semicolon-separated simple statements on the same line as the header, "

"following the header's colon, or it can be one or more indented statements "

"on subsequent lines. Only the latter form of a suite can contain nested "

"compound statements; the following is illegal, mostly because it wouldn't be "

"clear to which :keyword:`if` clause a following :keyword:`else` clause would "

"belong::"

msgstr ""

"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 :keyword:`if` se "

"rapporterait une clause :keyword:`else` placée en fin de ligne ::"

#: reference/compound_stmts.rst:39

msgid ""

"Also note that the semicolon binds tighter than the colon in this context, "

"so that in the following example, either all or none of the :func:`print` "

"calls are executed::"

msgstr ""

"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 :func:`print` sont exécutés, soit aucun ne l'est ::"

#: reference/compound_stmts.rst:45

msgid "Summarizing:"

msgstr "En résumé :"

#: reference/compound_stmts.rst:69

msgid ""

"Note that statements always end in a ``NEWLINE`` possibly followed by a "

"``DEDENT``. Also note that optional continuation clauses always begin with "

"a keyword that cannot start a statement, thus there are no ambiguities (the "

"'dangling :keyword:`else`' problem is solved in Python by requiring nested :"

"keyword:`if` statements to be indented)."

msgstr ""

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

"keyword:`else` dont on ne sait pas à quel ``if`` il est relié est résolu en "

"Python en exigeant que des instructions :keyword:`if` imbriquées soient "

"indentées les unes par rapport aux autres)."

#: reference/compound_stmts.rst:75

msgid ""

"The formatting of the grammar rules in the following sections places each "

"clause on a separate line for clarity."

msgstr ""

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

#: reference/compound_stmts.rst:84

msgid "The :keyword:`!if` statement"

msgstr "L'instruction :keyword:`!if`"

#: reference/compound_stmts.rst:92

msgid "The :keyword:`if` statement is used for conditional execution:"

msgstr ""

"L'instruction :keyword:`if` est utilisée pour exécuter des instructions en "

"fonction d'une condition :"

#: reference/compound_stmts.rst:99

msgid ""

"It selects exactly one of the suites by evaluating the expressions one by "

"one until one is found to be true (see section :ref:`booleans` for the "

"definition of true and false); then that suite is executed (and no other "

"part of the :keyword:`if` statement is executed or evaluated). If all "

"expressions are false, the suite of the :keyword:`else` clause, if present, "

"is executed."

msgstr ""

"Elle sélectionne exactement une des suites en évaluant les expressions une "

"par une jusqu'à ce qu'une soit vraie (voir la section :ref:`booleans` pour "

"la définition de vrai et faux) ; ensuite cette suite est exécutée (et aucune "

"autre partie de l'instruction :keyword:`if` n'est exécutée ou évaluée). Si "

"toutes les expressions sont fausses, la suite de la clause :keyword:`else`, "

"si elle existe, est exécutée."

#: reference/compound_stmts.rst:109

msgid "The :keyword:`!while` statement"

msgstr "L'instruction :keyword:`!while`"

#: reference/compound_stmts.rst:117

msgid ""

"The :keyword:`while` statement is used for repeated execution as long as an "

"expression is true:"

msgstr ""

"L'instruction :keyword:`while` est utilisée pour exécuter des instructions "

"de manière répétée tant qu'une expression est vraie :"

#: reference/compound_stmts.rst:124

msgid ""

"This repeatedly tests the expression and, if it is true, executes the first "

"suite; if the expression is false (which may be the first time it is tested) "

"the suite of the :keyword:`!else` clause, if present, is executed and the "

"loop terminates."

msgstr ""

"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 :keyword:`!else`, si elle "

"existe, est exécutée et la boucle se termine."

#: reference/compound_stmts.rst:133

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and goes back to testing the expression."

msgstr ""

"Une instruction :keyword:`break` exécutée dans la première suite termine la "

"boucle sans exécuter la suite de la clause :keyword:`!else`. Une "

"instruction :keyword:`continue` exécutée dans la première suite saute le "

"reste de la suite et retourne au test de l'expression."

#: reference/compound_stmts.rst:142

msgid "The :keyword:`!for` statement"

msgstr "L'instruction :keyword:`!for`"

#: reference/compound_stmts.rst:153

msgid ""

"The :keyword:`for` statement is used to iterate over the elements of a "

"sequence (such as a string, tuple or list) or other iterable object:"

msgstr ""

"L'instruction :keyword:`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 :"

#: reference/compound_stmts.rst:160

msgid ""

"The ``starred_list`` expression is evaluated once; it should yield an :term:"

"`iterable` object. An :term:`iterator` is created for that iterable. The "

"first item provided by the iterator is then assigned to the target list "

"using the standard rules for assignments (see :ref:`assignment`), and the "

"suite is executed. This repeats for each item provided by the iterator. "

"When the iterator is exhausted, the suite in the :keyword:`!else` clause, if "

"present, is executed, and the loop terminates."

msgstr ""

"L'expression ``starred_list`` n'est évaluée qu'une seule fois ; elle doit "

"produire un objet :term:`iterable`. Un :term:`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 :ref:`assignment`), puis la « suite » est exécutée. "

"Lorsque les éléments de l'itérateur sont épuisés, la « suite » de la clause :"

"keyword:`!else`, si elle existe, est exécutée et la boucle se termine."

#: reference/compound_stmts.rst:173

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and continues with the next item, or with the :keyword:`!else` clause if "

"there is no next item."

msgstr ""

"Une instruction :keyword:`break` exécutée dans la première suite termine la "

"boucle sans exécuter la suite de la clause :keyword:`!else`. Une "

"instruction :keyword:`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 :"

"keyword:`!else` s'il n'y a pas d'élément suivant."

#: reference/compound_stmts.rst:179

msgid ""

"The for-loop makes assignments to the variables in the target list. This "

"overwrites all previous assignments to those variables including those made "

"in the suite of the for-loop::"

msgstr ""

"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`` ::"

#: reference/compound_stmts.rst:193

msgid ""

"Names in the target list are not deleted when the loop is finished, but if "

"the sequence is empty, they will not have been assigned to at all by the "

"loop. Hint: the built-in type :func:`range` represents immutable arithmetic "

"sequences of integers. For instance, iterating ``range(3)`` successively "

"yields 0, 1, and then 2."

msgstr ""

"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 :func:`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."

# suit un :

#: reference/compound_stmts.rst:198

msgid "Starred elements are now allowed in the expression list."

msgstr ""

"les éléments étoilés sont maintenant autorisés dans l'expression liste."

#: reference/compound_stmts.rst:205

msgid "The :keyword:`!try` statement"

msgstr "L'instruction :keyword:`!try`"

#: reference/compound_stmts.rst:215

msgid ""

"The :keyword:`!try` statement specifies exception handlers and/or cleanup "

"code for a group of statements:"

msgstr ""

"L'instruction :keyword:`!try` définit les gestionnaires d'exception ou le "

"code de nettoyage pour un groupe d'instructions :"

#: reference/compound_stmts.rst:231

msgid ""

"Additional information on exceptions can be found in section :ref:"

"`exceptions`, and information on using the :keyword:`raise` statement to "

"generate exceptions may be found in section :ref:`raise`."

msgstr ""

"Vous trouvez des informations supplémentaires relatives aux exceptions dans "

"la section :ref:`exceptions` et, dans la section :ref:`raise`, des "

"informations relatives à l'utilisation de l'instruction :keyword:`raise` "

"pour produire des exceptions."

#: reference/compound_stmts.rst:239

msgid ":keyword:`!except` clause"

msgstr "clause :keyword:`!except`"

#: reference/compound_stmts.rst:241

msgid ""

"The :keyword:`!except` clause(s) specify one or more exception handlers. "

"When no exception occurs in the :keyword:`try` clause, no exception handler "

"is executed. When an exception occurs in the :keyword:`!try` suite, a search "

"for an exception handler is started. This search inspects the :keyword:`!"

"except` clauses in turn until one is found that matches the exception. An "

"expression-less :keyword:`!except` clause, if present, must be last; it "

"matches any exception. For an :keyword:`!except` clause with an expression, "

"that expression is evaluated, and the clause matches the exception if the "

"resulting object is \"compatible\" with the exception. An object is "

"compatible with an exception if the object is the class or a :term:`non-"

"virtual base class <abstract base class>` of the exception object, or a "

"tuple containing an item that is the class or a non-virtual base class of "

"the exception object."

msgstr ""

"La ou les clauses :keyword:`!except` précisent un ou plusieurs gestionnaires "

"d'exceptions. Si aucune exception ne se produit dans la clause :keyword:"

"`try`, aucun gestionnaire d'exception n'est exécuté. Lorsqu'une exception se "

"produit dans la suite de :keyword:`!try`, Python recherche un gestionnaire "

"d'exception. Cette recherche inspecte les clauses :keyword:`!except`, l'une "

"après l'autre, jusqu'à trouver une correspondance. Une clause :keyword:`!"

"except` vide (c'est-à-dire sans expression), si elle est présente, doit être "

"la dernière ; elle correspond à toute exception. Pour une clause :keyword:`!"

"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 mère (mais pas une :term:`classe mère abstraite`) de l'objet "

"exception ou si c'est un *n*-uplet dont un élément est la classe ou une "

"classe mère (non-abstraite) de l'exception."

#: reference/compound_stmts.rst:256

msgid ""

"If no :keyword:`!except` clause matches the exception, the search for an "

"exception handler continues in the surrounding code and on the invocation "

"stack. [#]_"

msgstr ""

"Si aucune clause :keyword:`!except` ne correspond à l'exception, la "

"recherche d'un gestionnaire d'exception se poursuit dans le code englobant "

"et dans la pile d'appels. [#]_"

#: reference/compound_stmts.rst:260

msgid ""

"If the evaluation of an expression in the header of an :keyword:`!except` "

"clause raises an exception, the original search for a handler is canceled "

"and a search starts for the new exception in the surrounding code and on the "

"call stack (it is treated as if the entire :keyword:`try` statement raised "

"the exception)."

msgstr ""

"Si l'évaluation d'une expression dans l'en-tête d'une clause :keyword:`!"

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

"keyword:`try` avait levé l'exception)."

#: reference/compound_stmts.rst:268

msgid ""

"When a matching :keyword:`!except` clause is found, the exception is "

"assigned to the target specified after the :keyword:`!as` keyword in that :"

"keyword:`!except` clause, if present, and the :keyword:`!except` clause's "

"suite is executed. All :keyword:`!except` clauses must have an executable "

"block. When the end of this block is reached, execution continues normally "

"after the entire :keyword:`try` statement. (This means that if two nested "

"handlers exist for the same exception, and the exception occurs in the :"

"keyword:`!try` clause of the inner handler, the outer handler will not "

"handle the exception.)"

msgstr ""

"Lorsqu'une clause :keyword:`!except` correspond, l'exception est affectée à "

"la cible précisée après le mot-clé :keyword:`!as` dans cette clause :keyword:"

"`!except`, si cette cible existe, et la suite de clause :keyword:`!except` "

"est exécutée. Toutes les clauses :keyword:`!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 :keyword:`try` (cela signifie "

"que si deux gestionnaires imbriqués existent pour la même exception, et que "

"l'exception se produit dans la clause :keyword:`!try` du gestionnaire "

"interne, le gestionnaire externe ne gère pas l'exception)."

#: reference/compound_stmts.rst:279

msgid ""

"When an exception has been assigned using ``as target``, it is cleared at "

"the end of the :keyword:`!except` clause. This is as if ::"

msgstr ""

"Lorsqu'une exception a été affectée en utilisant ``as cible``, elle est "

"effacée à la fin de la clause :keyword:`!except`. C'est comme si ::"

#: reference/compound_stmts.rst:285

msgid "was translated to ::"

msgstr "avait été traduit en \t::"

#: reference/compound_stmts.rst:293

msgid ""

"This means the exception must be assigned to a different name to be able to "

"refer to it after the :keyword:`!except` clause. Exceptions are cleared "

"because with the traceback attached to them, they form a reference cycle "

"with the stack frame, keeping all locals in that frame alive until the next "

"garbage collection occurs."

msgstr ""

"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 :keyword:`!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."

#: reference/compound_stmts.rst:303

msgid ""

"Before an :keyword:`!except` clause's suite is executed, the exception is "

"stored in the :mod:`sys` module, where it can be accessed from within the "

"body of the :keyword:`!except` clause by calling :func:`sys.exception`. When "

"leaving an exception handler, the exception stored in the :mod:`sys` module "

"is reset to its previous value::"

msgstr ""

"Avant qu'une suite de clauses :keyword:`!except` ne soit exécutée, "

"l'exception est stockée dans le module :mod:`sys`, où elle est accessible "

"depuis le corps de la clause :keyword:`!except` en appelant :func:`sys."

"exception`. Lorsque vous quittez un gestionnaire d'exceptions, l'exception "

"stockée dans le module :mod:`sys` est réinitialisée à sa valeur précédente ::"

#: reference/compound_stmts.rst:334

msgid ":keyword:`!except*` clause"

msgstr "clause :keyword:`!except*`"

#: reference/compound_stmts.rst:336

msgid ""

"The :keyword:`!except*` clause(s) are used for handling :exc:"

"`ExceptionGroup`\\s. The exception type for matching is interpreted as in "

"the case of :keyword:`except`, but in the case of exception groups we can "

"have partial matches when the type matches some of the exceptions in the "

"group. This means that multiple :keyword:`!except*` clauses can execute, "

"each handling part of the exception group. Each clause executes at most once "

"and handles an exception group of all matching exceptions. Each exception "

"in the group is handled by at most one :keyword:`!except*` clause, the first "

"that matches it. ::"

msgstr ""

"Les clauses :keyword:`!except*` sont utilisées pour gérer des :exc:"

"`ExceptionGroup`. Le type de l'exception pour la correspondance est "

"interprété de la même manière que dans le cas d'un :keyword:`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 :keyword:`!"

"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 :keyword:`!except*` au plus, la "

"première à laquelle elle correspond. ::"

#: reference/compound_stmts.rst:364

msgid ""

"Any remaining exceptions that were not handled by any :keyword:`!except*` "

"clause are re-raised at the end, combined into an exception group along with "

"all exceptions that were raised from within :keyword:`!except*` clauses."

msgstr ""

"Toutes les exceptions restantes qui n'ont été gérées par aucune clause :"

"keyword:`!except*` sont réactivées à la fin, combinées dans un groupe "

"d'exceptions avec toutes les exceptions qui ont été levées à partir des "

"clauses :keyword:`!except*`."

#: reference/compound_stmts.rst:368

msgid ""

"From version 3.11.4, when the entire :exc:`ExceptionGroup` is handled and "

"only one exception is raised from an :keyword:`!except*` clause, this "

"exception is no longer wrapped to form a new :exc:`ExceptionGroup`."

msgstr ""

"À partir de la version 3.11.4, lorsque l'intégralité de :exc:"

"`ExceptionGroup` est gérée et qu'une seule exception est levée à partir "

"d'une clause :keyword:`!except*`, cette exception n'est plus encapsulée pour "

"former un nouveau :exc:`ExceptionGroup`."

#: reference/compound_stmts.rst:372

msgid ""

"If the raised exception is not an exception group and its type matches one "

"of the :keyword:`!except*` clauses, it is caught and wrapped by an exception "

"group with an empty message string. ::"

msgstr ""

"Si l'exception levée n'est pas un groupe d'exceptions et que son type "

"correspond à l'une des clauses :keyword:`!except*`, elle est interceptée et "

"encapsulée par un groupe d'exceptions avec une chaîne de message vide. ::"

#: reference/compound_stmts.rst:383

msgid ""

"An :keyword:`!except*` clause must have a matching type, and this type "

"cannot be a subclass of :exc:`BaseExceptionGroup`. It is not possible to "

"mix :keyword:`except` and :keyword:`!except*` in the same :keyword:`try`. :"

"keyword:`break`, :keyword:`continue` and :keyword:`return` cannot appear in "

"an :keyword:`!except*` clause."

msgstr ""

"Une clause :keyword:`!except*` doit avoir un type correspondant, et ce type "

"ne peut pas être une sous-classe de :exc:`BaseExceptionGroup`. Il n'est pas "

"possible de combiner :keyword:`except` et :keyword:`!except*` dans un même :"

"keyword:`try`. Aucune clause :keyword:`break`, :keyword:`continue` ou :"

"keyword:`return` ne peut apparaître dans une clause :keyword:`!except*`."

#: reference/compound_stmts.rst:400

msgid ":keyword:`!else` clause"

msgstr "clause :keyword:`!else`"

#: reference/compound_stmts.rst:402

msgid ""

"The optional :keyword:`!else` clause is executed if the control flow leaves "

"the :keyword:`try` suite, no exception was raised, and no :keyword:"

"`return`, :keyword:`continue`, or :keyword:`break` statement was executed. "

"Exceptions in the :keyword:`!else` clause are not handled by the preceding :"

"keyword:`except` clauses."

msgstr ""

"La clause optionnelle :keyword:`!else` n'est exécutée que si l'exécution "

"atteint la fin de la clause :keyword:`try`, aucune exception n'a été levée, "

"et aucun :keyword:`return`, :keyword:`continue`, ou :keyword:`break` ont "

"étés exécutés. Les exceptions dans la clause :keyword:`!else` ne sont pas "

"gérées par les clauses :keyword:`except` précédentes."

#: reference/compound_stmts.rst:414

msgid ":keyword:`!finally` clause"

msgstr "clause :keyword:`!finally`"

#: reference/compound_stmts.rst:416

msgid ""

"If :keyword:`!finally` is present, it specifies a 'cleanup' handler. The :"

"keyword:`try` clause is executed, including any :keyword:`except` and :"

"keyword:`else` clauses. If an exception occurs in any of the clauses and is "

"not handled, the exception is temporarily saved. The :keyword:`!finally` "

"clause is executed. If there is a saved exception it is re-raised at the "

"end of the :keyword:`!finally` clause. If the :keyword:`!finally` clause "

"raises another exception, the saved exception is set as the context of the "

"new exception. If the :keyword:`!finally` clause executes a :keyword:"

"`return`, :keyword:`break` or :keyword:`continue` statement, the saved "

"exception is discarded::"

msgstr ""

"Si :keyword:`!finally` est présente, elle définit un gestionnaire de "

"« nettoyage ». La clause :keyword:`try` est exécutée, y compris les clauses :"

"keyword:`except` et :keyword:`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 :keyword:`!finally` est exécutée. S'il y a une "

"exception sauvegardée, elle est levée à nouveau à la fin de la clause :"

"keyword:`!finally`. Si la clause :keyword:`!finally` lève une autre "

"exception, l'exception sauvegardée est définie comme le contexte de la "

"nouvelle exception. Si la clause :keyword:`!finally` exécute une "

"instruction :keyword:`return`, :keyword:`break` ou :keyword:`continue`, "

"l'exception sauvegardée est jetée ::"

#: reference/compound_stmts.rst:435

msgid ""

"The exception information is not available to the program during execution "

"of the :keyword:`!finally` clause."

msgstr ""

"L'information relative à l'exception n'est pas disponible pour le programme "

"pendant l'exécution de la clause :keyword:`!finally`."

#: reference/compound_stmts.rst:443

msgid ""

"When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement "

"is executed in the :keyword:`try` suite of a :keyword:`!try`...\\ :keyword:`!"

"finally` statement, the :keyword:`!finally` clause is also executed 'on the "

"way out.'"

msgstr ""

"Lorsqu'une instruction :keyword:`return`, :keyword:`break` ou :keyword:"

"`continue` est exécutée dans la suite d'une instruction :keyword:`try` d'une "

"construction :keyword:`!try`…\\ :keyword:`!finally`, la clause :keyword:`!"

"finally` est aussi exécutée « à la sortie »."

#: reference/compound_stmts.rst:447

msgid ""

"The return value of a function is determined by the last :keyword:`return` "

"statement executed. Since the :keyword:`!finally` clause always executes, "

"a :keyword:`!return` statement executed in the :keyword:`!finally` clause "

"will always be the last one executed::"

msgstr ""

"La valeur de retour d'une fonction est déterminée par la dernière "

"instruction :keyword:`return` exécutée. Puisque la clause :keyword:`!"

"finally` s'exécute toujours, une instruction :keyword:`!return` exécutée "

"dans le :keyword:`!finally` sera toujours la dernière clause exécutée ::"

#: reference/compound_stmts.rst:461

msgid ""

"Prior to Python 3.8, a :keyword:`continue` statement was illegal in the :"

"keyword:`!finally` clause due to a problem with the implementation."

msgstr ""

"Avant Python 3.8, une instruction :keyword:`continue` n'était pas licite "

"dans une clause :keyword:`!finally` en raison d'un problème dans "

"l'implémentation."

#: reference/compound_stmts.rst:470

msgid "The :keyword:`!with` statement"

msgstr "L'instruction :keyword:`!with`"

#: reference/compound_stmts.rst:479

msgid ""

"The :keyword:`with` statement is used to wrap the execution of a block with "

"methods defined by a context manager (see section :ref:`context-managers`). "

"This allows common :keyword:`try`...\\ :keyword:`except`...\\ :keyword:"

"`finally` usage patterns to be encapsulated for convenient reuse."

msgstr ""

"L'instruction :keyword:`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 :ref:`context-managers`). Cela permet d'utiliser de manière simple "

"le patron de conception classique :keyword:`try`…\\ :keyword:`except`…\\ :"

"keyword:`finally`."

#: reference/compound_stmts.rst:489

msgid ""

"The execution of the :keyword:`with` statement with one \"item\" proceeds as "

"follows:"

msgstr ""

"L'exécution de l'instruction :keyword:`with` avec un seul "

"« élément » (*item* dans la grammaire) se déroule comme suit :"

#: reference/compound_stmts.rst:491

msgid ""

"The context expression (the expression given in the :token:`~python-grammar:"

"with_item`) is evaluated to obtain a context manager."

msgstr ""

"L'expression de contexte (l'expression donnée dans le :token:`~python-"

"grammar:with_item`) est évaluée pour obtenir un gestionnaire de contexte."

#: reference/compound_stmts.rst:494

msgid "The context manager's :meth:`__enter__` is loaded for later use."

msgstr ""

"La méthode :meth:`__enter__` du gestionnaire de contexte est chargée pour "

"une utilisation ultérieure."

#: reference/compound_stmts.rst:496

msgid "The context manager's :meth:`__exit__` is loaded for later use."

msgstr ""

"La méthode :meth:`__exit__` du gestionnaire de contexte est chargée pour une "

"utilisation ultérieure."

#: reference/compound_stmts.rst:498

msgid "The context manager's :meth:`__enter__` method is invoked."

msgstr "La méthode :meth:`__enter__` du gestionnaire de contexte est invoquée."

#: reference/compound_stmts.rst:500

msgid ""

"If a target was included in the :keyword:`with` statement, the return value "

"from :meth:`__enter__` is assigned to it."

msgstr ""

"Si une cible (*target* dans la grammaire ci-dessus) a été incluse dans "

"l'instruction :keyword:`with`, la valeur de retour de :meth:`__enter__` lui "

"est assignée."

#: reference/compound_stmts.rst:505

msgid ""

"The :keyword:`with` statement guarantees that if the :meth:`__enter__` "

"method returns without an error, then :meth:`__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."

msgstr ""

"L'instruction :keyword:`with` garantit que si la méthode :meth:`__enter__` "

"se termine sans erreur, alors la méthode :meth:`__exit__` est toujours "

"appelée. Ainsi, si une erreur se produit pendant l'affectation à la liste "

"cible, elle est traitée de la même façon qu'une erreur se produisant dans la "

"suite. Voir l'étape 7 ci-dessous."

#: reference/compound_stmts.rst:511

msgid "The suite is executed."

msgstr "La suite est exécutée."

#: reference/compound_stmts.rst:513

msgid ""

"The context manager's :meth:`__exit__` method is invoked. If an exception "

"caused the suite to be exited, its type, value, and traceback are passed as "

"arguments to :meth:`__exit__`. Otherwise, three :const:`None` arguments are "

"supplied."

msgstr ""

"La méthode :meth:`__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 à :meth:`__exit__`. Sinon, trois "

"arguments :const:`None` sont fournis."

#: reference/compound_stmts.rst:518

msgid ""

"If the suite was exited due to an exception, and the return value from the :"

"meth:`__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 :keyword:`with` statement."

msgstr ""

"Si l'on est sorti de la suite en raison d'une exception et que la valeur de "

"retour de la méthode :meth:`__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 :keyword:"

"`with`."

#: reference/compound_stmts.rst:523

msgid ""

"If the suite was exited for any reason other than an exception, the return "

"value from :meth:`__exit__` is ignored, and execution proceeds at the normal "

"location for the kind of exit that was taken."

msgstr ""

"Si l'on est sorti de la suite pour une raison autre qu'une exception, la "

"valeur de retour de :meth:`__exit__` est ignorée et l'exécution se poursuit "

"à l'endroit normal pour le type de sortie prise."

#: reference/compound_stmts.rst:527 reference/compound_stmts.rst:1518

#: reference/compound_stmts.rst:1559

msgid "The following code::"

msgstr "Le code suivant ::"

#: reference/compound_stmts.rst:532 reference/compound_stmts.rst:557

#: reference/compound_stmts.rst:1564

msgid "is semantically equivalent to::"

msgstr "est sémantiquement équivalent à ::"

#: reference/compound_stmts.rst:551

msgid ""

"With more than one item, the context managers are processed as if multiple :"

"keyword:`with` statements were nested::"

msgstr ""

"Avec plus d'un élément, les gestionnaires de contexte sont traités comme si "

"plusieurs instructions :keyword:`with` étaient imbriquées ::"

#: reference/compound_stmts.rst:563

msgid ""

"You can also write multi-item context managers in multiple lines if the "

"items are surrounded by parentheses. For example::"

msgstr ""

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

#: reference/compound_stmts.rst:572

msgid "Support for multiple context expressions."

msgstr "Prise en charge de multiples expressions de contexte."

# Pas de majuscule car après un :

#: reference/compound_stmts.rst:575

msgid ""

"Support for using grouping parentheses to break the statement in multiple "

"lines."

msgstr ""

"prise en charge des parenthèses pour pouvoir écrire l'instruction sur "

"plusieurs lignes."

#: reference/compound_stmts.rst:581

msgid ":pep:`343` - The \"with\" statement"

msgstr ":pep:`343` — L'instruction « *with* »"

#: reference/compound_stmts.rst:581

msgid ""

"The specification, background, and examples for the Python :keyword:`with` "

"statement."

msgstr ""

"La spécification, les motivations et des exemples de l'instruction :keyword:"

"`with` en Python."

#: reference/compound_stmts.rst:587

msgid "The :keyword:`!match` statement"

msgstr "L'instruction :keyword:`!match`"

#: reference/compound_stmts.rst:601

msgid "The match statement is used for pattern matching. Syntax:"

msgstr ""

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

"est :"

# Pas de majuscule car après un :

#: reference/compound_stmts.rst:610

msgid ""

"This section uses single quotes to denote :ref:`soft keywords <soft-"

"keywords>`."

msgstr ""

"cette section utilise les guillemets simples pour désigner les :ref:`mots-"

"clés ad-hoc <soft-keywords>`."

#: reference/compound_stmts.rst:613

msgid ""

"Pattern matching takes a pattern as input (following ``case``) and a subject "

"value (following ``match``). The pattern (which may contain subpatterns) is "

"matched against the subject value. The outcomes are:"

msgstr ""

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

# énumération

#: reference/compound_stmts.rst:617

msgid "A match success or failure (also termed a pattern success or failure)."

msgstr ""

"un indicateur de réussite ou d'échec pour le filtrage (on peut aussi dire "

"que le motif a réussi ou échoué) ;"

# énumération

#: reference/compound_stmts.rst:619

msgid ""

"Possible binding of matched values to a name. The prerequisites for this "

"are further discussed below."

msgstr ""

"la possibilité de lier les valeurs filtrées à un nom. Les pré-requis sont "

"indiqués plus bas."

#: reference/compound_stmts.rst:622

msgid ""

"The ``match`` and ``case`` keywords are :ref:`soft keywords <soft-keywords>`."

msgstr ""

"Les mots-clés ``match`` et ``case`` sont des :ref:`mots-clés ad-hoc <soft-"

"keywords>`."

#: reference/compound_stmts.rst:626 reference/compound_stmts.rst:1181

msgid ":pep:`634` -- Structural Pattern Matching: Specification"

msgstr ":pep:`634` — Spécifications pour le filtrage par motif"

#: reference/compound_stmts.rst:627 reference/compound_stmts.rst:1182

msgid ":pep:`636` -- Structural Pattern Matching: Tutorial"

msgstr ":pep:`636` — Tutoriel pour le filtrage par motif"

#: reference/compound_stmts.rst:631

msgid "Overview"

msgstr "Aperçu"

#: reference/compound_stmts.rst:633

msgid "Here's an overview of the logical flow of a match statement:"

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

#: reference/compound_stmts.rst:636

msgid ""

"The subject expression ``subject_expr`` is evaluated and a resulting subject "

"value obtained. If the subject expression contains a comma, a tuple is "

"constructed using :ref:`the standard rules <typesseq-tuple>`."

msgstr ""

"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 :ref:`règles classiques <typesseq-"

"tuple>`."

#: reference/compound_stmts.rst:640

msgid ""

"Each pattern in a ``case_block`` is attempted to match with the subject "

"value. The specific rules for success or failure are described below. The "

"match attempt can also bind some or all of the standalone names within the "

"pattern. The precise pattern binding rules vary per pattern type and are "

"specified below. **Name bindings made during a successful pattern match "

"outlive the executed block and can be used after the match statement**."

msgstr ""

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

# Pas de majuscule car après ':'

#: reference/compound_stmts.rst:649

msgid ""

"During failed pattern matches, some subpatterns may succeed. Do not rely on "

"bindings being made for a failed match. Conversely, do not rely on "

"variables remaining unchanged after a failed match. The exact behavior is "

"dependent on implementation and may vary. This is an intentional decision "

"made to allow different implementations to add optimizations."

msgstr ""

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

#: reference/compound_stmts.rst:656

msgid ""

"If the pattern succeeds, the corresponding guard (if present) is evaluated. "

"In this case all name bindings are guaranteed to have happened."

msgstr ""

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

#: reference/compound_stmts.rst:659

msgid ""

"If the guard evaluates as true or is missing, the ``block`` inside "

"``case_block`` is executed."

msgstr ""

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

#: reference/compound_stmts.rst:662

msgid "Otherwise, the next ``case_block`` is attempted as described above."

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

#: reference/compound_stmts.rst:664

msgid "If there are no further case blocks, the match statement is completed."

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

# Pas de majuscule car après ':'

#: reference/compound_stmts.rst:668

msgid ""

"Users should generally never rely on a pattern being evaluated. Depending "

"on implementation, the interpreter may cache values or use other "

"optimizations which skip repeated evaluations."

msgstr ""

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

#: reference/compound_stmts.rst:672

msgid "A sample match statement::"

msgstr "Voici un exemple d'instruction de filtrage par motif ::"

#: reference/compound_stmts.rst:688

msgid ""

"In this case, ``if flag`` is a guard. Read more about that in the next "

"section."

msgstr ""

"Dans cet exemple, ``if flag`` est une garde. Plus de détails sont fournis "

"dans la prochaine section."

#: reference/compound_stmts.rst:691

msgid "Guards"

msgstr "Gardes"

#: reference/compound_stmts.rst:698

msgid ""

"A ``guard`` (which is part of the ``case``) must succeed for code inside the "

"``case`` block to execute. It takes the form: :keyword:`if` followed by an "

"expression."

msgstr ""

"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é :keyword:`if` suivi d'une expression."

#: reference/compound_stmts.rst:703

msgid "The logical flow of a ``case`` block with a ``guard`` follows:"

msgstr ""

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

"suivant :"

#: reference/compound_stmts.rst:705

msgid ""

"Check that the pattern in the ``case`` block succeeded. If the pattern "

"failed, the ``guard`` is not evaluated and the next ``case`` block is "

"checked."

msgstr ""

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

#: reference/compound_stmts.rst:709

msgid "If the pattern succeeded, evaluate the ``guard``."

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

#: reference/compound_stmts.rst:711

msgid ""

"If the ``guard`` condition evaluates as true, the case block is selected."

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

#: reference/compound_stmts.rst:714

msgid ""

"If the ``guard`` condition evaluates as false, the case block is not "

"selected."

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

#: reference/compound_stmts.rst:717

msgid ""

"If the ``guard`` raises an exception during evaluation, the exception "

"bubbles up."

msgstr ""

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

"est propagée."

#: reference/compound_stmts.rst:720

msgid ""

"Guards are allowed to have side effects as they are expressions. Guard "

"evaluation must proceed from the first to the last case block, one at a "

"time, skipping case blocks whose pattern(s) don't all succeed. (I.e., guard "

"evaluation must happen in order.) Guard evaluation must stop once a case "

"block is selected."

msgstr ""

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

#: reference/compound_stmts.rst:730

msgid "Irrefutable Case Blocks"

msgstr "Bloc ``case`` attrape-tout"

#: reference/compound_stmts.rst:734

msgid ""

"An irrefutable case block is a match-all case block. A match statement may "

"have at most one irrefutable case block, and it must be last."

msgstr ""

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

#: reference/compound_stmts.rst:737

msgid ""

"A case block is considered irrefutable if it has no guard and its pattern is "

"irrefutable. A pattern is considered irrefutable if we can prove from its "

"syntax alone that it will always succeed. Only the following patterns are "

"irrefutable:"

msgstr ""

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

#: reference/compound_stmts.rst:742

msgid ":ref:`as-patterns` whose left-hand side is irrefutable"

msgstr "Les :ref:`as-patterns` pour lesquels la partie gauche est attrape-tout"

#: reference/compound_stmts.rst:744

msgid ":ref:`or-patterns` containing at least one irrefutable pattern"

msgstr "Les :ref:`or-patterns` contenant au moins un filtre attrape-tout"

#: reference/compound_stmts.rst:746

msgid ":ref:`capture-patterns`"

msgstr "Les :ref:`capture-patterns`"

#: reference/compound_stmts.rst:748

msgid ":ref:`wildcard-patterns`"

msgstr "Les :ref:`wildcard-patterns`"

#: reference/compound_stmts.rst:750

msgid "parenthesized irrefutable patterns"

msgstr "les filtres attrape-tout entre parenthèses"

#: reference/compound_stmts.rst:754