# 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: 2024-11-01 00:16+0100\n"

"PO-Revision-Date: 2024-10-29 22:06+0100\n"

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

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

"Language: fr\n"

"MIME-Version: 1.0\n"

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

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

"X-Generator: Poedit 3.2.2\n"

#: reference/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

#, fuzzy

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

msgid "Private name mangling"

msgstr ""

#: reference/expressions.rst:89

msgid ""

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

msgstr ""

#: reference/expressions.rst:95

msgid "The :ref:`class specifications <class>`."

msgstr ""

#: reference/expressions.rst:97

msgid ""

"More precisely, private names are transformed to a longer form before code "

"is generated for them. If the transformed name is longer than 255 "

"characters, implementation-defined truncation may happen."

msgstr ""

#: reference/expressions.rst:101

msgid ""

"The transformation is independent of the syntactical context in which the "

"identifier is used but only the following private identifiers are mangled:"

msgstr ""

#: reference/expressions.rst:104

msgid ""

"Any name used as the name of a variable that is assigned or read or any name "

"of an attribute being accessed."

msgstr ""

#: reference/expressions.rst:107

msgid ""

"The :attr:`~definition.__name__` attribute of nested functions, classes, and "

"type aliases is however not mangled."

msgstr ""

#: reference/expressions.rst:110

msgid ""

"The name of imported modules, e.g., ``__spam`` in ``import __spam``. If the "

"module is part of a package (i.e., its name contains a dot), the name is "

"*not* mangled, e.g., the ``__foo`` in ``import __foo.bar`` is not mangled."

msgstr ""

#: reference/expressions.rst:115

msgid ""

"The name of an imported member, e.g., ``__f`` in ``from spam import __f``."

msgstr ""

#: reference/expressions.rst:117

msgid "The transformation rule is defined as follows:"

msgstr ""

#: reference/expressions.rst:119

msgid ""

"The class name, with leading underscores removed and a single leading "

"underscore inserted, is inserted in front of the identifier, e.g., the "

"identifier ``__spam`` occurring in a class named ``Foo``, ``_Foo`` or "

"``__Foo`` is transformed to ``_Foo__spam``."

msgstr ""

#: reference/expressions.rst:124

msgid ""

"If the class name consists only of underscores, the transformation is the "

"identity, e.g., the identifier ``__spam`` occurring in a class named ``_`` "

"or ``__`` is left as is."

msgstr ""

#: reference/expressions.rst:131

msgid "Literals"

msgstr "Littéraux"

#: reference/expressions.rst:135

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

#, fuzzy

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

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

msgid "Parenthesized forms"

msgstr "Formes parenthésées"

#: reference/expressions.rst:166

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

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

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

msgid ""

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

"comma. 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:194

msgid "Displays for lists, sets and dictionaries"

msgstr "Agencements des listes, ensembles et dictionnaires"

#: reference/expressions.rst:198

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

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

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

#: reference/expressions.rst:203

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

msgid "Common syntax elements for comprehensions are:"

msgstr ""

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

"suivants :"

#: reference/expressions.rst:219

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

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

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

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

#, fuzzy

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

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, après cette expression de tête, "

"une clause :keyword:`!for` ou :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 "

"des clauses :keyword:`!async for`, des expressions :keyword:`!await` ou "

"d'autres compréhensions asynchrones, 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:251

msgid ""

"If a comprehension contains :keyword:`!async for` clauses, or if it "

"contains :keyword:`!await` expressions or other asynchronous comprehensions "

"anywhere except the iterable expression in the leftmost :keyword:`!for` "

"clause, 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 ""

#: reference/expressions.rst:258

msgid "Asynchronous comprehensions were introduced."

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

#: reference/expressions.rst:439

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

# suit un ':'

#: reference/expressions.rst:264

msgid ""

"Asynchronous comprehensions are now allowed inside comprehensions in "

"asynchronous functions. Outer comprehensions implicitly become asynchronous."

msgstr ""

"les compréhensions asynchrones sont maintenant autorisées dans les "

"compréhensions des fonctions asynchrones. Les compréhensions englobantes "

"deviennent implicitement asynchrones."

#: reference/expressions.rst:273

msgid "List displays"

msgstr "Agencements de listes"

#: reference/expressions.rst:283

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

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

msgid "Set displays"

msgstr "Agencements d'ensembles"

#: reference/expressions.rst:308

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

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 mutable, 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:320

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

msgid "Dictionary displays"

msgstr "Agencements de dictionnaires"

#: reference/expressions.rst:338

msgid ""

"A dictionary display is a possibly empty series of dict items (key/value "

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

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

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

#: reference/expressions.rst:349

msgid ""

"If a comma-separated sequence of dict items 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 value. This "

"means that you can specify the same key multiple times in the dict item "

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

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

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 dict items "

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

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

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

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 value (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 mutables). 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:381

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

msgid "Generator expressions"

msgstr "Expressions génératrices"

#: reference/expressions.rst:398

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

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

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

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

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

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`. 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:431

msgid "Asynchronous generator expressions were introduced."

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

#: reference/expressions.rst:434

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

msgid "Yield expressions"

msgstr "Expressions ``yield``"

#: reference/expressions.rst:459

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

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

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

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

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

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

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

"`~python-grammar:expression_list` à l'appelant du générateur ou ``None`` si :"

"token:`~python-grammar:expression_list` est omis. 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 (généralement *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:504

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

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

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

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

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

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

#: reference/expressions.rst:542

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

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

#: reference/expressions.rst:543

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

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

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

#: reference/expressions.rst:546

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

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

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

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

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

#: reference/expressions.rst:554

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

msgid "Generator-iterator methods"

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

#: reference/expressions.rst:563

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

#: reference/expressions.rst:566

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

#, fuzzy

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:yield_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:583

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

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

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

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

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

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

"Cependant, pour assurer la rétrocompatibilité, la deuxième signature est "

"prise en charge, suivant une convention des anciennes versions de Python. "

"L'argument *type* doit être une classe d'exception et *value* doit être une "

"instance d'exception. Si *value* n'est pas fournie, le constructeur de "

"*type* est appelé pour obtenir une instance. Si *traceback* est fournie, "

"elle est liée sur l'exception, sinon tout attribut :attr:`~BaseException."