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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2016-10-30 10:42+0100\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

"MIME-Version: 1.0\n"

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

"Content-Transfer-Encoding: 8bit\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:193

msgid "List displays"

msgstr "Agencements de listes"

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

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

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

msgid "Set displays"

msgstr "Agencements d'ensembles"

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

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

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

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

msgid "Dictionary displays"

msgstr "Agencements de dictionnaires"

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

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

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

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

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

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

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

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

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

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

msgid "Generator expressions"

msgstr "Générateurs (expressions)"

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

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

msgstr ""

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

"entourée de parenthèses :"

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

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érateur 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:306

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

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

msgid "Yield expressions"

msgstr "Expressions ``yield``"

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

msgid ""

"The yield expression is only used when defining a :term:`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."

msgstr ""

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

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érateur 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érateur. 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:356

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érateurs 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érateur 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:362

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

msgid "Generator-iterator methods"

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

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

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

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

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

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

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

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érateur 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:456

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érateur a été "

"mise en pause. Si la fonction générateur 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:467

msgid "Examples"

msgstr "Exemples"

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

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

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

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

msgid "Primaries"

msgstr "Primaires"

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

msgid ""

"Primaries represent the most tightly bound operations of the language. Their "

"syntax is:"

msgstr ""

"Les primaires (*primary* dans la grammaire formelle ci-dessous) représentent "

"les opérations qui se lient au plus proche dans le langage. Leur syntaxe "

"est :"

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

msgid "Attribute references"

msgstr "Références à des attributs"

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

msgid "An attribute reference is a primary followed by a period and a name:"

msgstr ""

"Une référence à un attribut (*attributeref* dans la grammaire formelle ci-"

"dessous) est une primaire suivie par un point et un nom :"

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

msgid ""

"The primary must evaluate to an object of a type that supports attribute "

"references, which most objects do. This object is then asked to produce the "

"attribute whose name is the identifier. This production can be customized "

"by overriding the :meth:`__getattr__` method. If this attribute is not "

"available, the exception :exc:`AttributeError` is raised. Otherwise, the "

"type and value of the object produced is determined by the object. Multiple "

"evaluations of the same attribute reference may yield different objects."

msgstr ""

"La primaire doit s'évaluer à un objet d'un type qui gère les références aux "

"attributs, ce qui est le cas de la plupart des objets. Cet objet doit alors "

"produire l'attribut dont le nom est \"identifier\". Cette production peut "

"être personnalisée en surchargeant la méthode :meth:`__getattr__`. Si "

"l'attribut n'est pas disponible, une exception :exc:`AttributeError` est "

"levée. Sinon, le type et la valeur de l'objet produit sont déterminés par "

"l'objet. Plusieurs évaluations successives d'une référence à un même "

"attribut peuvent produire différents objets."

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

msgid "Subscriptions"

msgstr "Sélections"

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

msgid ""

"A subscription selects an item of a sequence (string, tuple or list) or "

"mapping (dictionary) object:"

msgstr ""

"Une sélection (*subscription* dans la grammaire formelle ci-dessous) désigne "

"un élément dans un objet séquence (chaîne, n-uplet ou liste) ou tableau de "

"correspondances (dictionnaire) :"

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

msgid ""

"The primary must evaluate to an object that supports subscription (lists or "

"dictionaries for example). User-defined objects can support subscription by "

"defining a :meth:`__getitem__` method."

msgstr ""

"La primaire doit s'appliquer à un objet qui gère les sélections (une liste "

"ou un dictionnaire par exemple). Les objets définis par l'utilisateur "

"peuvent gérer les sélections en définissant une méthode :meth:`__getitem__`."

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

msgid ""

"For built-in objects, there are two types of objects that support "

"subscription:"

msgstr "Pour les objets natifs, deux types d'objets gèrent la sélection :"

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

msgid ""

"If the primary is a mapping, the expression list must evaluate to an object "

"whose value is one of the keys of the mapping, and the subscription selects "

"the value in the mapping that corresponds to that key. (The expression list "

"is a tuple except if it has exactly one item.)"

msgstr ""

"Si la primaire est un tableau de correspondances, la liste d'expressions "

"(*expression_list* dans la grammaire formelle ci-dessous) doit pouvoir être "

"évaluée comme un objet dont la valeur est une des clés du tableau de "

"correspondances et la sélection désigne la valeur qui correspond à cette clé "

"(la liste d'expressions est un n-uplet sauf si elle comporte exactement un "

"élément)."

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

msgid ""

"If the primary is a sequence, the expression (list) must evaluate to an "

"integer or a slice (as discussed in the following section)."

msgstr ""

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

msgid ""

"The formal syntax makes no special provision for negative indices in "

"sequences; however, built-in sequences all provide a :meth:`__getitem__` "

"method that interprets negative indices by adding the length of the sequence "

"to the index (so that ``x[-1]`` selects the last item of ``x``). The "

"resulting value must be a nonnegative integer less than the number of items "

"in the sequence, and the subscription selects the item whose index is that "

"value (counting from zero). Since the support for negative indices and "

"slicing occurs in the object's :meth:`__getitem__` method, subclasses "

"overriding this method will need to explicitly add that support."

msgstr ""

"La syntaxe formelle ne traite pas des cas d'indices négatifs dans les "

"séquences ; cependant, toutes les séquences natives possèdent une méthode :"

"meth:`__getitem__` qui interprète les indices négatifs en ajoutant la "

"longueur de la séquence à l'indice (de manière à ce que ``x[-1]`` "

"sélectionne le dernier élément de ``x``). La valeur résultante doit être un "

"entier positif ou nul, inférieur au nombre d'éléments dans la séquence ; la "

"sélection désigne alors l'élément dont l'indice est cette valeur (en "

"comptant à partir de zéro). Comme la gestion des indices négatifs et des "

"tranches est faite par la méthode :meth:`__getitem__`, les sous-classes qui "

"surchargent cette méthode doivent aussi savoir les gérer, de manière "

"explicite."

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

msgid ""

"A string's items are characters. A character is not a separate data type "

"but a string of exactly one character."

msgstr ""

"Les éléments des chaînes sont des caractères. Un caractère n'est pas un type "

"en tant que tel, c'est une chaîne de longueur un."

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

msgid "Slicings"

msgstr "Tranches"

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

msgid ""

"A slicing selects a range of items in a sequence object (e.g., a string, "

"tuple or list). Slicings may be used as expressions or as targets in "

"assignment or :keyword:`del` statements. The syntax for a slicing:"

msgstr ""

"Une tranche (*slicing* dans la grammaire formelle ci-dessous) sélectionne un "

"intervalle d'éléments d'un objet séquence (par exemple une chaîne, un n-"

"uplet ou une liste, respectivement les types *string*, *tuple* et *list*). "

"Les tranches peuvent être utilisées comme des expressions ou des cibles dans "

"les assignations ou les instructions :keyword:`del`. La syntaxe est la "

"suivante :"

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

msgid ""

"There is ambiguity in the formal syntax here: anything that looks like an "

"expression list also looks like a slice list, so any subscription can be "

"interpreted as a slicing. Rather than further complicating the syntax, this "

"is disambiguated by defining that in this case the interpretation as a "

"subscription takes priority over the interpretation as a slicing (this is "

"the case if the slice list contains no proper slice)."

msgstr ""

"Il existe une ambigüité dans la syntaxe formelle ci-dessus : tout ce qui "

"ressemble à une liste d'expressions (*expression_list* vue avant) ressemble "

"aussi à une liste de tranches (*slice_list* dans la grammaire ci-dessus). En "

"conséquence, toute sélection (*subscription* dans la grammaire) peut être "

"interprétée comme une tranche. Plutôt que de compliquer encore la syntaxe, "

"l'ambigüité est levée en disant que, dans ce cas, l'interprétation en tant "

"que sélection (*subscription*) est prioritaire sur l'interprétation en tant "

"que tranche (c'est le cas si la liste de tranches (*slice_list*) ne contient "

"aucune tranche en tant que telle)."

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

msgid ""

"The semantics for a slicing are as follows. The primary is indexed (using "

"the same :meth:`__getitem__` method as normal subscription) with a key that "

"is constructed from the slice list, as follows. If the slice list contains "

"at least one comma, the key is a tuple containing the conversion of the "

"slice items; otherwise, the conversion of the lone slice item is the key. "

"The conversion of a slice item that is an expression is that expression. "

"The conversion of a proper slice is a slice object (see section :ref:"

"`types`) whose :attr:`~slice.start`, :attr:`~slice.stop` and :attr:`~slice."

"step` attributes are the values of the expressions given as lower bound, "

"upper bound and stride, respectively, substituting ``None`` for missing "

"expressions."

msgstr ""

"La sémantique pour une tranche est définie comme suit. La primaire est "

"indicée (en utilisant la même méthode :meth:`__getitem__` que pour les "

"sélections normales) avec une clé qui est construite à partir de la liste de "

"tranches (*slice_list* dans la grammaire), de cette manière : si la liste de "

"tranches contient au moins une virgule (``,``), la clé est un n-uplet "

"contenant la conversion des éléments de la tranche ; sinon, la conversion du "

"seul élément de la tranche est la clé. La conversion d'un élément de tranche "

"qui est une expression est cette expression. La conversion d'une tranche en "

"tant que telle est un objet *slice* (voir la section :ref:`types`) dont les "

"attributs :attr:`~slice.start`, :attr:`~slice.stop` et :attr:`~slice.step` "

"sont les valeurs des expressions données pour la borne inférieure "

"(*lower_bound* dans la grammaire), la borne supérieure (*upper_bound* dans "

"la grammaire) et le pas (*stride* dans la grammaire), respectivement. En cas "

"d'expression manquante, la valeur par défaut est ``None``."

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

msgid "Calls"

msgstr "Appels"

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

msgid ""

"A call calls a callable object (e.g., a :term:`function`) with a possibly "

"empty series of :term:`arguments <argument>`:"

msgstr ""

"Un appel (*call* dans la grammaire ci-dessous) appelle un objet appelable "

"(par exemple, une :term:`fonction <function>`) avec, possiblement, une liste "

"d'\\ :term:`arguments <argument>` :"

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

msgid ""

"An optional trailing comma may be present after the positional and keyword "

"arguments but does not affect the semantics."

msgstr ""

"Une virgule finale (optionnelle) peut être présente, après les arguments "

"positionnels et par mots-clés, mais elle n'affecte pas la sémantique."

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

msgid ""

"The primary must evaluate to a callable object (user-defined functions, "

"built-in functions, methods of built-in objects, class objects, methods of "

"class instances, and all objects having a :meth:`__call__` method are "

"callable). All argument expressions are evaluated before the call is "

"attempted. Please refer to section :ref:`function` for the syntax of "

"formal :term:`parameter` lists."

msgstr ""