# SOME DESCRIPTIVE TITLE.

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

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2018-06-17 10:39+0200\n"

"PO-Revision-Date: 2018-06-17 10:55+0200\n"

"Last-Translator: Julien Palard <julien@palard.fr>\n"

"Language-Team: \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 2.0.2\n"

#: ../Doc/reference/expressions.rst:6

msgid "Expressions"

msgstr "Expressions"

#: ../Doc/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."

#: ../Doc/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"

#: ../Doc/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``."

#: ../Doc/reference/expressions.rst:26

msgid "Arithmetic conversions"

msgstr "Conversions arithmétiques"

#: ../Doc/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 :"

#: ../Doc/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 ;"

#: ../Doc/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 ;"

#: ../Doc/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."

#: ../Doc/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."

#: ../Doc/reference/expressions.rst:49

msgid "Atoms"

msgstr "Atomes"

#: ../Doc/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 :"

#: ../Doc/reference/expressions.rst:66

msgid "Identifiers (Names)"

msgstr "Identifiants (noms)"

#: ../Doc/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."

#: ../Doc/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`."

#: ../Doc/reference/expressions.rst:84

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

#: ../Doc/reference/expressions.rst:100

msgid "Literals"

msgstr "Littéraux"

#: ../Doc/reference/expressions.rst:104

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

#: ../Doc/reference/expressions.rst:110

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

#: ../Doc/reference/expressions.rst:119

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

#: ../Doc/reference/expressions.rst:129

msgid "Parenthesized forms"

msgstr "Formes parenthésées"

#: ../Doc/reference/expressions.rst:133

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

#: ../Doc/reference/expressions.rst:138

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 *tuple*) ; sinon, elle produit l'expression elle-"

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

#: ../Doc/reference/expressions.rst:144

msgid ""

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

"immutable, the rules 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 *tuple* vide. Comme les "

"*tuples* sont immuables, la règle pour les littéraux s'applique (c'est-à-"

"dire que deux occurrences du *tuple* vide peuvent, ou pas, produire le même "

"objet)."

#: ../Doc/reference/expressions.rst:152

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 *tuples* ne sont pas créés par les parenthèses mais par "

"l'utilisation de la virgule. L'exception est le tuple 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)."

#: ../Doc/reference/expressions.rst:161

msgid "Displays for lists, sets and dictionaries"

msgstr "Agencements des listes, ensembles et dictionnaires"

#: ../Doc/reference/expressions.rst:163

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

#: ../Doc/reference/expressions.rst:166

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

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

#: ../Doc/reference/expressions.rst:168

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

#: ../Doc/reference/expressions.rst:171

msgid "Common syntax elements for comprehensions are:"

msgstr ""

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

"suivants :"

#: ../Doc/reference/expressions.rst:179

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

#: ../Doc/reference/expressions.rst:186

msgid ""

"Note that the comprehension is executed in a separate scope, so names "

"assigned to in the target list don't \"leak\" into the enclosing scope."

msgstr ""

"Notez que la compréhension est exécutée dans une portée séparée, les noms "

"assignés dans la liste cible ne pouvant pas \"fuir\" en dehors de cette "

"portée."

#: ../Doc/reference/expressions.rst:189

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

#: ../Doc/reference/expressions.rst:204

msgid "List displays"

msgstr "Agencements de listes"

#: ../Doc/reference/expressions.rst:212

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

#: ../Doc/reference/expressions.rst:218

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

#: ../Doc/reference/expressions.rst:228

msgid "Set displays"

msgstr "Agencements d'ensembles"

#: ../Doc/reference/expressions.rst:233

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

#: ../Doc/reference/expressions.rst:239

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

#: ../Doc/reference/expressions.rst:245

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

#: ../Doc/reference/expressions.rst:252

msgid "Dictionary displays"

msgstr "Agencements de dictionnaires"

#: ../Doc/reference/expressions.rst:258

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

#: ../Doc/reference/expressions.rst:267

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

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

#: ../Doc/reference/expressions.rst:269

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

#: ../Doc/reference/expressions.rst:277

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

#: ../Doc/reference/expressions.rst:282

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

#: ../Doc/reference/expressions.rst:285

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

#: ../Doc/reference/expressions.rst:293

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

#: ../Doc/reference/expressions.rst:303

msgid "Generator expressions"

msgstr "Expressions génératrices"

#: ../Doc/reference/expressions.rst:308

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

#: ../Doc/reference/expressions.rst:313

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

#: ../Doc/reference/expressions.rst:317

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

"clause is immediately evaluated, so that an error produced by it can be seen "

"before any other possible error in the code that handles the generator "

"expression. Subsequent :keyword:`for` clauses cannot be evaluated "

"immediately since they may depend on the previous :keyword:`for` loop. For "

"example: ``(x*y for x in range(10) for y in bar(x))``."

msgstr ""

"Les variables utilisées dans une expression générateur 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, la clause :keyword:`for` la plus à gauche est "

"immédiatement évaluée, de manière à ce qu'une erreur dans cette partie "

"puisse être vue avant tout autre erreur dans le code qui gère l'expression "

"générateur. Les clauses :keyword:`for` suivantes ne peuvent pas être "

"évaluées immédiatement car elles peuvent dépendre de la précédente boucle :"

"keyword:`for`. Par exemple, ``(x*y for x in range(10) for y in truc(x))``."

#: ../Doc/reference/expressions.rst:326

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

#: ../Doc/reference/expressions.rst:329

msgid ""

"Since Python 3.6, if the generator appears in an :keyword:`async def` "

"function, then :keyword:`async for` clauses and :keyword:`await` expressions "

"are permitted as with an asynchronous comprehension. 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 yields a new asynchronous generator "

"object, which is an asynchronous iterator (see :ref:`async-iterators`)."

msgstr ""

"Depuis Python 3.6, si le générateur apparaît dans une fonction :keyword:"

"`async def`, alors la clause :keyword:`async for` et les expressions :"

"keyword:`await` sont permises comme pour une compréhension asynchrone. Si "

"une expression générateur contient soit des clauses :keyword:`async for`, "

"soit des expressions :keyword:`await`, alors on l'appelle :dfn:`expression "

"générateur asynchrone`. Une expression générateur asynchrone produit un "

"nouvel objet générateur asynchrone qui est un itérateur asynchrone (voir :"

"ref:`async-iterators`)."

#: ../Doc/reference/expressions.rst:341

msgid "Yield expressions"

msgstr "Expressions ``yield``"

#: ../Doc/reference/expressions.rst:352

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, and using it in an :keyword:"

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

"asynchronous generator. For example::"

msgstr ""

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

"`générateur` ou une fonction :term:`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 un générateur et son "

"utilisation dans le corps d'une fonction :keyword:`async def` entraine que "

"cette fonction coroutine devient un générateur asynchrone. Par exemple ::"

#: ../Doc/reference/expressions.rst:365

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

#: ../Doc/reference/expressions.rst:369

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

"to the generator's caller. 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."

#: ../Doc/reference/expressions.rst:388

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

#: ../Doc/reference/expressions.rst:394

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

#: ../Doc/reference/expressions.rst:400

msgid ""

"When ``yield from <expr>`` is used, it treats the supplied expression as a "

"subiterator. All values produced by that subiterator 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'utilisation de ``yield from <expr>`` traite l'expression passée en "

"paramètre comme un sous-itérateur. Toutes les valeurs produites par ce sous-"

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

#: ../Doc/reference/expressions.rst:409

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 sub-iterator is a generator (by "

"returning a value from the sub-generator)."

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

#: ../Doc/reference/expressions.rst:415

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

#: ../Doc/reference/expressions.rst:418

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

#: ../Doc/reference/expressions.rst:424

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

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

#: ../Doc/reference/expressions.rst:424

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

#: ../Doc/reference/expressions.rst:428

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

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

#: ../Doc/reference/expressions.rst:427

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

#: ../Doc/reference/expressions.rst:431

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

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

#: ../Doc/reference/expressions.rst:431

msgid ""

"The proposal to introduce the :token:`yield_from` syntax, making delegation "

"to sub-generators easy."

msgstr ""

"Proposition d'introduire la syntaxe :token:`yield_from`, de manière à "

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

#: ../Doc/reference/expressions.rst:438

msgid "Generator-iterator methods"

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

#: ../Doc/reference/expressions.rst:440

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

#: ../Doc/reference/expressions.rst:443

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

#: ../Doc/reference/expressions.rst:451

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:`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érateur ou la reprend à la dernière "

"expression ``yield`` exécutée. Quand une fonction générateur 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:`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."

#: ../Doc/reference/expressions.rst:460

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

#: ../Doc/reference/expressions.rst:466

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

#: ../Doc/reference/expressions.rst:477

msgid ""

"Raises an exception of type ``type`` 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 de type ``type`` à l'endroit où le générateur est en "

"pause et renvoie la valeur suivante produite par la fonction générateur. 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."

#: ../Doc/reference/expressions.rst:488

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

#: ../Doc/reference/expressions.rst:499

msgid "Examples"

msgstr "Exemples"

#: ../Doc/reference/expressions.rst:501

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

#: ../Doc/reference/expressions.rst:528

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

#: ../Doc/reference/expressions.rst:534

msgid "Asynchronous generator functions"

msgstr "Fonctions génératrices asynchrones"

#: ../Doc/reference/expressions.rst:536

msgid ""

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

"keyword:`async def` further defines the function as a :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`."

#: ../Doc/reference/expressions.rst:540

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

#: ../Doc/reference/expressions.rst:547

msgid ""

"Calling one of the asynchronous generator's methods returns an :term:"

"`awaitable` object, and the execution starts when this object is awaited on. "

"At that time, the execution proceeds to the first yield expression, where it "

"is suspended again, returning the value of :token:`expression_list` to the "

"awaiting coroutine. As with a generator, suspension means 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 awaiting on the next "

"object returned by the asynchronous 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:`~agen.__anext__` is used then the result "

"is :const:`None`. Otherwise, if :meth:`~agen.asend` is used, then the result "

"will be the value passed in to that method."

msgstr ""

"L'appel d'une méthode du générateur asynchrone renvoie un objet :term:"

"`awaitable` et l'exécution commence au moment où l'on atteint une "

"instruction ``await`` le concernant. À ce moment, l'exécution se déroule "

"jusqu'à la première expression ``yield``, où elle est suspendue et renvoie "

"la valeur de :token:`expression_list` à la coroutine en attente. Comme pour "

"un générateur, la suspension signifie que tous les états locaux sont "

"conservés, y compris les liaisons 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 parce que l'appelant "

"a atteint une instruction ``await`` sur l'objet suivant retourné par les "

"méthodes du générateur asynchrone, 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`` au moment de la reprise dépend de la méthode qui a "

"relancé l'exécution. Si c'est :meth:`~agen.__anext__` qui a été utilisée, "

"alors le résultat est :const:`None`. Sinon, si c'est :meth:`~agen.asend` qui "

"a été utilisée, alors le résultat est la valeur transmise à cette méthode."

#: ../Doc/reference/expressions.rst:563

msgid ""

"In an asynchronous generator function, yield expressions are allowed "

"anywhere in a :keyword:`try` construct. However, if an asynchronous "

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

"reference count or by being garbage collected), then a yield expression "

"within a :keyword:`try` construct could result in a failure to execute "

"pending :keyword:`finally` clauses. In this case, it is the responsibility "

"of the event loop or scheduler running the asynchronous generator to call "

"the asynchronous generator-iterator's :meth:`~agen.aclose` method and run "

"the resulting coroutine object, thus allowing any pending :keyword:`finally` "

"clauses to execute."

msgstr ""

"Dans une fonction générateur asynchrone, les expressions ``yield`` sont "

"autorisées n'importe où dans une construction :keyword:`try`. Cependant, si "

"l'exécution d'un générateur asynchrone n'a pas repris avant que le "

"générateur ne soit finalisé (parce que son compteur de référence a atteint "

"zéro ou parce qu'il est nettoyé par le ramasse-miettes), alors une "

"expression ``yield`` dans une construction :keyword:`try` pourrait ne pas "

"atteindre la clause :keyword:`finally` en attente. Dans ce cas, c'est la "

"responsabilité de la boucle d'événements ou du programmateur exécutant le "

"générateur asynchrone d'appeler la méthode :meth:`~agen.aclose` du "

"générateur asynchrone et d'exécuter l'objet coroutine résultant, permettant "

"ainsi à toute clause :keyword:`finally` en attente d'être exécutée."

#: ../Doc/reference/expressions.rst:574

msgid ""

"To take care of finalization, an event loop should define a *finalizer* "

"function which takes an asynchronous generator-iterator and presumably "

"calls :meth:`~agen.aclose` and executes the coroutine. This *finalizer* may "

"be registered by calling :func:`sys.set_asyncgen_hooks`. When first iterated "

"over, an asynchronous generator-iterator will store the registered "

"*finalizer* to be called upon finalization. For a reference example of a "

"*finalizer* method see the implementation of ``asyncio.Loop."

"shutdown_asyncgens`` in :source:`Lib/asyncio/base_events.py`."

msgstr ""

"Pour effectuer correctement la finalisation, une boucle d'événements doit "

"définir une fonction *finalizer* qui prend un générateur-itérateur "

"asynchrone, appelle sans doute :meth:`~agen.aclose` et exécute la coroutine. "

"Ce *finalizer* peut s'enregistrer en appelant :func:`sys."

"set_asyncgen_hooks`. Lors de la première itération, un générateur-itérateur "

"asynchrone stocke le *finalizer* enregistré à appeler lors de la "

"finalisation. Pour un exemple de référence relatif à une méthode de "

"*finalizer*, regardez l'implémentation de ``asyncio.Loop."

"shutdown_asyncgens`` dans :source:`Lib/asyncio/base_events.py`."

#: ../Doc/reference/expressions.rst:583

msgid ""

"The expression ``yield from <expr>`` is a syntax error when used in an "

"asynchronous generator function."

msgstr ""

"L'expression ``yield from <expr>`` produit une erreur de syntaxe quand elle "

"est utilisée dans une fonction génératrice asynchrone."

#: ../Doc/reference/expressions.rst:590

msgid "Asynchronous generator-iterator methods"

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

#: ../Doc/reference/expressions.rst:592

msgid ""

"This subsection describes the methods of an asynchronous generator iterator, "

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

msgstr ""

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

"asynchrones. Elles sont utilisées pour contrôler l’exécution des fonctions "

"génératrices."

#: ../Doc/reference/expressions.rst:600

msgid ""

"Returns an awaitable which when run starts to execute the asynchronous "

"generator or resumes it at the last executed yield expression. When an "

"asynchronous generator function is resumed with a :meth:`~agen.__anext__` "

"method, the current yield expression always evaluates to :const:`None` in "

"the returned awaitable, which when run will continue to the next yield "

"expression. The value of the :token:`expression_list` of the yield "

"expression is the value of the :exc:`StopIteration` exception raised by the "

"completing coroutine. If the asynchronous generator exits without yielding "

"another value, the awaitable instead raises an :exc:`StopAsyncIteration` "

"exception, signalling that the asynchronous iteration has completed."

msgstr ""

"Renvoie un *awaitable* qui, quand il a la main, démarre l'exécution du "

"générateur asynchrone ou reprend son exécution à l'endroit de la dernière "

"expression ``yield`` exécutée. Quand une fonction générateur asynchrone est "

"reprise par une méthode :meth:`~agen.__anext__`, l’expression ``yield`` en "

"cours s’évalue toujours à :const:`None` dans le *awaitable* renvoyé, et elle "

"continue son exécution jusqu’à l’expression ``yield`` suivante. La valeur "

"de :token:`expression_list` de l'expression ``yield`` est la valeur de "

"l'exception :exc:`StopIteration` levée par la coroutine qui termine. Si le "

"générateur asynchrone termine sans produire d'autre valeur, le *awaitable* "

"lève une exception :exc:`StopAsyncIteration` qui signale que l'itération "