# 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-03-22 22:57+0100\n"

"PO-Revision-Date: 2022-10-18 16:15+0200\n"

"Last-Translator: Jean Abou Samra <jean@abou-samra.fr>\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.0\n"

#: reference/expressions.rst:6

msgid "Expressions"

msgstr "Expressions"

#: reference/expressions.rst:10

msgid ""

"This chapter explains the meaning of the elements of expressions in Python."

msgstr ""

"Ce chapitre explique la signification des éléments des expressions en Python."

#: reference/expressions.rst:12

msgid ""

"**Syntax Notes:** In this and the following chapters, extended BNF notation "

"will be used to describe syntax, not lexical analysis. When (one "

"alternative of) a syntax rule has the form"

msgstr ""

"**Notes sur la syntaxe :** dans ce chapitre et le suivant, nous utilisons la "

"notation BNF étendue pour décrire la syntaxe, pas l'analyse lexicale. Quand "

"une règle de syntaxe est de la forme"

#: reference/expressions.rst:19

msgid ""

"and no semantics are given, the semantics of this form of ``name`` are the "

"same as for ``othername``."

msgstr ""

"et qu'aucune sémantique n'est donnée, la sémantique de ``name`` est la même "

"que celle de ``othername``."

#: reference/expressions.rst:26

msgid "Arithmetic conversions"

msgstr "Conversions arithmétiques"

#: reference/expressions.rst:30

msgid ""

"When a description of an arithmetic operator below uses the phrase \"the "

"numeric arguments are converted to a common type\", this means that the "

"operator implementation for built-in types works as follows:"

msgstr ""

"Quand la description d'un opérateur arithmétique ci-dessous utilise la "

"phrase « les arguments numériques sont convertis vers un type commun », cela "

"signifie que l'implémentation de l'opérateur fonctionne de la manière "

"suivante pour les types natifs :"

#: reference/expressions.rst:34

msgid ""

"If either argument is a complex number, the other is converted to complex;"

msgstr ""

"Si l'un des deux arguments est du type nombre complexe, l'autre est converti "

"en nombre complexe ;"

#: reference/expressions.rst:36

msgid ""

"otherwise, if either argument is a floating point number, the other is "

"converted to floating point;"

msgstr ""

"sinon, si l'un des arguments est un nombre à virgule flottante, l'autre est "

"converti en nombre à virgule flottante ;"

#: reference/expressions.rst:39

msgid "otherwise, both must be integers and no conversion is necessary."

msgstr ""

"sinon, les deux doivent être des entiers et aucune conversion n'est "

"nécessaire."

#: reference/expressions.rst:41

msgid ""

"Some additional rules apply for certain operators (e.g., a string as a left "

"argument to the '%' operator). Extensions must define their own conversion "

"behavior."

msgstr ""

"Des règles supplémentaires s'appliquent pour certains opérateurs (par "

"exemple, une chaîne comme opérande de gauche pour l'opérateur ``%``). Les "

"extensions doivent définir leurs propres règles de conversion."

#: reference/expressions.rst:49

msgid "Atoms"

msgstr "Atomes"

#: reference/expressions.rst:53

msgid ""

"Atoms are the most basic elements of expressions. The simplest atoms are "

"identifiers or literals. Forms enclosed in parentheses, brackets or braces "

"are also categorized syntactically as atoms. The syntax for atoms is:"

msgstr ""

"Les atomes sont les éléments de base des expressions. Les atomes les plus "

"simples sont les identifiants et les littéraux. Les expressions entre "

"parenthèses, crochets ou accolades sont aussi classées syntaxiquement comme "

"des atomes. La syntaxe pour les atomes est :"

#: reference/expressions.rst:66

msgid "Identifiers (Names)"

msgstr "Identifiants (noms)"

#: reference/expressions.rst:70

msgid ""

"An identifier occurring as an atom is a name. See section :ref:"

"`identifiers` for lexical definition and section :ref:`naming` for "

"documentation of naming and binding."

msgstr ""

"Un identifiant qui apparaît en tant qu'atome est un nom. Lisez la section :"

"ref:`identifiers` pour la définition lexicale et la section :ref:`naming` "

"pour la documentation sur les noms et les liaisons afférentes."

#: reference/expressions.rst:76

msgid ""

"When the name is bound to an object, evaluation of the atom yields that "

"object. When a name is not bound, an attempt to evaluate it raises a :exc:"

"`NameError` exception."

msgstr ""

"Quand un nom est lié à un objet, l'évaluation de l'atome produit cet objet. "

"Quand le nom n'est pas lié, toute tentative de l'évaluer lève une exception :"

"exc:`NameError`."

#: reference/expressions.rst:86

msgid ""

"**Private name mangling:** When an identifier that textually occurs in a "

"class definition begins with two or more underscore characters and does not "

"end in two or more underscores, it is considered a :dfn:`private name` of "

"that class. Private names are transformed to a longer form before code is "

"generated for them. The transformation inserts the class name, with leading "

"underscores removed and a single underscore inserted, in front of the name. "

"For example, the identifier ``__spam`` occurring in a class named ``Ham`` "

"will be transformed to ``_Ham__spam``. This transformation is independent "

"of the syntactical context in which the identifier is used. If the "

"transformed name is extremely long (longer than 255 characters), "

"implementation defined truncation may happen. If the class name consists "

"only of underscores, no transformation is done."

msgstr ""

"**Transformation des noms privés :** lorsqu'un identificateur qui apparaît "

"textuellement dans la définition d'une classe commence par deux (ou plus) "

"caractères de soulignement et ne se termine pas par deux (ou plus) "

"caractères de soulignement, il est considéré comme un :dfn:`nom privé "

"<private name>` de cette classe. Les noms privés sont transformés en une "

"forme plus longue avant que le code ne soit généré pour eux. La "

"transformation insère le nom de la classe, avec les soulignés enlevés et un "

"seul souligné inséré devant le nom. Par exemple, l'identificateur ``__spam`` "

"apparaissant dans une classe nommée ``Ham`` est transformé en "

"``_Ham__spam``. Cette transformation est indépendante du contexte syntaxique "

"dans lequel l'identificateur est utilisé. Si le nom transformé est "

"extrêmement long (plus de 255 caractères), l'implémentation peut le "

"tronquer. Si le nom de la classe est constitué uniquement de traits de "

"soulignement, aucune transformation n'est effectuée."

#: reference/expressions.rst:102

msgid "Literals"

msgstr "Littéraux"

#: reference/expressions.rst:106

msgid "Python supports string and bytes literals and various numeric literals:"

msgstr ""

"Python gère les littéraux de chaînes de caractères, de chaînes d'octets et "

"de plusieurs autres types numériques :"

#: reference/expressions.rst:112

msgid ""

"Evaluation of a literal yields an object of the given type (string, bytes, "

"integer, floating point number, complex number) with the given value. The "

"value may be approximated in the case of floating point and imaginary "

"(complex) literals. See section :ref:`literals` for details."

msgstr ""

"L'évaluation d'un littéral produit un objet du type donné (chaîne de "

"caractères, chaîne d'octets, entier, nombre à virgule flottante, nombre "

"complexe) avec la valeur donnée. La valeur peut être approximée dans le cas "

"des nombres à virgule flottante et des nombres imaginaires (complexes). "

"Reportez-vous à la section :ref:`literals` pour les détails."

#: reference/expressions.rst:121

msgid ""

"All literals correspond to immutable data types, and hence the object's "

"identity is less important than its value. Multiple evaluations of literals "

"with the same value (either the same occurrence in the program text or a "

"different occurrence) may obtain the same object or a different object with "

"the same value."

msgstr ""

"Tous les littéraux sont de types immuables et donc l'identifiant de l'objet "

"est moins important que sa valeur. Des évaluations multiples de littéraux "

"avec la même valeur (soit la même occurrence dans le texte du programme, "

"soit une autre occurrence) résultent dans le même objet ou un objet "

"différent avec la même valeur."

#: reference/expressions.rst:131

msgid "Parenthesized forms"

msgstr "Formes parenthésées"

#: reference/expressions.rst:137

msgid ""

"A parenthesized form is an optional expression list enclosed in parentheses:"

msgstr ""

"Une forme parenthésée est une liste d'expressions (cette liste est en fait "

"optionnelle) placée à l'intérieur de parenthèses :"

#: reference/expressions.rst:142

msgid ""

"A parenthesized expression list yields whatever that expression list yields: "

"if the list contains at least one comma, it yields a tuple; otherwise, it "

"yields the single expression that makes up the expression list."

msgstr ""

"Une liste d'expressions entre parenthèses produit ce que la liste de ces "

"expressions produirait : si la liste contient au moins une virgule, elle "

"produit un *n*-uplet (type *n*-uplet) ; sinon, elle produit l'expression "

"elle-même (qui constitue donc elle-même la liste d'expressions)."

#: reference/expressions.rst:148

msgid ""

"An empty pair of parentheses yields an empty tuple object. Since tuples are "

"immutable, the same rules as for literals apply (i.e., two occurrences of "

"the empty tuple may or may not yield the same object)."

msgstr ""

"Une paire de parenthèses vide produit un objet *n*-uplet vide. Comme les n-"

"uplets sont immuables, la même règle que pour les littéraux s'applique "

"(c'est-à-dire que deux occurrences du *n*-uplet vide peuvent, ou pas, "

"produire le même objet)."

#: reference/expressions.rst:156

msgid ""

"Note that tuples are not formed by the parentheses, but rather by use of the "

"comma operator. The exception is the empty tuple, for which parentheses "

"*are* required --- allowing unparenthesized \"nothing\" in expressions would "

"cause ambiguities and allow common typos to pass uncaught."

msgstr ""

"Notez que les *n*-uplets ne sont pas créés par les parenthèses mais par "

"l'utilisation de la virgule. L'exception est le *n*-uplet vide, pour lequel "

"les parenthèses *sont requises* (autoriser que « rien » ne soit pas "

"parenthésé dans les expressions aurait généré des ambigüités et aurait "

"permis à certaines coquilles de passer inaperçu)."

#: reference/expressions.rst:165

msgid "Displays for lists, sets and dictionaries"

msgstr "Agencements des listes, ensembles et dictionnaires"

#: reference/expressions.rst:169

msgid ""

"For constructing a list, a set or a dictionary Python provides special "

"syntax called \"displays\", each of them in two flavors:"

msgstr ""

"Pour construire une liste, un ensemble ou un dictionnaire, Python fournit "

"des syntaxes spéciales dites « agencements » (*displays* en anglais), chaque "

"agencement comportant deux variantes :"

#: reference/expressions.rst:172

msgid "either the container contents are listed explicitly, or"

msgstr "soit le contenu du conteneur est listé explicitement,"

#: reference/expressions.rst:174

msgid ""

"they are computed via a set of looping and filtering instructions, called a :"

"dfn:`comprehension`."

msgstr ""

"soit il est calculé à l'aide de la combinaison d'une boucle et "

"d'instructions de filtrage, appelée une :dfn:`compréhension` (dans le sens "

"de ce qui sert à définir un concept, par opposition à *extension*)."

#: reference/expressions.rst:182

msgid "Common syntax elements for comprehensions are:"

msgstr ""

"Les compréhensions sont constituées des éléments de syntaxe communs "

"suivants :"

#: reference/expressions.rst:190

msgid ""

"The comprehension consists of a single expression followed by at least one :"

"keyword:`!for` clause and zero or more :keyword:`!for` or :keyword:`!if` "

"clauses. In this case, the elements of the new container are those that "

"would be produced by considering each of the :keyword:`!for` or :keyword:`!"

"if` clauses a block, nesting from left to right, and evaluating the "

"expression to produce an element each time the innermost block is reached."

msgstr ""

"Une compréhension est constituée par une seule expression suivie par au "

"moins une clause :keyword:`!for` et zéro ou plus clauses :keyword:`!for` ou :"

"keyword:`!if`. Dans ce cas, les éléments du nouveau conteneur sont ceux qui "

"auraient été produits si l'on avait considéré toutes les clauses :keyword:`!"

"for` ou :keyword:`!if` comme des blocs, imbriqués de la gauche vers la "

"droite, et évalué l'expression pour produire un élément à chaque fois que le "

"bloc le plus imbriqué était atteint."

#: reference/expressions.rst:197

msgid ""

"However, aside from the iterable expression in the leftmost :keyword:`!for` "

"clause, the comprehension is executed in a separate implicitly nested scope. "

"This ensures that names assigned to in the target list don't \"leak\" into "

"the enclosing scope."

msgstr ""

"Cependant, à part l'expression de l'itérable dans la clause :keyword:`!for` "

"la plus à gauche, la compréhension est exécutée dans une portée séparée, "

"implicitement imbriquée. Ceci assure que les noms assignés dans la liste "

"cible ne « fuient » pas en dehors de cette portée."

#: reference/expressions.rst:201

msgid ""

"The iterable expression in the leftmost :keyword:`!for` clause is evaluated "

"directly in the enclosing scope and then passed as an argument to the "

"implicitly nested scope. Subsequent :keyword:`!for` clauses and any filter "

"condition in the leftmost :keyword:`!for` clause cannot be evaluated in the "

"enclosing scope as they may depend on the values obtained from the leftmost "

"iterable. For example: ``[x*y for x in range(10) for y in range(x, x+10)]``."

msgstr ""

"L'expression de l'itérable dans la clause :keyword:`!for` la plus à gauche "

"est évaluée directement dans la portée englobante puis passée en tant "

"qu'argument à la portée implicite imbriquée. Les clauses :keyword:`!for` "

"suivantes et les filtres conditionnels de la clause :keyword:`!for` la plus "

"à gauche ne peuvent pas être évalués dans la portée englobante, car ils "

"peuvent dépendre de valeurs obtenues à partir de l'itérable le plus à "

"gauche. Par exemple : ``[x*y for x in range(10) for y in range(x, x+10)]``."

#: reference/expressions.rst:208

msgid ""

"To ensure the comprehension always results in a container of the appropriate "

"type, ``yield`` and ``yield from`` expressions are prohibited in the "

"implicitly nested scope."

msgstr ""

"Pour assurer que le résultat de la compréhension soit un conteneur du type "

"approprié, les expressions ``yield`` et ``yield from`` sont interdites dans "

"la portée implicite imbriquée."

#: reference/expressions.rst:215

msgid ""

"Since Python 3.6, in an :keyword:`async def` function, an :keyword:`!async "

"for` clause may be used to iterate over a :term:`asynchronous iterator`. A "

"comprehension in an :keyword:`!async def` function may consist of either a :"

"keyword:`!for` or :keyword:`!async for` clause following the leading "

"expression, may contain additional :keyword:`!for` or :keyword:`!async for` "

"clauses, and may also use :keyword:`await` expressions. If a comprehension "

"contains either :keyword:`!async for` clauses or :keyword:`!await` "

"expressions it is called an :dfn:`asynchronous comprehension`. An "

"asynchronous comprehension may suspend the execution of the coroutine "

"function in which it appears. See also :pep:`530`."

msgstr ""

"Depuis Python 3.6, dans une fonction :keyword:`async def`, une clause :"

"keyword:`!async for` peut être utilisée pour itérer sur un :term:`itérateur "

"asynchrone <asynchronous iterator>`. Une compréhension dans une fonction :"

"keyword:`!async def` consiste alors à avoir une clause :keyword:`!for` or :"

"keyword:`!async for` suivie par des clauses :keyword:`!for` ou :keyword:`!"

"async for` additionnelles facultatives et, possiblement, des expressions :"

"keyword:`await`. Si la compréhension contient soit des clauses :keyword:`!"

"async for`, soit des expressions :keyword:`!await`, elle est appelée :dfn:"

"`compréhension asynchrone`. Une compréhension asynchrone peut suspendre "

"l'exécution de la fonction coroutine dans laquelle elle apparaît. Voir aussi "

"la :pep:`530`."

#: reference/expressions.rst:227

msgid "Asynchronous comprehensions were introduced."

msgstr "Les compréhensions asynchrones ont été introduites."

#: reference/expressions.rst:403

msgid "``yield`` and ``yield from`` prohibited in the implicitly nested scope."

msgstr ""

"``yield`` et ``yield from`` sont interdites dans la portée implicite "

"imbriquée."

#: reference/expressions.rst:237

msgid "List displays"

msgstr "Agencements de listes"

#: reference/expressions.rst:247

msgid ""

"A list display is a possibly empty series of expressions enclosed in square "

"brackets:"

msgstr ""

"Un agencement de liste est une suite (possiblement vide) d'expressions à "

"l'intérieur de crochets :"

#: reference/expressions.rst:253

msgid ""

"A list display yields a new list object, the contents being specified by "

"either a list of expressions or a comprehension. When a comma-separated "

"list of expressions is supplied, its elements are evaluated from left to "

"right and placed into the list object in that order. When a comprehension "

"is supplied, the list is constructed from the elements resulting from the "

"comprehension."

msgstr ""

"Un agencement de liste produit un nouvel objet liste, dont le contenu est "

"spécifié soit par une liste d'expression soit par une compréhension. Quand "

"une liste d'expressions (dont les éléments sont séparés par des virgules) "

"est fournie, ces éléments sont évalués de la gauche vers la droite et placés "

"dans l'objet liste, dans cet ordre. Quand c'est une compréhension qui est "

"fournie, la liste est construite à partir des éléments produits par la "

"compréhension."

#: reference/expressions.rst:263

msgid "Set displays"

msgstr "Agencements d'ensembles"

#: reference/expressions.rst:272

msgid ""

"A set display is denoted by curly braces and distinguishable from dictionary "

"displays by the lack of colons separating keys and values:"

msgstr ""

"Un agencement d'ensemble (type *set*) est délimité par des accolades et se "

"distingue de l'agencement d'un dictionnaire par le fait qu'il n'y a pas de "

"« deux points » ``:`` pour séparer les clés et les valeurs :"

#: reference/expressions.rst:278

msgid ""

"A set display yields a new mutable set object, the contents being specified "

"by either a sequence of expressions or a comprehension. When a comma-"

"separated list of expressions is supplied, its elements are evaluated from "

"left to right and added to the set object. When a comprehension is "

"supplied, the set is constructed from the elements resulting from the "

"comprehension."

msgstr ""

"Un agencement d'ensemble produit un nouvel objet ensemble muable, le contenu "

"étant spécifié soit par une séquence d'expression, soit par une "

"compréhension. Quand une liste (dont les éléments sont séparés par des "

"virgules) est fournie, ses éléments sont évalués de la gauche vers la droite "

"et ajoutés à l'objet ensemble. Quand une compréhension est fournie, "

"l'ensemble est construit à partir des éléments produits par la compréhension."

#: reference/expressions.rst:284

msgid ""

"An empty set cannot be constructed with ``{}``; this literal constructs an "

"empty dictionary."

msgstr ""

"Un ensemble vide ne peut pas être construit par ``{}`` ; cette écriture "

"construit un dictionnaire vide."

#: reference/expressions.rst:291

msgid "Dictionary displays"

msgstr "Agencements de dictionnaires"

#: reference/expressions.rst:302

msgid ""

"A dictionary display is a possibly empty series of key/datum pairs enclosed "

"in curly braces:"

msgstr ""

"Un agencement de dictionnaire est une série (possiblement vide) de couples "

"clés-valeurs entourée par des accolades :"

#: reference/expressions.rst:311

msgid "A dictionary display yields a new dictionary object."

msgstr "Un agencement de dictionnaire produit un nouvel objet dictionnaire."

#: reference/expressions.rst:313

msgid ""

"If a comma-separated sequence of key/datum pairs is given, they are "

"evaluated from left to right to define the entries of the dictionary: each "

"key object is used as a key into the dictionary to store the corresponding "

"datum. This means that you can specify the same key multiple times in the "

"key/datum list, and the final dictionary's value for that key will be the "

"last one given."

msgstr ""

"Si une séquence (dont les éléments sont séparés par des virgules) de couples "

"clés-valeurs est fournie, les couples sont évalués de la gauche vers la "

"droite pour définir les entrées du dictionnaire : chaque objet clé est "

"utilisé comme clé dans le dictionnaire pour stocker la donnée "

"correspondante. Cela signifie que vous pouvez spécifier la même clé "

"plusieurs fois dans la liste des couples clés-valeurs et, dans ce cas, la "

"valeur finalement stockée dans le dictionnaire est la dernière donnée."

#: reference/expressions.rst:323

msgid ""

"A double asterisk ``**`` denotes :dfn:`dictionary unpacking`. Its operand "

"must be a :term:`mapping`. Each mapping item is added to the new "

"dictionary. Later values replace values already set by earlier key/datum "

"pairs and earlier dictionary unpackings."

msgstr ""

"Une double astérisque ``**`` demande de :dfn:`dépaqueter le dictionnaire`. "

"L'opérande doit être un :term:`tableau de correspondances <mapping>`. Chaque "

"élément du tableau de correspondances est ajouté au nouveau dictionnaire. "

"Les valeurs les plus récentes remplacent les valeurs déjà définies par des "

"couples clés-valeurs antérieurs ou par d'autres dépaquetages de "

"dictionnaires antérieurs."

#: reference/expressions.rst:328

msgid "Unpacking into dictionary displays, originally proposed by :pep:`448`."

msgstr ""

"le dépaquetage peut se faire vers un agencement de dictionnaire, proposé à "

"l'origine par la :pep:`448`."

#: reference/expressions.rst:331

msgid ""

"A dict comprehension, in contrast to list and set comprehensions, needs two "

"expressions separated with a colon followed by the usual \"for\" and \"if\" "

"clauses. When the comprehension is run, the resulting key and value elements "

"are inserted in the new dictionary in the order they are produced."

msgstr ""

"Une compréhension de dictionnaire, au contraire des compréhensions de listes "

"ou d'ensembles, requiert deux expressions séparées par une virgule et "

"suivies par les clauses usuelles \"for\" et \"if\". Quand la compréhension "

"est exécutée, les éléments clés-valeurs sont insérés dans le nouveau "

"dictionnaire dans l'ordre dans lequel ils sont produits."

#: reference/expressions.rst:339

msgid ""

"Restrictions on the types of the key values are listed earlier in section :"

"ref:`types`. (To summarize, the key type should be :term:`hashable`, which "

"excludes all mutable objects.) Clashes between duplicate keys are not "

"detected; the last datum (textually rightmost in the display) stored for a "

"given key value prevails."

msgstr ""

"Les restrictions relatives aux types des clés sont données dans la section :"

"ref:`types` (pour résumer, le type de la clé doit être :term:`hachable "

"<hashable>`, ce qui exclut tous les objets muables). Les collisions entre "

"les clés dupliquées ne sont pas détectées ; la dernière valeur (celle qui "

"apparaît le plus à droite dans l'agencement) stockée prévaut pour une clé "

"donnée."

#: reference/expressions.rst:345

msgid ""

"Prior to Python 3.8, in dict comprehensions, the evaluation order of key and "

"value was not well-defined. In CPython, the value was evaluated before the "

"key. Starting with 3.8, the key is evaluated before the value, as proposed "

"by :pep:`572`."

msgstr ""

"Avant Python 3.8, dans les compréhensions de dictionnaires, l'ordre "

"d'évaluation entre les clés et les valeurs n'était pas bien défini. Dans "

"CPython, la valeur était évaluée avant la clé. À partir de la version 3.8, "

"la clé est évaluée avant la valeur, comme proposé par la :pep:`572`."

#: reference/expressions.rst:355

msgid "Generator expressions"

msgstr "Expressions génératrices"

#: reference/expressions.rst:362

msgid "A generator expression is a compact generator notation in parentheses:"

msgstr ""

"Une expression génératrice est une notation concise pour un générateur, "

"entourée de parenthèses :"

#: reference/expressions.rst:367

msgid ""

"A generator expression yields a new generator object. Its syntax is the "

"same as for comprehensions, except that it is enclosed in parentheses "

"instead of brackets or curly braces."

msgstr ""

"Une expression génératrice produit un nouvel objet générateur. Sa syntaxe "

"est la même que celle des compréhensions, sauf qu'elle est entourée de "

"parenthèses au lieu de crochets ou d'accolades."

#: reference/expressions.rst:371

msgid ""

"Variables used in the generator expression are evaluated lazily when the :"

"meth:`~generator.__next__` method is called for the generator object (in the "

"same fashion as normal generators). However, the iterable expression in the "

"leftmost :keyword:`!for` clause is immediately evaluated, so that an error "

"produced by it will be emitted at the point where the generator expression "

"is defined, rather than at the point where the first value is retrieved. "

"Subsequent :keyword:`!for` clauses and any filter condition in the leftmost :"

"keyword:`!for` clause cannot be evaluated in the enclosing scope as they may "

"depend on the values obtained from the leftmost iterable. For example: "

"``(x*y for x in range(10) for y in range(x, x+10))``."

msgstr ""

"Les variables utilisées dans une expression génératrice sont évaluées "

"paresseusement, au moment où la méthode :meth:`~generator.__next__` de "

"l'objet générateur est appelée (de la même manière que pour les générateurs "

"classiques). Cependant, l'expression de l'itérable dans la clause :keyword:`!"

"for` la plus à gauche est immédiatement évaluée, de manière à ce qu'une "

"erreur dans cette partie soit signalée à l'endroit où l'expression "

"génératrice est définie plutôt qu'à l'endroit où la première valeur est "

"récupérée. Les clauses :keyword:`!for` suivantes ne peuvent pas être "

"évaluées dans la portée implicite imbriquée car elles peuvent dépendre de "

"valeurs obtenues à partir de boucles :keyword:`!for` plus à gauche. Par "

"exemple, ``(x*y for x in range(10) for y in range(x, x+10))``."

#: reference/expressions.rst:382

msgid ""

"The parentheses can be omitted on calls with only one argument. See "

"section :ref:`calls` for details."

msgstr ""

"Les parenthèses peuvent être omises pour les appels qui ne possèdent qu'un "

"seul argument. Voir la section :ref:`calls` pour les détails."

#: reference/expressions.rst:385

msgid ""

"To avoid interfering with the expected operation of the generator expression "

"itself, ``yield`` and ``yield from`` expressions are prohibited in the "

"implicitly defined generator."

msgstr ""

"Pour éviter d'interférer avec l'opération attendue de l'expression "

"génératrice elle-même, les expressions ``yield`` et ``yield from`` sont "

"interdites dans les générateurs définis de manière implicite."

#: reference/expressions.rst:389

msgid ""

"If a generator expression contains either :keyword:`!async for` clauses or :"

"keyword:`await` expressions it is called an :dfn:`asynchronous generator "

"expression`. An asynchronous generator expression returns a new "

"asynchronous generator object, which is an asynchronous iterator (see :ref:"

"`async-iterators`)."

msgstr ""

"Si une expression génératrice contient une ou des expressions :keyword:`!"

"async for` ou :keyword:`await`, elle est appelée :dfn:`expression "

"génératrice asynchrone <asynchronous generator expression>`. Une expression "

"génératrice asynchrone produit un nouvel objet générateur asynchrone qui est "

"un itérateur asynchrone (voir :ref:`async-iterators`)."

#: reference/expressions.rst:395

msgid "Asynchronous generator expressions were introduced."

msgstr "les expressions génératrices asynchrones ont été introduites."

#: reference/expressions.rst:398

msgid ""

"Prior to Python 3.7, asynchronous generator expressions could only appear "

"in :keyword:`async def` coroutines. Starting with 3.7, any function can use "

"asynchronous generator expressions."

msgstr ""

"Avant Python 3.7, les expressions génératrices asynchrones ne pouvaient "

"apparaître que dans les coroutines :keyword:`async def`. À partir de la "

"version 3.7, toute fonction peut utiliser des expressions génératrices "

"asynchrones."

#: reference/expressions.rst:410

msgid "Yield expressions"

msgstr "Expressions ``yield``"

#: reference/expressions.rst:422

msgid ""

"The yield expression is used when defining a :term:`generator` function or "

"an :term:`asynchronous generator` function and thus can only be used in the "

"body of a function definition. Using a yield expression in a function's "

"body causes that function to be a generator function, and using it in an :"

"keyword:`async def` function's body causes that coroutine function to be an "

"asynchronous generator function. For example::"

msgstr ""

"Une expression ``yield`` est utilisée pour définir une :term:`fonction "

"génératrice <generator>` ou une :term:`fonction génératrice asynchrone "

"<asynchronous generator>` et ne peut donc être utilisée que dans le corps de "

"la définition d'une fonction. L'utilisation d'une expression ``yield`` dans "

"le corps d'une fonction entraîne que cette fonction devient une fonction "

"génératrice et son utilisation dans le corps d'une fonction :keyword:`async "

"def` entraine que cette fonction coroutine devient une fonction génératrice "

"asynchrone. Par exemple ::"

#: reference/expressions.rst:435

msgid ""

"Due to their side effects on the containing scope, ``yield`` expressions are "

"not permitted as part of the implicitly defined scopes used to implement "

"comprehensions and generator expressions."

msgstr ""

"En raison des effets de bords sur la portée contenant, les expressions "

"``yield`` ne sont pas autorisées dans la portée implicite utilisée dans "

"l'implémentation des compréhensions et des expressions génératrices."

#: reference/expressions.rst:439

msgid ""

"Yield expressions prohibited in the implicitly nested scopes used to "

"implement comprehensions and generator expressions."

msgstr ""

"Les expressions ``yield`` sont interdites dans la portée implicite imbriquée "

"utilisée dans l'implémentation des compréhensions et des expressions "

"génératrices."

#: reference/expressions.rst:443

msgid ""

"Generator functions are described below, while asynchronous generator "

"functions are described separately in section :ref:`asynchronous-generator-"

"functions`."

msgstr ""

"Les fonctions génératrices sont décrites plus loin alors que les fonctions "

"générateurs asynchrones sont décrites séparément dans la section :ref:"

"`asynchronous-generator-functions`."

#: reference/expressions.rst:447

#, fuzzy

msgid ""

"When a generator function is called, it returns an iterator known as a "

"generator. That generator then controls the execution of the generator "

"function. The execution starts when one of the generator's methods is "

"called. At that time, the execution proceeds to the first yield expression, "

"where it is suspended again, returning the value of :token:`~python-grammar:"

"expression_list` to the generator's caller, or ``None`` if :token:`~python-"

"grammar:expression_list` is omitted. By suspended, we mean that all local "

"state is retained, including the current bindings of local variables, the "

"instruction pointer, the internal evaluation stack, and the state of any "

"exception handling. When the execution is resumed by calling one of the "

"generator's methods, the function can proceed exactly as if the yield "

"expression were just another external call. The value of the yield "

"expression after resuming depends on the method which resumed the "

"execution. If :meth:`~generator.__next__` is used (typically via either a :"

"keyword:`for` or the :func:`next` builtin) then the result is :const:"

"`None`. Otherwise, if :meth:`~generator.send` is used, then the result will "

"be the value passed in to that method."

msgstr ""

"Lorsqu'une fonction génératrice est appelée, elle renvoie un itérateur que "

"l'on appelle générateur. Ce générateur contrôle l'exécution de la fonction "

"génératrice. L'exécution commence lorsque l'une des méthodes du générateur "

"est appelée. À ce moment, l'exécution se déroule jusqu'à la première "

"expression ``yield``, où elle se suspend, renvoyant la valeur de :token:"

"`expression_list` à l'appelant du générateur. Cette suspension conserve tous "

"les états locaux, y compris les liaisons en cours des variables locales, le "

"pointeur d'instruction, la pile d'évaluation interne et l'état de tous les "

"gestionnaires d'exceptions. Lorsque l'exécution reprend en appelant l'une "

"des méthodes du générateur, la fonction s'exécute exactement comme si "

"l'expression ``yield`` n'avait été qu'un simple appel externe. La valeur de "

"l'expression ``yield`` après reprise dépend de la méthode qui a permis la "

"reprise de l'exécution. Si c'est :meth:`~generator.__next__` qui a été "

"utilisée (typiquement *via* un :keyword:`for` ou la fonction native :func:"

"`next`) alors le résultat est :const:`None`. Sinon, si c'est :meth:"

"`~generator.send` qui a été utilisée, alors le résultat est la valeur "

"transmise à cette méthode."

#: reference/expressions.rst:467

msgid ""

"All of this makes generator functions quite similar to coroutines; they "

"yield multiple times, they have more than one entry point and their "

"execution can be suspended. The only difference is that a generator "

"function cannot control where the execution should continue after it yields; "

"the control is always transferred to the generator's caller."

msgstr ""

"Tout ceci rend les fonctions génératrices très similaires aux coroutines : "

"elles produisent plusieurs objets *via* des expressions ``yield``, elles "

"possèdent plus qu'un seul point d'entrée et leur exécution peut être "

"suspendue. La seule différence est qu'une fonction génératrice ne peut pas "

"contrôler où l'exécution doit se poursuivre après une instruction "

"``yield`` ; ce contrôle est toujours du ressort de l'appelant au générateur."

#: reference/expressions.rst:473

msgid ""

"Yield expressions are allowed anywhere in a :keyword:`try` construct. If "

"the generator is not resumed before it is finalized (by reaching a zero "

"reference count or by being garbage collected), the generator-iterator's :"

"meth:`~generator.close` method will be called, allowing any pending :keyword:"

"`finally` clauses to execute."

msgstr ""

"Les expressions ``yield`` sont autorisées partout dans un bloc :keyword:"

"`try`. Si l'exécution du générateur ne reprend pas avant qu'il ne soit "

"finalisé (parce que son compteur de référence est tombé à zéro ou parce "

"qu'il est nettoyé par le ramasse-miettes), la méthode :meth:`~generator."

"close` du générateur-itérateur est appelée, ce qui permet l'exécution de "

"toutes les clauses :keyword:`finally` en attente."

#: reference/expressions.rst:482

msgid ""

"When ``yield from <expr>`` is used, the supplied expression must be an "

"iterable. The values produced by iterating that iterable are passed directly "

"to the caller of the current generator's methods. Any values passed in with :"

"meth:`~generator.send` and any exceptions passed in with :meth:`~generator."

"throw` are passed to the underlying iterator if it has the appropriate "

"methods. If this is not the case, then :meth:`~generator.send` will raise :"

"exc:`AttributeError` or :exc:`TypeError`, while :meth:`~generator.throw` "

"will just raise the passed in exception immediately."

msgstr ""

"L'expression passée à ``yield from <expr>`` doit être un itérateur. Toutes "

"les valeurs produites par cet itérateur sont directement passées à "

"l'appelant des méthodes du générateur courant. Toute valeur passée par :meth:"

"`~generator.send` ou toute exception passée par :meth:`~generator.throw` est "

"transmise à l'itérateur sous-jacent s'il possède les méthodes appropriées. "

"Si ce n'est pas le cas, alors :meth:`~generator.send` lève une :exc:"

"`AttributeError` ou une :exc:`TypeError`, alors que :meth:`~generator.throw` "

"ne fait que propager l'exception immédiatement."

#: reference/expressions.rst:491

msgid ""

"When the underlying iterator is complete, the :attr:`~StopIteration.value` "

"attribute of the raised :exc:`StopIteration` instance becomes the value of "

"the yield expression. It can be either set explicitly when raising :exc:"

"`StopIteration`, or automatically when the subiterator is a generator (by "

"returning a value from the subgenerator)."

msgstr ""

"Quand l'itérateur sous-jacent a terminé, l'attribut :attr:`~StopIteration."

"value` de l'instance :exc:`StopIteration` qui a été levée devient la valeur "

"produite par l'expression ``yield``. Elle peut être définie explicitement "

"quand vous levez :exc:`StopIteration` ou automatiquement que le sous-"

"itérateur est un générateur (en renvoyant une valeur par le sous-générateur)."

#: reference/expressions.rst:497

msgid "Added ``yield from <expr>`` to delegate control flow to a subiterator."

msgstr ""

"``yield from <expr>`` a été ajoutée pour déléguer le contrôle du flot "

"d'exécution à un sous-itérateur."

#: reference/expressions.rst:500

msgid ""

"The parentheses may be omitted when the yield expression is the sole "

"expression on the right hand side of an assignment statement."

msgstr ""

"Les parenthèses peuvent être omises quand l'expression ``yield`` est la "

"seule expression à droite de l'instruction de l'instruction d'assignation."

#: reference/expressions.rst:506

msgid ":pep:`255` - Simple Generators"

msgstr ":pep:`255` : générateurs simples"

#: reference/expressions.rst:506

msgid ""

"The proposal for adding generators and the :keyword:`yield` statement to "

"Python."

msgstr ""

"La proposition d'ajouter à Python des générateurs et l'instruction :keyword:"

"`yield`."

#: reference/expressions.rst:510

msgid ":pep:`342` - Coroutines via Enhanced Generators"

msgstr ":pep:`342` -- Coroutines *via* des générateurs améliorés"

#: reference/expressions.rst:509

msgid ""

"The proposal to enhance the API and syntax of generators, making them usable "

"as simple coroutines."

msgstr ""

"Proposition d'améliorer l'API et la syntaxe des générateurs, de manière à "

"pouvoir les utiliser comme de simples coroutines."

#: reference/expressions.rst:514

msgid ":pep:`380` - Syntax for Delegating to a Subgenerator"

msgstr ":pep:`380` -- Syntaxe pour déléguer à un sous-générateur"

#: reference/expressions.rst:513

msgid ""

"The proposal to introduce the :token:`~python-grammar:yield_from` syntax, "

"making delegation to subgenerators easy."

msgstr ""

"Proposition d'introduire la syntaxe :token:`~python-grammar:yield_from`, de "

"manière à déléguer facilement l'exécution à un sous-générateur."

#: reference/expressions.rst:517

msgid ":pep:`525` - Asynchronous Generators"

msgstr ":pep:`525` : Générateurs asynchrones"

#: reference/expressions.rst:517

msgid ""

"The proposal that expanded on :pep:`492` by adding generator capabilities to "

"coroutine functions."

msgstr ""

"La proposition qui a amélioré la :pep:`492` en ajoutant des capacités de "

"générateur pour les coroutines."

#: reference/expressions.rst:524

msgid "Generator-iterator methods"

msgstr "Méthodes des générateurs-itérateurs"

#: reference/expressions.rst:526

msgid ""

"This subsection describes the methods of a generator iterator. They can be "

"used to control the execution of a generator function."

msgstr ""

"Cette sous-section décrit les méthodes des générateurs-itérateurs. Elles "

"peuvent être utilisées pour contrôler l'exécution des fonctions générateurs."

#: reference/expressions.rst:529

msgid ""

"Note that calling any of the generator methods below when the generator is "

"already executing raises a :exc:`ValueError` exception."

msgstr ""

"Notez que l'appel à une méthode ci-dessous d'un générateur alors que le "

"générateur est déjà en cours d'exécution lève une exception :exc:"

"`ValueError`."

#: reference/expressions.rst:537

msgid ""

"Starts the execution of a generator function or resumes it at the last "

"executed yield expression. When a generator function is resumed with a :"

"meth:`~generator.__next__` method, the current yield expression always "

"evaluates to :const:`None`. The execution then continues to the next yield "

"expression, where the generator is suspended again, and the value of the :"

"token:`~python-grammar:expression_list` is returned to :meth:`__next__`'s "

"caller. If the generator exits without yielding another value, a :exc:"

"`StopIteration` exception is raised."

msgstr ""

"Démarre l'exécution d'une fonction génératrice ou la reprend à la dernière "

"expression ``yield`` exécutée. Quand une fonction génératrice est reprise "

"par une méthode :meth:`~generator.__next__`, l'expression ``yield`` en cours "

"s'évalue toujours à :const:`None`. L'exécution continue ensuite jusqu'à "

"l'expression ``yield`` suivante, où le générateur est à nouveau suspendu et "

"la valeur de :token:`~python-grammar:expression_list` est renvoyée à la "

"méthode :meth:`__next__` de l'appelant. Si le générateur termine sans donner "

"une autre valeur, une exception :exc:`StopIteration` est levée."

#: reference/expressions.rst:546

msgid ""

"This method is normally called implicitly, e.g. by a :keyword:`for` loop, or "

"by the built-in :func:`next` function."

msgstr ""

"Cette méthode est normalement appelée implicitement, par exemple par une "

"boucle :keyword:`for` ou par la fonction native :func:`next`."

#: reference/expressions.rst:552

msgid ""

"Resumes the execution and \"sends\" a value into the generator function. "

"The *value* argument becomes the result of the current yield expression. "

"The :meth:`send` method returns the next value yielded by the generator, or "

"raises :exc:`StopIteration` if the generator exits without yielding another "

"value. When :meth:`send` is called to start the generator, it must be "

"called with :const:`None` as the argument, because there is no yield "

"expression that could receive the value."

msgstr ""

"Reprend l'exécution et « envoie » une valeur à la fonction générateur. "

"L'argument *value* devient le résultat de l'expression ``yield`` courante. "

"La méthode :meth:`send` renvoie la valeur suivante produite par le "

"générateur ou lève :exc:`StopIteration` si le générateur termine sans "

"produire de nouvelle valeur. Quand :meth:`send` est utilisée pour démarrer "

"le générateur, elle doit avoir :const:`None` comme argument, car il n'y a "

"aucune expression ``yield`` qui peut recevoir la valeur."

#: reference/expressions.rst:564

msgid ""

"Raises an exception at the point where the generator was paused, and returns "

"the next value yielded by the generator function. If the generator exits "

"without yielding another value, a :exc:`StopIteration` exception is raised. "

"If the generator function does not catch the passed-in exception, or raises "

"a different exception, then that exception propagates to the caller."

msgstr ""

"Lève une exception à l'endroit où le générateur est en pause et renvoie la "

"valeur suivante produite par la fonction génératrice. Si le générateur "

"termine sans produire de nouvelle valeur, une exception :exc:`StopIteration` "

"est levée. Si la fonction génératrice ne gère pas l'exception passée ou lève "

"une autre exception, alors cette exception est propagée vers l'appelant."

#: reference/expressions.rst:570

msgid ""

"In typical use, this is called with a single exception instance similar to "

"the way the :keyword:`raise` keyword is used."

msgstr ""

"Dans son utilisation typique, elle est appelée avec une seule instance "

"d'exception, de façon similaire à l'utilisation du mot-clé :keyword:`raise`."

#: reference/expressions.rst:573

msgid ""

"For backwards compatibility, however, the second signature is supported, "

"following a convention from older versions of Python. The *type* argument "

"should be an exception class, and *value* should be an exception instance. "

"If the *value* is not provided, the *type* constructor is called to get an "

"instance. If *traceback* is provided, it is set on the exception, otherwise "

"any existing :attr:`~BaseException.__traceback__` attribute stored in "

"*value* may be cleared."

msgstr ""

#: reference/expressions.rst:587

msgid ""

"Raises a :exc:`GeneratorExit` at the point where the generator function was "

"paused. If the generator function then exits gracefully, is already closed, "

"or raises :exc:`GeneratorExit` (by not catching the exception), close "

"returns to its caller. If the generator yields a value, a :exc:"

"`RuntimeError` is raised. If the generator raises any other exception, it "

"is propagated to the caller. :meth:`close` does nothing if the generator "

"has already exited due to an exception or normal exit."

msgstr ""

"Lève une :exc:`GeneratorExit` à l'endroit où la fonction génératrice a été "

"mise en pause. Si la fonction génératrice termine, est déjà fermée ou lève :"

"exc:`GeneratorExit` (parce qu'elle ne gère pas l'exception), *close* revient "

"vers l'appelant. Si le générateur produit une valeur, une :exc:"

"`RuntimeError` est levée. Si le générateur lève une autre exception, elle "

"est propagée à l'appelant. La méthode :meth:`close` ne fait rien si le "

"générateur a déjà terminé en raison d'une exception ou d'une fin normale."

#: reference/expressions.rst:598

msgid "Examples"

msgstr "Exemples"

#: reference/expressions.rst:600

msgid ""

"Here is a simple example that demonstrates the behavior of generators and "

"generator functions::"

msgstr ""

"Voici un exemple simple qui montre le comportement des générateurs et des "

"fonctions génératrices ::"

#: reference/expressions.rst:627

msgid ""

"For examples using ``yield from``, see :ref:`pep-380` in \"What's New in "

"Python.\""

msgstr ""

"Pour des exemples d'utilisation de ``yield from``, lisez la :ref:`pep-380` "

"dans « Les nouveautés de Python »."

#: reference/expressions.rst:633

msgid "Asynchronous generator functions"

msgstr "Fonctions génératrices asynchrones"

#: reference/expressions.rst:635

msgid ""

"The presence of a yield expression in a function or method defined using :"

"keyword:`async def` further defines the function as an :term:`asynchronous "

"generator` function."

msgstr ""

"La présence d'une expression *yield* dans une fonction ou une méthode "

"définie en utilisant :keyword:`async def` transforme cette fonction en "

"fonction :term:`générateur asynchrone <asynchronous generator>`."

#: reference/expressions.rst:639

msgid ""

"When an asynchronous generator function is called, it returns an "

"asynchronous iterator known as an asynchronous generator object. That object "

"then controls the execution of the generator function. An asynchronous "

"generator object is typically used in an :keyword:`async for` statement in a "

"coroutine function analogously to how a generator object would be used in a :"

"keyword:`for` statement."

msgstr ""

"Quand une fonction génératrice asynchrone est appelée, elle renvoie un "

"itérateur asynchrone, autrement appelé objet générateur asynchrone. Cet "

"objet contrôle l'exécution de la fonction génératrice. Un objet générateur "

"asynchrone est typiquement utilisé dans une instruction :keyword:`async for` "

"à l'intérieur d'une fonction coroutine de la même manière qu'un objet "

"générateur serait utilisé dans une instruction :keyword:`for`."