controlflow.po

# 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: 2025-10-17 09:58+0200\n"
"PO-Revision-Date: 2024-12-16 23: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"

#: tutorial/controlflow.rst:5
msgid "More Control Flow Tools"
msgstr "D'autres outils de contrôle de flux"

#: tutorial/controlflow.rst:7
msgid ""
"As well as the :keyword:`while` statement just introduced, Python uses a few "
"more that we will encounter in this chapter."
msgstr ""
"En plus de l'instruction :keyword:`while` qui vient d'être présentée, Python "
"dispose d'autres instructions de contrôle de flux que l'on détaillera dans "
"ce chapitre."

#: tutorial/controlflow.rst:14
msgid ":keyword:`!if` Statements"
msgstr "L'instruction :keyword:`!if`"

#: tutorial/controlflow.rst:16
msgid ""
"Perhaps the most well-known statement type is the :keyword:`if` statement.  "
"For example::"
msgstr ""
"L'instruction :keyword:`if` est sans doute la plus connue. Par exemple ::"

#: tutorial/controlflow.rst:33
msgid ""
"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "
"part is optional.  The keyword ':keyword:`!elif`' is short for 'else if', "
"and is useful to avoid excessive indentation.  An  :keyword:`!"
"if` ... :keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute "
"for the ``switch`` or ``case`` statements found in other languages."
msgstr ""
"Il peut y avoir un nombre quelconque de parties :keyword:`elif` et la "
"partie :keyword:`else` est facultative. Le mot clé :keyword:`!elif` est un "
"raccourci pour *else if*, et permet de gagner un niveau d'indentation. Une "
"séquence :keyword:`!if` ... :keyword:`!elif` ... :keyword:`!elif` ... est "
"par ailleurs équivalente aux instructions ``switch`` ou ``case`` disponibles "
"dans d'autres langages."

#: tutorial/controlflow.rst:39
msgid ""
"If you're comparing the same value to several constants, or checking for "
"specific types or attributes, you may also find the :keyword:`!match` "
"statement useful. For more details see :ref:`tut-match`."
msgstr ""
"Pour les comparaisons avec beaucoup de constantes, ainsi que les tests "
"d'appartenance à un type ou de forme d'un attribut, l'instruction :keyword:`!"
"match` décrite plus bas peut se révéler utile (voir :ref:`tut-match`)."

#: tutorial/controlflow.rst:46
msgid ":keyword:`!for` Statements"
msgstr "L'instruction :keyword:`!for`"

#: tutorial/controlflow.rst:51
msgid ""
"The :keyword:`for` statement in Python differs a bit from what you may be "
"used to in C or Pascal.  Rather than always iterating over an arithmetic "
"progression of numbers (like in Pascal), or giving the user the ability to "
"define both the iteration step and halting condition (as C), "
"Python's :keyword:`!for` statement iterates over the items of any sequence "
"(a list or a string), in the order that they appear in the sequence.  For "
"example (no pun intended):"
msgstr ""
"L'instruction :keyword:`for` que propose Python est un peu différente de "
"celle que l'on peut trouver en C ou en Pascal. Au lieu de toujours itérer "
"sur une suite arithmétique de nombres (comme en Pascal), ou de donner à "
"l'utilisateur la possibilité de définir le pas d'itération et la condition "
"de fin (comme en C), l'instruction :keyword:`!for` en Python itère sur les "
"éléments d'une séquence (qui peut être une liste, une chaîne de "
"caractères…), dans l'ordre dans lequel ils apparaissent dans la séquence. "
"Par exemple :"

#: tutorial/controlflow.rst:72
msgid ""
"Code that modifies a collection while iterating over that same collection "
"can be tricky to get right.  Instead, it is usually more straight-forward to "
"loop over a copy of the collection or to create a new collection::"
msgstr ""
"Écrire du code qui modifie une collection tout en itérant dessus peut "
"s'avérer délicat. Il est généralement plus simple de boucler sur une copie "
"de la collection ou de créer une nouvelle collection ::"

#: tutorial/controlflow.rst:94
msgid "The :func:`range` Function"
msgstr "La fonction :func:`range`"

#: tutorial/controlflow.rst:96
msgid ""
"If you do need to iterate over a sequence of numbers, the built-in "
"function :func:`range` comes in handy.  It generates arithmetic "
"progressions::"
msgstr ""
"Si vous devez itérer sur une suite de nombres, la fonction "
"native :func:`range` est faite pour cela. Elle génère des suites "
"arithmétiques ::"

#: tutorial/controlflow.rst:108
msgid ""
"The given end point is never part of the generated sequence; ``range(10)`` "
"generates 10 values, the legal indices for items of a sequence of length "
"10.  It is possible to let the range start at another number, or to specify "
"a different increment (even negative; sometimes this is called the 'step')::"
msgstr ""
"Le dernier élément fourni en paramètre ne fait jamais partie de la liste "
"générée ; ``range(10)`` génère une liste de 10 valeurs, dont les valeurs "
"vont de 0 à 9. Il est possible de spécifier une valeur de début et une "
"valeur d'incrément différentes (y compris négative pour cette dernière, que "
"l'on appelle également parfois le « pas ») ::"

#: tutorial/controlflow.rst:122
msgid ""
"To iterate over the indices of a sequence, you can combine :func:`range` "
"and :func:`len` as follows::"
msgstr ""
"Pour itérer sur les indices d'une séquence, on peut combiner les "
"fonctions :func:`range` et :func:`len` ::"

#: tutorial/controlflow.rst:135
msgid ""
"In most such cases, however, it is convenient to use the :func:`enumerate` "
"function, see :ref:`tut-loopidioms`."
msgstr ""
"Cependant, dans la plupart des cas, il est plus pratique d'utiliser la "
"fonction :func:`enumerate`. Voyez pour cela :ref:`tut-loopidioms`."

#: tutorial/controlflow.rst:138
msgid "A strange thing happens if you just print a range::"
msgstr "Une chose étrange se produit lorsqu'on affiche un *range* ::"

#: tutorial/controlflow.rst:143
msgid ""
"In many ways the object returned by :func:`range` behaves as if it is a "
"list, but in fact it isn't. It is an object which returns the successive "
"items of the desired sequence when you iterate over it, but it doesn't "
"really make the list, thus saving space."
msgstr ""
"L'objet renvoyé par :func:`range` se comporte presque comme une liste, mais "
"ce n'en est pas une. Cet objet génère les éléments de la séquence au fur et "
"à mesure de l'itération, sans réellement produire la liste en tant que "
"telle, économisant ainsi de l'espace."

#: tutorial/controlflow.rst:148
msgid ""
"We say such an object is :term:`iterable`, that is, suitable as a target for "
"functions and constructs that expect something from which they can obtain "
"successive items until the supply is exhausted.  We have seen that "
"the :keyword:`for` statement is such a construct, while an example of a "
"function that takes an iterable is :func:`sum`::"
msgstr ""
"On appelle de tels objets des :term:`itérables <iterable>`, c'est-à-dire des "
"objets qui conviennent à des fonctions ou constructions qui s'attendent à "
"quelque chose duquel elles peuvent tirer des éléments, successivement, "
"jusqu'à épuisement. Nous avons vu que l'instruction :keyword:`for` est une "
"de ces constructions, et un exemple de fonction qui prend un itérable en "
"paramètre est :func:`sum` ::"

#: tutorial/controlflow.rst:157
msgid ""
"Later we will see more functions that return iterables and take iterables as "
"arguments.  In chapter :ref:`tut-structures`, we will discuss in more detail "
"about :func:`list`."
msgstr ""
"Plus loin nous voyons d'autres fonctions qui donnent des itérables ou en "
"prennent en paramètre. De plus amples détails sur :func:`list` sont donnés "
"dans :ref:`tut-structures`."

#: tutorial/controlflow.rst:164
msgid ":keyword:`!break` and :keyword:`!continue` Statements"
msgstr "Les instructions :keyword:`!break` et :keyword:`!continue`"

#: tutorial/controlflow.rst:166
msgid ""
"The :keyword:`break` statement breaks out of the innermost "
"enclosing :keyword:`for` or :keyword:`while` loop::"
msgstr ""
"L'instruction :keyword:`break` interrompt la boucle :keyword:`for` "
"ou :keyword:`while` la plus profonde."

#: tutorial/controlflow.rst:180
msgid ""
"The :keyword:`continue` statement continues with the next iteration of the "
"loop::"
msgstr ""
"L'instruction :keyword:`continue` fait passer la boucle à son itération "
"suivante ::"

#: tutorial/controlflow.rst:202
msgid ":keyword:`!else` Clauses on Loops"
msgstr "La clause :keyword:`!else` au sein des boucles"

#: tutorial/controlflow.rst:204
msgid ""
"In a :keyword:`!for` or :keyword:`!while` loop the :keyword:`!break` "
"statement may be paired with an :keyword:`!else` clause.  If the loop "
"finishes without executing the :keyword:`!break`, the :keyword:`!else` "
"clause executes."
msgstr ""
"Dans une boucle :keyword:`!for` ou :keyword:`!while`, "
"l'instruction :keyword:`!break` peut être couplée à la clause :keyword:`!"
"else`. Si la boucle finit sans exécuter le :keyword:`!break`, alors la "
"clause :keyword:`!else` s'exécute."

#: tutorial/controlflow.rst:208
msgid ""
"In a :keyword:`for` loop, the :keyword:`!else` clause is executed after the "
"loop finishes its final iteration, that is, if no break occurred."
msgstr ""
"Dans une boucle :keyword:`for`, la clause :keyword:`!else` s'exécute après "
"l'exécution de la dernière itération, c'est-à-dire uniquement si la boucle "
"n'a pas été interrompue."

#: tutorial/controlflow.rst:211
msgid ""
"In a :keyword:`while` loop, it's executed after the loop's condition becomes "
"false."
msgstr ""
"Dans une boucle :keyword:`while`, celle-ci est exécutée lorsque la condition "
"devient fausse."

#: tutorial/controlflow.rst:213
msgid ""
"In either kind of loop, the :keyword:`!else` clause is **not** executed if "
"the loop was terminated by a :keyword:`break`.  Of course, other ways of "
"ending the loop early, such as a :keyword:`return` or a raised exception, "
"will also skip execution of the :keyword:`else` clause."
msgstr ""
"Dans les deux types de boucles, la clause :keyword:`!else` n'est **pas** "
"exécutée si la boucle a été interrompue par un :keyword:`break`. Bien sûr, "
"d'autres façons de terminer une boucle de manière prématurée, comme "
"avec :keyword:`return` ou le déclenchement d'une exception, vont aussi "
"ignorer l'exécution de la clause :keyword:`else`."

#: tutorial/controlflow.rst:218
msgid ""
"This is exemplified in the following :keyword:`!for` loop, which searches "
"for prime numbers::"
msgstr ""
"Un exemple est donné dans la boucle :keyword:`!for` ci-dessous, qui cherche "
"des nombres premiers ::"

#: tutorial/controlflow.rst:239
msgid ""
"(Yes, this is the correct code.  Look closely: the ``else`` clause belongs "
"to the ``for`` loop, **not** the ``if`` statement.)"
msgstr ""
"(Oui, ce code est correct. Regardez attentivement : la clause ``else`` est "
"rattachée à la boucle ``for``, et **non** à l'instruction ``if``.)"

#: tutorial/controlflow.rst:242
msgid ""
"One way to think of the else clause is to imagine it paired with the ``if`` "
"inside the loop.  As the loop executes, it will run a sequence like if/if/if/"
"else. The ``if`` is inside the loop, encountered a number of times. If the "
"condition is ever true, a ``break`` will happen. If the condition is never "
"true, the ``else`` clause outside the loop will execute."
msgstr ""
"Une façon de voir la clause ``else`` est de l'imaginer couplée à ``if`` dans "
"une boucle. Lorsque la boucle s'exécute, une séquence similaire à ``if/if/if/"
"else`` est exécutée. Le ``if`` étant dans la boucle il est exécuté un "
"certain nombre de fois. Si sa condition est vraie, un ``break`` est "
"déclenché. Si la condition n'est jamais vraie, la clause ``else`` en dehors "
"de la boucle est exécutée."

#: tutorial/controlflow.rst:248
msgid ""
"When used with a loop, the ``else`` clause has more in common with the "
"``else`` clause of a :keyword:`try` statement than it does with that of "
"``if`` statements: a ``try`` statement's ``else`` clause runs when no "
"exception occurs, and a loop's ``else`` clause runs when no ``break`` "
"occurs. For more on the ``try`` statement and exceptions, see :ref:`tut-"
"handling`."
msgstr ""
"Lorsqu'elle utilisée dans une boucle, la clause ``else`` est donc plus "
"proche de celle associée à une instruction :keyword:`try` que de celle "
"associée à une instruction ``if`` : la clause ``else`` d'une instruction "
"``try`` s'exécute lorsqu'aucune exception n'est déclenchée, et celle d'une "
"boucle lorsqu'aucun ``break`` n'intervient. Pour plus d'informations sur "
"l'instruction ``try`` et le traitement des exceptions, consultez la "
"section :ref:`tut-handling`."

#: tutorial/controlflow.rst:258
msgid ":keyword:`!pass` Statements"
msgstr "L'instruction :keyword:`!pass`"

#: tutorial/controlflow.rst:260
msgid ""
"The :keyword:`pass` statement does nothing. It can be used when a statement "
"is required syntactically but the program requires no action. For example::"
msgstr ""
"L'instruction :keyword:`pass` ne fait rien. Elle peut être utilisée "
"lorsqu'une instruction est nécessaire pour fournir une syntaxe correcte, "
"mais qu'aucune action ne doit être effectuée. Par exemple ::"

#: tutorial/controlflow.rst:267
msgid "This is commonly used for creating minimal classes::"
msgstr ""
"On utilise couramment cette instruction pour créer des classes minimales ::"

#: tutorial/controlflow.rst:273
msgid ""
"Another place :keyword:`pass` can be used is as a place-holder for a "
"function or conditional body when you are working on new code, allowing you "
"to keep thinking at a more abstract level.  The :keyword:`!pass` is silently "
"ignored::"
msgstr ""
"Un autre cas d'utilisation du :keyword:`pass` est de réserver un espace en "
"phase de développement pour une fonction ou un traitement conditionnel, vous "
"permettant ainsi de construire votre code à un niveau plus abstrait. "
"L'instruction :keyword:`!pass` est alors ignorée silencieusement ::"

#: tutorial/controlflow.rst:281
msgid ""
"For this last case, many people use the ellipsis literal :code:`...` instead "
"of :code:`pass`. This use has no special meaning to Python, and is not part "
"of the language definition (you could use any constant expression here), "
"but :code:`...` is used conventionally as a placeholder body as well. "
"See :ref:`bltin-ellipsis-object`."
msgstr ""

#: tutorial/controlflow.rst:291
msgid ":keyword:`!match` Statements"
msgstr "L'instruction :keyword:`!match`"

#: tutorial/controlflow.rst:293
#, fuzzy
msgid ""
"A :keyword:`match` statement takes an expression and compares its value to "
"successive patterns given as one or more case blocks.  This is superficially "
"similar to a switch statement in C, Java or JavaScript (and many other "
"languages), but it's more similar to pattern matching in languages like Rust "
"or Haskell. Only the first pattern that matches gets executed and it can "
"also extract components (sequence elements or object attributes) from the "
"value into variables. If no case matches, none of the branches is executed."
msgstr ""
"L'instruction :keyword:`match` confronte la valeur d'une expression à "
"plusieurs filtres successifs donnés par les instructions ``case``. "
"L’instruction ``match`` peut faire penser au ``switch`` que l'on trouve dans "
"les langages C, Java, JavaScript et autres, mais elle ressemble plus au "
"filtrage par motif des langages Rust et Haskell. Seul le premier filtre qui "
"correspond est exécuté et elle permet aussi d'extraire dans des variables "
"des composantes de la valeur, comme les éléments d'une séquence ou les "
"attributs d'un objet."

#: tutorial/controlflow.rst:302
msgid ""
"The simplest form compares a subject value against one or more literals::"
msgstr ""
"Dans sa plus simple expression, une instruction ``match`` compare une valeur "
"à des littéraux ::"

#: tutorial/controlflow.rst:315
#, fuzzy
msgid ""
"Note the last block: the \"variable name\" ``_`` acts as a *wildcard* and "
"never fails to match."
msgstr ""
"Remarquez l'emploi du signe souligné ``_`` dans le dernier bloc, qui est "
"normalement un nom de variable spécial. Ici, c'est un filtre *attrape-tout*, "
"c'est-à-dire qu'il accepte toutes les valeurs. Si aucun des filtres dans les "
"``case`` ne fonctionne, aucune des branches indentées sous les ``case`` "
"n'est exécutée."

#: tutorial/controlflow.rst:318
msgid ""
"You can combine several literals in a single pattern using ``|`` (\"or\")::"
msgstr ""
"On peut combiner plusieurs littéraux en un seul filtre avec le signe ``|``, "
"qui se lit OU ::"

#: tutorial/controlflow.rst:323
msgid ""
"Patterns can look like unpacking assignments, and can be used to bind "
"variables::"
msgstr ""
"Les filtres peuvent prendre une forme similaire aux affectations multiples, "
"et provoquer la liaison de variables ::"

#: tutorial/controlflow.rst:339
msgid ""
"Study that one carefully!  The first pattern has two literals, and can be "
"thought of as an extension of the literal pattern shown above.  But the next "
"two patterns combine a literal and a variable, and the variable *binds* a "
"value from the subject (``point``).  The fourth pattern captures two values, "
"which makes it conceptually similar to the unpacking assignment ``(x, y) = "
"point``."
msgstr ""
"Observez bien cet exemple ! Le premier filtre contient simplement deux "
"littéraux. C'est une sorte d'extension des filtres littéraux. Mais les deux "
"filtres suivants mélangent un littéral et un nom de variable. Si un tel "
"filtre réussit, il provoque l'affectation à la variable. Le quatrième filtre "
"est constitué de deux variables, ce qui le fait beaucoup ressembler à "
"l'affectation multiple ``(x, y) = point``."

#: tutorial/controlflow.rst:346
msgid ""
"If you are using classes to structure your data you can use the class name "
"followed by an argument list resembling a constructor, but with the ability "
"to capture attributes into variables::"
msgstr ""
"Si vous structurez vos données par l'utilisation de classes, vous pouvez "
"former des filtres avec le nom de la classe suivi d'une liste d'arguments. "
"Ces filtres sont semblables à l'appel d'un constructeur, et permettent de "
"capturer des attributs ::"

#: tutorial/controlflow.rst:368
msgid ""
"You can use positional parameters with some builtin classes that provide an "
"ordering for their attributes (e.g. dataclasses). You can also define a "
"specific position for attributes in patterns by setting the "
"``__match_args__`` special attribute in your classes. If it's set to (\"x\", "
"\"y\"), the following patterns are all equivalent (and all bind the ``y`` "
"attribute to the ``var`` variable)::"
msgstr ""
"Un certain nombre de classes natives, notamment les classes de données, "
"prennent en charge le filtrage par arguments positionnels en définissant un "
"ordre des attributs. Vous pouvez ajouter cette possibilité à vos propres "
"classes en y définissant l'attribut spécial ``__match_args__``. Par exemple, "
"le mettre à ``(\"x\", \"y\")`` rend tous les filtres ci-dessous équivalents "
"(en particulier, tous provoquent la liaison de l'attribut ``y`` à la "
"variable ``var``) ::"

#: tutorial/controlflow.rst:379
msgid ""
"A recommended way to read patterns is to look at them as an extended form of "
"what you would put on the left of an assignment, to understand which "
"variables would be set to what. Only the standalone names (like ``var`` "
"above) are assigned to by a match statement. Dotted names (like "
"``foo.bar``), attribute names (the ``x=`` and ``y=`` above) or class names "
"(recognized by the \"(...)\" next to them like ``Point`` above) are never "
"assigned to."
msgstr ""
"Une méthode préconisée pour lire les filtres est de les voir comme une "
"extension de ce que l'on peut placer à gauche du signe ``=`` dans une "
"affectation. Cela permet de visualiser quelles variables sont liées à quoi. "
"Seuls les noms simples, comme ``var`` ci-dessus, sont des variables "
"susceptibles d'être liées à une valeur. Il n'y a jamais de liaison pour les "
"noms qualifiés (avec un point, comme dans ``truc.machin``), les noms "
"d'attributs (tels que ``x=`` et ``y=`` dans l'exemple précédent) et les noms "
"de classes (identifiés par les parenthèses à leur droite, comme ``Point``)."

#: tutorial/controlflow.rst:386
msgid ""
"Patterns can be arbitrarily nested.  For example, if we have a short list of "
"Points, with ``__match_args__`` added, we could match it like this::"
msgstr ""
"On peut imbriquer les filtres autant que de besoin. Ainsi, on peut lire une "
"courte liste de points, avec ``__match_args__``, comme ceci ::"

#: tutorial/controlflow.rst:407
msgid ""
"We can add an ``if`` clause to a pattern, known as a \"guard\".  If the "
"guard is false, ``match`` goes on to try the next case block.  Note that "
"value capture happens before the guard is evaluated::"
msgstr ""
"Un filtre peut comporter un ``if``, qui introduit ce que l'on appelle une "
"garde. Si le filtre réussit, la garde est alors testée et, si elle s'évalue "
"à une valeur fausse, l'exécution continue au bloc ``case`` suivant. Les "
"variables sont liées avant l'évaluation de la garde, et peuvent être "
"utilisées à l'intérieur ::"

#: tutorial/controlflow.rst:417
msgid "Several other key features of this statement:"
msgstr "Voici d’autres caractéristiques importantes de cette instruction :"

#: tutorial/controlflow.rst:419
msgid ""
"Like unpacking assignments, tuple and list patterns have exactly the same "
"meaning and actually match arbitrary sequences.  An important exception is "
"that they don't match iterators or strings."
msgstr ""
"comme dans les affectations multiples, les filtres de *n*-uplet et de liste "
"sont totalement équivalents et autorisent tous les types de séquences. "
"Exception importante, ils n'autorisent pas les itérateurs ni les chaînes de "
"caractères ;"

#: tutorial/controlflow.rst:423
msgid ""
"Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, "
"*rest)`` work similar to unpacking assignments.  The name after ``*`` may "
"also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items "
"without binding the remaining items."
msgstr ""
"les filtres de séquence peuvent faire intervenir l'affectation étoilée : "
"``[x, y, *reste]`` ou ``(x, y, *reste)`` ont le même sens que dans une "
"affectation avec ``=``. Le nom de variable après l'étoile peut aussi être "
"l'attrape-tout ``_``. Ainsi, ``(x, y, *_)`` est un filtre qui reconnaît les "
"séquences à deux éléments ou plus, en capturant les deux premiers et en "
"ignorant le reste ;"

#: tutorial/controlflow.rst:428
msgid ""
"Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` captures the "
"``\"bandwidth\"`` and ``\"latency\"`` values from a dictionary.  Unlike "
"sequence patterns, extra keys are ignored.  An unpacking like ``**rest`` is "
"also supported.  (But ``**_`` would be redundant, so it is not allowed.)"
msgstr ""
"Il existe des filtres d'association. Par exemple, le filtre "
"``{\"bande_passante\": b, \"latence\": l}`` extrait les valeurs des clés "
"``\"bande_passante\"`` et ``\"latence\"`` dans un dictionnaire. "
"Contrairement aux filtres de séquence, les clés absentes du filtre sont "
"ignorées. L'affectation double-étoilée (``**reste``) fonctionne aussi "
"(cependant, ``**_`` serait redondant et n'est donc pas permis) ;"

#: tutorial/controlflow.rst:433
msgid "Subpatterns may be captured using the ``as`` keyword::"
msgstr ""
"on peut capturer la valeur d'une partie d'un filtre avec le mot-clé ``as``, "
"par exemple ::"

#: tutorial/controlflow.rst:437
msgid ""
"will capture the second element of the input as ``p2`` (as long as the input "
"is a sequence of two points)"
msgstr ""
"Ce filtre, lorsqu'il est comparé à une séquence de deux points, réussit et "
"capture le second dans la variable ``p2`` ;"

#: tutorial/controlflow.rst:440
msgid ""
"Most literals are compared by equality, however the singletons ``True``, "
"``False`` and ``None`` are compared by identity."
msgstr ""
"la plupart des littéraux sont comparés par égalité. Néanmoins, les "
"singletons ``True``, ``False`` et ``None`` sont comparés par identité ;"

#: tutorial/controlflow.rst:443
msgid ""
"Patterns may use named constants.  These must be dotted names to prevent "
"them from being interpreted as capture variable::"
msgstr ""
"les filtres peuvent contenir des noms qui se réfèrent à des constantes. Ces "
"noms doivent impérativement être qualifiés (contenir un point) pour ne pas "
"être interprétés comme des variables de capture ::"

#: tutorial/controlflow.rst:462
msgid ""
"For a more detailed explanation and additional examples, you can look "
"into :pep:`636` which is written in a tutorial format."
msgstr ""
"Pour plus d'explications et d'exemples, lire la :pep:`636` (en anglais), qui "
"est écrite sous forme de tutoriel."

#: tutorial/controlflow.rst:468
msgid "Defining Functions"
msgstr "Définir des fonctions"

#: tutorial/controlflow.rst:470
msgid ""
"We can create a function that writes the Fibonacci series to an arbitrary "
"boundary::"
msgstr ""
"On peut créer une fonction qui écrit la suite de Fibonacci jusqu'à une "
"limite imposée ::"

#: tutorial/controlflow.rst:490
msgid ""
"The keyword :keyword:`def` introduces a function *definition*.  It must be "
"followed by the function name and the parenthesized list of formal "
"parameters. The statements that form the body of the function start at the "
"next line, and must be indented."
msgstr ""
"Le mot-clé :keyword:`def` introduit une *définition* de fonction. Il doit "
"être suivi du nom de la fonction et d'une liste, entre parenthèses, de ses "
"paramètres. L'instruction qui constitue le corps de la fonction débute à la "
"ligne suivante et doit être indentée."

#: tutorial/controlflow.rst:495
msgid ""
"The first statement of the function body can optionally be a string literal; "
"this string literal is the function's documentation string, "
"or :dfn:`docstring`. (More about docstrings can be found in the "
"section :ref:`tut-docstrings`.) There are tools which use docstrings to "
"automatically produce online or printed documentation, or to let the user "
"interactively browse through code; it's good practice to include docstrings "
"in code that you write, so make a habit of it."
msgstr ""
"La première instruction d'une fonction peut, de façon facultative, être une "
"chaîne de caractères littérale ; cette chaîne de caractères est alors la "
"chaîne de documentation de la fonction, appelée :dfn:`docstring` (consultez "
"la section :ref:`tut-docstrings` pour en savoir plus). Il existe des outils "
"qui utilisent ces chaînes de documentation pour générer automatiquement une "
"documentation en ligne ou imprimée, ou pour permettre à l'utilisateur de "
"naviguer de façon interactive dans le code ; prenez-en l'habitude, c'est une "
"bonne pratique que de documenter le code que vous écrivez."

#: tutorial/controlflow.rst:502
msgid ""
"The *execution* of a function introduces a new symbol table used for the "
"local variables of the function.  More precisely, all variable assignments "
"in a function store the value in the local symbol table; whereas variable "
"references first look in the local symbol table, then in the local symbol "
"tables of enclosing functions, then in the global symbol table, and finally "
"in the table of built-in names. Thus, global variables and variables of "
"enclosing functions cannot be directly assigned a value within a function "
"(unless, for global variables, named in a :keyword:`global` statement, or, "
"for variables of enclosing functions, named in a :keyword:`nonlocal` "
"statement), although they may be referenced."
msgstr ""
"*L'exécution* d'une fonction introduit un nouvel espace de nommage (aussi "
"appelé table des symboles) utilisé par les variables locales de la fonction. "
"Plus précisément, toutes les affectations de variables effectuées au sein "
"d'une fonction stockent les valeurs dans l'espace de nommage local à la "
"fonction ; en revanche, les références de variables sont recherchées dans "
"l'espace de nommage local, puis dans les espaces de nommage des fonctions "
"englobantes, puis dans l'espace de nommage global et finalement dans "
"l'espace de nommage des primitives. Par conséquent, bien qu'on puisse y "
"faire référence, il est impossible d'affecter une valeur à une variable "
"globale ou à une variable d'une fonction englobante (sauf pour les variables "
"globales désignées dans une instruction :keyword:`global` et, pour les "
"variables des fonctions englobantes, désignées dans une "
"instruction :keyword:`nonlocal`)."

#: tutorial/controlflow.rst:513
msgid ""
"The actual parameters (arguments) to a function call are introduced in the "
"local symbol table of the called function when it is called; thus, arguments "
"are passed using *call by value* (where the *value* is always an object "
"*reference*, not the value of the object). [#]_ When a function calls "
"another function, or calls itself recursively, a new local symbol table is "
"created for that call."
msgstr ""
"Les paramètres effectifs (arguments) d'une fonction sont introduits dans "
"l'espace de nommage local de la fonction appelée, au moment où elle est "
"appelée ; par conséquent, les passages de paramètres se font *par valeur*, "
"la *valeur* étant toujours une *référence* à un objet et non la valeur de "
"l'objet lui-même [#]_. Lorsqu'une fonction appelle une autre fonction, ou "
"s'appelle elle-même par récursion, un nouvel espace de nommage local est "
"créé pour cet appel."

#: tutorial/controlflow.rst:520
msgid ""
"A function definition associates the function name with the function object "
"in the current symbol table.  The interpreter recognizes the object pointed "
"to by that name as a user-defined function.  Other names can also point to "
"that same function object and can also be used to access the function::"
msgstr ""
"Une définition de fonction associe un nom de fonction à un objet fonction "
"dans l'espace de nommage actuel. Pour l'interpréteur, l'objet référencé par "
"ce nom est une fonction définie par l'utilisateur. Plusieurs noms peuvent "
"faire référence à une même fonction, ils peuvent alors tous être utilisés "
"pour appeler la fonction ::"

#: tutorial/controlflow.rst:531
msgid ""
"Coming from other languages, you might object that ``fib`` is not a function "
"but a procedure since it doesn't return a value.  In fact, even functions "
"without a :keyword:`return` statement do return a value, albeit a rather "
"boring one.  This value is called ``None`` (it's a built-in name).  Writing "
"the value ``None`` is normally suppressed by the interpreter if it would be "
"the only value written. You can see it if you really want to "
"using :func:`print`::"
msgstr ""
"Si vous venez d'autres langages, vous pouvez penser que ``fib`` n'est pas "
"une fonction mais une procédure, puisqu'elle ne renvoie pas de résultat. En "
"fait, même les fonctions sans instruction :keyword:`return` renvoient une "
"valeur, quoique ennuyeuse. Cette valeur est appelée ``None`` (c'est le nom "
"d'une primitive). Écrire la valeur ``None`` est normalement supprimé par "
"l'interpréteur lorsqu'il s'agit de la seule valeur qui doit être écrite. "
"Vous pouvez le constater, si vous y tenez vraiment, en "
"utilisant :func:`print` ::"

#: tutorial/controlflow.rst:542
msgid ""
"It is simple to write a function that returns a list of the numbers of the "
"Fibonacci series, instead of printing it::"
msgstr ""
"Il est facile d'écrire une fonction qui renvoie une liste de la série de "
"Fibonacci au lieu de l'afficher ::"

#: tutorial/controlflow.rst:558
msgid "This example, as usual, demonstrates some new Python features:"
msgstr ""
"Cet exemple, comme d'habitude, illustre de nouvelles fonctionnalités de "
"Python :"

# énumération --> pas de majuscule et point-virgule en fin de proposition.
#: tutorial/controlflow.rst:560
msgid ""
"The :keyword:`return` statement returns with a value from a "
"function. :keyword:`!return` without an expression argument returns "
"``None``. Falling off the end of a function also returns ``None``."
msgstr ""
"l'instruction :keyword:`return` provoque la sortie de la fonction en "
"renvoyant une valeur. :keyword:`!return` sans expression en paramètre "
"renvoie ``None``. Arriver à la fin d'une fonction renvoie également "
"``None`` ;"

# fin d'énumération --> pas de majuscule et point final.
#: tutorial/controlflow.rst:564
#, fuzzy
msgid ""
"The statement ``result.append(a)`` calls a *method* of the list object "
"``result``.  A method is a function that 'belongs' to an object and is named "
"``obj.methodname``, where ``obj`` is some object (this may be an "
"expression), and ``methodname`` is the name of a method that is defined by "
"the object's type. Different types define different methods.  Methods of "
"different types may have the same name without causing ambiguity.  (It is "
"possible to define your own object types and methods, using *classes*, "
"see :ref:`tut-classes`) The method :meth:`~list.append` shown in the example "
"is defined for list objects; it adds a new element at the end of the list.  "
"In this example it is equivalent to ``result = result + [a]``, but more "
"efficient."
msgstr ""
"l'instruction ``result.append(a)`` appelle une *méthode* de l'objet "
"``result`` qui est une liste. Une méthode est une fonction qui "
"« appartient » à un objet et qui est nommée ``obj.methodname``, où ``obj`` "
"est un objet (il peut également s'agir d'une expression) et ``methodname`` "
"est le nom d'une méthode que le type de l'objet définit. Différents types "
"définissent différentes méthodes. Des méthodes de différents types peuvent "
"porter le même nom sans qu'il n'y ait d'ambigüité (vous pouvez définir vos "
"propres types d'objets et leurs méthodes en utilisant des *classes*, "
"voir :ref:`tut-classes`). La méthode :meth:`!append` utilisée dans cet "
"exemple est définie pour les listes ; elle ajoute un nouvel élément à la fin "
"de la liste. Dans cet exemple, elle est l'équivalent de ``result = result + "
"[a]``, en plus efficace."

#: tutorial/controlflow.rst:579
msgid "More on Defining Functions"
msgstr "Davantage sur la définition des fonctions"

#: tutorial/controlflow.rst:581
msgid ""
"It is also possible to define functions with a variable number of arguments. "
"There are three forms, which can be combined."
msgstr ""
"Il est également possible de définir des fonctions avec un nombre variable "
"d'arguments. Trois syntaxes peuvent être utilisées, éventuellement combinées."

#: tutorial/controlflow.rst:588
msgid "Default Argument Values"
msgstr "Valeur par défaut des arguments"

#: tutorial/controlflow.rst:590
msgid ""
"The most useful form is to specify a default value for one or more "
"arguments. This creates a function that can be called with fewer arguments "
"than it is defined to allow.  For example::"
msgstr ""
"La forme la plus utile consiste à indiquer une valeur par défaut pour "
"certains arguments. Ceci crée une fonction qui peut être appelée avec moins "
"d'arguments que ceux présents dans sa définition. Par exemple ::"

#: tutorial/controlflow.rst:606
msgid "This function can be called in several ways:"
msgstr "Cette fonction peut être appelée de plusieurs façons :"

# énumération --> pas de majuscule
#: tutorial/controlflow.rst:608
msgid ""
"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"
msgstr ""
"en ne fournissant que les arguments obligatoires : ``ask_ok('Do you really "
"want to quit?')`` ;"

# énumération --> pas de majuscule et point-virgule en fin de proposition.
#: tutorial/controlflow.rst:610
msgid ""
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
"2)``"
msgstr ""
"en fournissant une partie des arguments facultatifs : ``ask_ok('OK to "
"overwrite the file?', 2)`` ;"

# fin d'énumération --> pas de majuscule et point final.
#: tutorial/controlflow.rst:612
msgid ""
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "
"on, only yes or no!')``"
msgstr ""
"en fournissant tous les arguments : ``ask_ok('OK to overwrite the file?', 2, "
"'Come on, only yes or no!')``."

#: tutorial/controlflow.rst:615
msgid ""
"This example also introduces the :keyword:`in` keyword. This tests whether "
"or not a sequence contains a certain value."
msgstr ""
"Cet exemple présente également le mot-clé :keyword:`in`. Celui-ci permet de "
"tester si une séquence contient une certaine valeur."

#: tutorial/controlflow.rst:618
msgid ""
"The default values are evaluated at the point of function definition in the "
"*defining* scope, so that ::"
msgstr ""
"Les valeurs par défaut sont évaluées lors de la définition de la fonction "
"dans la portée de la *définition*, de telle sorte que ::"

#: tutorial/controlflow.rst:629
msgid "will print ``5``."
msgstr "affiche ``5``."

#: tutorial/controlflow.rst:631
msgid ""
"**Important warning:**  The default value is evaluated only once. This makes "
"a difference when the default is a mutable object such as a list, "
"dictionary, or instances of most classes.  For example, the following "
"function accumulates the arguments passed to it on subsequent calls::"
msgstr ""
"**Avertissement important :** la valeur par défaut n'est évaluée qu'une "
"seule fois. Ceci fait une différence lorsque cette valeur par défaut est un "
"objet mutable tel qu'une liste, un dictionnaire ou des instances de la "
"plupart des classes. Par exemple, la fonction suivante accumule les "
"arguments qui lui sont passés au fil des appels successifs ::"

# pas de majuscule : ok
#: tutorial/controlflow.rst:644
msgid "This will print ::"
msgstr "affiche ::"

#: tutorial/controlflow.rst:650
msgid ""
"If you don't want the default to be shared between subsequent calls, you can "
"write the function like this instead::"
msgstr ""
"Si vous ne voulez pas que cette valeur par défaut soit partagée entre des "
"appels successifs, vous pouvez écrire la fonction de cette façon ::"

#: tutorial/controlflow.rst:663
msgid "Keyword Arguments"
msgstr "Les arguments nommés"

#: tutorial/controlflow.rst:665
msgid ""
"Functions can also be called using :term:`keyword arguments <keyword "
"argument>` of the form ``kwarg=value``.  For instance, the following "
"function::"
msgstr ""
"Les fonctions peuvent également être appelées en utilisant "
"des :term:`arguments nommés <keyword argument>` sous la forme "
"``kwarg=value``. Par exemple, la fonction suivante ::"

#: tutorial/controlflow.rst:674
msgid ""
"accepts one required argument (``voltage``) and three optional arguments "
"(``state``, ``action``, and ``type``).  This function can be called in any "
"of the following ways::"
msgstr ""
"accepte un argument obligatoire (``voltage``) et trois arguments facultatifs "
"(``state``, ``action`` et ``type``). Cette fonction peut être appelée de "
"n'importe laquelle des façons suivantes ::"

#: tutorial/controlflow.rst:685
msgid "but all the following calls would be invalid::"
msgstr "mais tous les appels qui suivent sont incorrects ::"

#: tutorial/controlflow.rst:692
msgid ""
"In a function call, keyword arguments must follow positional arguments. All "
"the keyword arguments passed must match one of the arguments accepted by the "
"function (e.g. ``actor`` is not a valid argument for the ``parrot`` "
"function), and their order is not important.  This also includes non-"
"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument "
"may receive a value more than once. Here's an example that fails due to this "
"restriction::"
msgstr ""
"Dans un appel de fonction, les arguments nommés doivent suivre les arguments "
"positionnés. Tous les arguments nommés doivent correspondre à l'un des "
"arguments acceptés par la fonction (par exemple, ``actor`` n'est pas un "
"argument accepté par la fonction ``parrot``), mais leur ordre n'est pas "
"important. Ceci inclut également les arguments obligatoires "
"(``parrot(voltage=1000)`` est également correct). Aucun argument ne peut "
"recevoir une valeur plus d'une fois, comme l'illustre cet exemple incorrect "
"du fait de cette restriction ::"

#: tutorial/controlflow.rst:708
msgid ""
"When a final formal parameter of the form ``**name`` is present, it receives "
"a dictionary (see :ref:`typesmapping`) containing all keyword arguments "
"except for those corresponding to a formal parameter.  This may be combined "
"with a formal parameter of the form ``*name`` (described in the next "
"subsection) which receives a :ref:`tuple <tut-tuples>` containing the "
"positional arguments beyond the formal parameter list.  (``*name`` must "
"occur before ``**name``.) For example, if we define a function like this::"
msgstr ""
"Quand un dernier paramètre formel est présent sous la forme ``**name``, il "
"reçoit un dictionnaire (voir :ref:`typesmapping`) contenant tous les "
"arguments nommés à l'exception de ceux correspondant à un paramètre formel. "
"Ceci peut être combiné à un paramètre formel sous la forme ``*name`` (décrit "
"dans la section suivante) qui lui reçoit un :ref:`n-uplet <tut-tuples>` "
"contenant les arguments positionnés au-delà de la liste des paramètres "
"formels (``*name`` doit être présent avant ``**name``). Par exemple, si vous "
"définissez une fonction comme ceci ::"

#: tutorial/controlflow.rst:725
msgid "It could be called like this::"
msgstr "Elle pourrait être appelée comme ceci ::"

#: tutorial/controlflow.rst:733
msgid "and of course it would print:"
msgstr "et, bien sûr, elle affiche :"

#: tutorial/controlflow.rst:746
msgid ""
"Note that the order in which the keyword arguments are printed is guaranteed "
"to match the order in which they were provided in the function call."
msgstr ""
"Notez que Python garantit que l'ordre d'affichage des arguments est le même "
"que l'ordre dans lesquels ils sont fournis lors de l'appel à la fonction."

#: tutorial/controlflow.rst:750
msgid "Special parameters"
msgstr "Paramètres spéciaux"

#: tutorial/controlflow.rst:752
msgid ""
"By default, arguments may be passed to a Python function either by position "
"or explicitly by keyword. For readability and performance, it makes sense to "
"restrict the way arguments can be passed so that a developer need only look "
"at the function definition to determine if items are passed by position, by "
"position or keyword, or by keyword."
msgstr ""
"Par défaut, les arguments peuvent être passés à une fonction Python par "
"position, ou explicitement en les nommant. Pour la lisibilité et la "
"performance, il est logique de restreindre la façon dont les arguments "
"peuvent être transmis afin qu'un développeur n'ait qu'à regarder la "
"définition de la fonction pour déterminer si les éléments sont transmis par "
"position seule, par position ou nommé, ou seulement nommé."

#: tutorial/controlflow.rst:758
msgid "A function definition may look like:"
msgstr "Voici à quoi ressemble une définition de fonction :"

#: tutorial/controlflow.rst:769
msgid ""
"where ``/`` and ``*`` are optional. If used, these symbols indicate the kind "
"of parameter by how the arguments may be passed to the function: positional-"
"only, positional-or-keyword, and keyword-only. Keyword parameters are also "
"referred to as named parameters."
msgstr ""
"où ``/`` et ``*`` sont facultatifs. S'ils sont utilisés, ces symboles "
"indiquent par quel type de paramètre un argument peut être transmis à la "
"fonction : position seule, position ou nommé, et seulement nommé. Les "
"paramètres par mot-clé sont aussi appelés paramètres nommés."

#: tutorial/controlflow.rst:776
msgid "Positional-or-Keyword Arguments"
msgstr "Les arguments positionnels-ou-nommés"

#: tutorial/controlflow.rst:778
msgid ""
"If ``/`` and ``*`` are not present in the function definition, arguments may "
"be passed to a function by position or by keyword."
msgstr ""
"Si ``/`` et ``*`` ne sont pas présents dans la définition de fonction, les "
"arguments peuvent être passés à une fonction par position ou par nommés."

#: tutorial/controlflow.rst:783
msgid "Positional-Only Parameters"
msgstr "Paramètres positionnels uniquement"

#: tutorial/controlflow.rst:785
msgid ""
"Looking at this in a bit more detail, it is possible to mark certain "
"parameters as *positional-only*. If *positional-only*, the parameters' order "
"matters, and the parameters cannot be passed by keyword. Positional-only "
"parameters are placed before a ``/`` (forward-slash). The ``/`` is used to "
"logically separate the positional-only parameters from the rest of the "
"parameters. If there is no ``/`` in the function definition, there are no "
"positional-only parameters."
msgstr ""
"En y regardant de plus près, il est possible de marquer certains paramètres "
"comme *positionnels uniquement*. S'ils sont marqués comme *positionnels "
"uniquement*, l'ordre des paramètres est important, et les paramètres ne "
"peuvent pas être transmis en tant que « arguments nommés ». Les paramètres "
"« positionnels uniquement » sont placés avant un ``/``. Le ``/`` est utilisé "
"pour séparer logiquement les paramètres « positionnels uniquement » du reste "
"des paramètres. S'il n'y a pas de ``/`` dans la définition de fonction, il "
"n'y a pas de paramètres « positionnels uniquement »."

#: tutorial/controlflow.rst:793
msgid ""
"Parameters following the ``/`` may be *positional-or-keyword* or *keyword-"
"only*."
msgstr ""
"Les paramètres qui suivent le ``/`` peuvent être *positionnels-ou-nommés* ou "
"*nommés-uniquement*."

#: tutorial/controlflow.rst:797
msgid "Keyword-Only Arguments"
msgstr "Arguments nommés uniquement"

#: tutorial/controlflow.rst:799