From 012906e70364c01439b21a0ccf8aba2eb4712d5d Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Fri, 25 May 2018 23:06:54 +0200 Subject: [PATCH] =?UTF-8?q?'Reference=20-=20Expressions'=20translation.=20?= =?UTF-8?q?Travail=20en=20cours.=20Vocabulaire=20=C3=A0=20valider=20(non?= =?UTF-8?q?=20exhaustif)=20:=20display=20-=20agencement=20yield=20expressi?= =?UTF-8?q?on=20-=20expression=20yield=20primary=20-=20primaire=20(n.f.)?= =?UTF-8?q?=20subscription=20-=20s=C3=A9lection?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- glossary.po | 18 +- reference/expressions.po | 485 +++++++++++++++++++++++++++++++++++++-- 2 files changed, 469 insertions(+), 34 deletions(-) diff --git a/glossary.po b/glossary.po index 19e5a9ae..35ad4f68 100644 --- a/glossary.po +++ b/glossary.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-01-04 15:51+0100\n" -"PO-Revision-Date: 2018-04-14 17:16+0200\n" +"PO-Revision-Date: 2018-05-25 23:03+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" @@ -1515,7 +1515,7 @@ msgstr "" #: ../Doc/glossary.rst:630 msgid "mapping" -msgstr "mapping" +msgstr "Tableau de correspondances" #: ../Doc/glossary.rst:632 msgid "" @@ -1526,13 +1526,13 @@ msgid "" "`collections.defaultdict`, :class:`collections.OrderedDict` and :class:" "`collections.Counter`." msgstr "" -"Conteneur permettant de rechercher des éléments à partir de clés et " -"implémentant les méthodes spécifiées dans les :ref:`classes de base " -"abstraites ` :class:`collections.abc." -"Mapping` ou :class:`collections.abc.MutableMapping`. Les classes suivantes " -"sont des exemples de mapping: :class:`dict`, :class:`collections." -"defaultdict`, :class:`collections.OrderedDict` et :class:`collections." -"Counter`." +"(*mapping* en anglais) Conteneur permettant de rechercher des éléments à " +"partir de clés et implémentant les méthodes spécifiées dans les :ref:" +"`classes de base abstraites ` :class:" +"`collections.abc.Mapping` ou :class:`collections.abc.MutableMapping`. Les " +"classes suivantes sont des exemples de tableaux de correspondances : :class:" +"`dict`, :class:`collections.defaultdict`, :class:`collections.OrderedDict` " +"et :class:`collections.Counter`." #: ../Doc/glossary.rst:638 msgid "meta path finder" diff --git a/reference/expressions.po b/reference/expressions.po index d3716eeb..c8344fd8 100644 --- a/reference/expressions.po +++ b/reference/expressions.po @@ -8,23 +8,24 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-09-21 09:15+0200\n" -"PO-Revision-Date: 2017-08-10 00:54+0200\n" +"PO-Revision-Date: 2018-05-25 23:00+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" -"X-Generator: Poedit 1.8.11\n" +"X-Generator: Poedit 2.0.2\n" #: ../Doc/reference/expressions.rst:6 msgid "Expressions" -msgstr "" +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 "" @@ -32,16 +33,21 @@ msgid "" "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 "" +msgstr "Conversions arithmétiques" #: ../Doc/reference/expressions.rst:30 msgid "" @@ -49,21 +55,31 @@ msgid "" "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 "" @@ -71,10 +87,13 @@ msgid "" "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 "" +msgstr "Atomes" #: ../Doc/reference/expressions.rst:53 msgid "" @@ -82,10 +101,14 @@ msgid "" "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 "" +msgstr "Identifiants (noms)" #: ../Doc/reference/expressions.rst:70 msgid "" @@ -93,6 +116,9 @@ msgid "" "`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 "" @@ -100,6 +126,9 @@ msgid "" "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 "" @@ -116,14 +145,30 @@ msgid "" "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é " +"` 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 "" +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 "" @@ -132,6 +177,11 @@ msgid "" "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 "" @@ -141,15 +191,22 @@ msgid "" "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 "" +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 "" @@ -157,6 +214,10 @@ msgid "" "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 "" @@ -164,6 +225,10 @@ msgid "" "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 "" @@ -172,30 +237,43 @@ msgid "" "*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 "" +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 "" +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 "" @@ -206,12 +284,22 @@ msgid "" "clauses a block, nesting from left to right, and evaluating the expression " "to produce an element each time the innermost block is reached." msgstr "" +"Une compréhension est constituée par une seule expression suivie par au " +"moins une clause :keyword:`for` et zéro ou plus clauses :keyword:`for` ou :" +"keyword:`if`. Dans ce cas, les éléments du nouveau conteneur sont ceux qui " +"auraient été produits si l'on avait considéré toutes les clauses :keyword:" +"`for` ou :keyword:`if` comme des blocs, imbriqués de la gauche vers la " +"droite, et évalué l'expression pour produire un élément à chaque fois que le " +"bloc le plus imbriqué était atteint." #: ../Doc/reference/expressions.rst:186 msgid "" "Note that the comprehension is executed in a separate scope, so names " "assigned to in the target list don't \"leak\" into the enclosing scope." msgstr "" +"Notez que la compréhension est exécutée dans une portée séparée, les noms " +"assignés dans la liste cible ne pouvant pas \"fuir\" en dehors de cette " +"portée." #: ../Doc/reference/expressions.rst:189 msgid "" @@ -226,16 +314,28 @@ msgid "" "comprehension may suspend the execution of the coroutine function in which " "it appears. See also :pep:`530`." msgstr "" +"Depuis Python 3.6, dans une fonction :keyword:`async def`, une clause :" +"keyword:`async for` peut être utilisée pour itérer sur un :term:`itérateur " +"asynchrone `. Une compréhension dans une fonction :" +"keyword:`async def` consiste alors à avoir une clause :keyword:`for` or :" +"keyword:`async for` suivie par des clauses :keyword:`for` or :keyword:`async " +"for` additionnelles facultatives et, possiblement, des expressions :keyword:" +"`await`. Si la compréhension contient soit des clauses :keyword:`async for`, " +"soit des expressions :keyword:`await`, elle est appelée :dfn:`compréhension " +"asynchrone`. Une compréhension asynchrone peut susprendre l'exécution de la " +"fonction coroutine dans laquelle elle apparaît. Voir aussi la :pep:`530`." #: ../Doc/reference/expressions.rst:204 msgid "List displays" -msgstr "" +msgstr "Agencements de listes" #: ../Doc/reference/expressions.rst:212 msgid "" "A list display is a possibly empty series of expressions enclosed in square " "brackets:" msgstr "" +"Un agencement de liste est une suite (possiblement vide) d'expressions à " +"l'intérieur de crochets :" #: ../Doc/reference/expressions.rst:218 msgid "" @@ -246,16 +346,26 @@ msgid "" "is supplied, the list is constructed from the elements resulting from the " "comprehension." msgstr "" +"Un agencement de liste produit un nouvel objet liste, dont le contenu est " +"spécifié soit par une liste d'expression soit par une compréhension. Quand " +"une liste d'expressions (dont les éléments sont séparés par des virgules) " +"est fournie, ces éléments sont évalués de la gauche vers la droite et placés " +"dans l'objet liste, dans cet ordre. Quand c'est une compréhension qui est " +"fournie, la liste est construite à partir des éléments produits par la " +"compréhension." #: ../Doc/reference/expressions.rst:228 msgid "Set displays" -msgstr "" +msgstr "Agencements d'ensembles" #: ../Doc/reference/expressions.rst:233 msgid "" "A set display is denoted by curly braces and distinguishable from dictionary " "displays by the lack of colons separating keys and values:" msgstr "" +"Un agencement d'ensemble (type *set*) est délimité par des accolades et se " +"distingue de l'agencement d'un dictionnaire par le fait qu'il n'y a pas de " +"\"deux points\" ``:`` pour séparer les clés et les valeurs :" #: ../Doc/reference/expressions.rst:239 msgid "" @@ -266,26 +376,36 @@ msgid "" "supplied, the set is constructed from the elements resulting from the " "comprehension." msgstr "" +"Un agencement d'ensemble produit un nouvel objet ensemble muable, le contenu " +"étant spécifié soit par une séquence d'expression, soit par une " +"compréhension. Quand une liste (dont les éléments sont séparés par des " +"virgules) est fournie, ses éléments sont évalués de la gauche vers la droite " +"et ajoutés à l'objet ensemble. Quand une compréhension est fournie, " +"l'ensemble est construit à partir des éléments produits par la compréhension." #: ../Doc/reference/expressions.rst:245 msgid "" "An empty set cannot be constructed with ``{}``; this literal constructs an " "empty dictionary." msgstr "" +"Un ensemble vide ne peut pas être construit par ``{}`` ; cette écriture " +"construit un dictionnaire vide." #: ../Doc/reference/expressions.rst:252 msgid "Dictionary displays" -msgstr "" +msgstr "Agencements de dictionnaires" #: ../Doc/reference/expressions.rst:258 msgid "" "A dictionary display is a possibly empty series of key/datum pairs enclosed " "in curly braces:" msgstr "" +"Un agencement de dictionnaire est une série (possiblement vide) de couples " +"clés-valeurs entourée par des accolades :" #: ../Doc/reference/expressions.rst:267 msgid "A dictionary display yields a new dictionary object." -msgstr "" +msgstr "Un agencement de dictionnaire produit un nouvel objet dictionnaire." #: ../Doc/reference/expressions.rst:269 msgid "" @@ -296,6 +416,13 @@ msgid "" "key/datum list, and the final dictionary's value for that key will be the " "last one given." msgstr "" +"Si une séquence (dont les éléments sont séparés par des virgules) de couples " +"clés-valeurs est fournie, les couples sont évalués de la gauche vers la " +"droite pour définir les entrées du dictionnaire : chaque objet clé est " +"utilisé comme clé dans le dictionnaire pour stocker la donnée " +"correspondante. Cela signifie que vous pouvez spécifier la même clé " +"plusieurs fois dans la liste des couples clés-valeurs et, dans ce cas, la " +"valeur finalement stockée dans le dictionnaire est la dernière donnée." #: ../Doc/reference/expressions.rst:277 msgid "" @@ -304,10 +431,18 @@ msgid "" "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 `. Chaque " +"élément du tableau de correspondances est ajouté au nouveau dictionnaire. " +"Les valeurs les plus récentes remplacent les valeurs déjà définies par des " +"couples clés-valeurs antérieurs ou par d'autres dépaquetages de " +"dictionnaires antérieurs." #: ../Doc/reference/expressions.rst:282 msgid "Unpacking into dictionary displays, originally proposed by :pep:`448`." msgstr "" +"le dépaquetage peut se faire vers un agencement de dictionnaire, proposé à " +"l'origine par la :pep:`448`." #: ../Doc/reference/expressions.rst:285 msgid "" @@ -316,6 +451,11 @@ msgid "" "clauses. When the comprehension is run, the resulting key and value elements " "are inserted in the new dictionary in the order they are produced." msgstr "" +"Une compréhension de dictionnaire, au contraire des compréhensions de listes " +"ou d'ensembles, requiert deux expressions séparées par une virgule et " +"suivies par les clauses usuelles \"for\" et \"if\". Quand la compréhension " +"est exécutée, les éléments clés-valeurs sont insérés dans le nouveau " +"dictionnaire dans l'ordre dans lequel ils sont produits." #: ../Doc/reference/expressions.rst:293 msgid "" @@ -325,6 +465,12 @@ msgid "" "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 " +"`, ce qui exclut tous les objets muables). Les collisions entre " +"les clés dupliquées ne sont pas détectées ; la dernière valeur (celle qui " +"apparaît le plus à droite dans l'agencement) stockée prévaut pour une clé " +"donnée." #: ../Doc/reference/expressions.rst:303 msgid "Generator expressions" @@ -333,6 +479,8 @@ msgstr "Générateurs (expressions)" #: ../Doc/reference/expressions.rst:308 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:313 msgid "" @@ -340,6 +488,9 @@ msgid "" "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:317 msgid "" @@ -352,12 +503,23 @@ msgid "" "immediately since they may depend on the previous :keyword:`for` loop. For " "example: ``(x*y for x in range(10) for y in bar(x))``." msgstr "" +"Les variables utilisées dans une expression générateur sont évaluées " +"paresseusement, au moment où la méthode :meth:`~generator.__next__` de " +"l'objet générateur est appelée (de la même manière que pour les générateurs " +"classiques). Cependant, la clause :keyword:`for` la plus à gauche est " +"immédiatement évaluée, de manière à ce qu'une erreur dans cette partie " +"puisse être vue avant tout autre erreur dans le code qui gère l'expression " +"générateur. Les clauses :keyword:`for` suivantes ne peuvent pas être " +"évaluées immédiatement car elles peuvent dépendre de la précédente boucle :" +"keyword:`for`. Par exemple, ``(x*y for x in range(10) for y in truc(x))``." #: ../Doc/reference/expressions.rst:326 msgid "" "The parentheses can be omitted on calls with only one argument. See " "section :ref:`calls` for details." msgstr "" +"Les parenthèses peuvent être omises pour les appels qui ne possèdent qu'un " +"seul argument. Voir la section :ref:`calls` pour les détails." #: ../Doc/reference/expressions.rst:329 msgid "" @@ -369,10 +531,18 @@ msgid "" "asynchronous generator expression yields a new asynchronous generator " "object, which is an asynchronous iterator (see :ref:`async-iterators`)." msgstr "" +"Depuis Python 3.6, si le générateur apparaît dans une fonction :keyword:" +"`async def`, alors la clause :keyword:`async for` et les expressions :" +"keyword:`await` sont permises comme pour une compréhension asynchrone. Si " +"une expression générateur contient soit des clauses :keyword:`async for`, " +"soit des expressions :keyword:`await`, alors on l'appelle :dfn:`expression " +"générateur asynchrone`. Une expression générateur asynchrone produit un " +"nouvel objet générateur asynchrone qui est un itérateur asynchrone (voir :" +"ref:`async-iterators`)." #: ../Doc/reference/expressions.rst:341 msgid "Yield expressions" -msgstr "" +msgstr "Expressions yield" #: ../Doc/reference/expressions.rst:352 msgid "" @@ -383,6 +553,13 @@ msgid "" "`async def` function's body causes that coroutine function to be an " "asynchronous generator. For example::" msgstr "" +"Une expression yield est utilisée pour définir une fonction :term:" +"`générateur` ou une fonction :term:`générateur asynchrone` et ne peut donc " +"être utilisée que dans le corps de la définition d'une fonction. " +"L'utilisation d'une expression yield dans le corps d'une fonction entraîne " +"que cette fonction devient un générateur et son utilisation dans le corps " +"d'une fonction :keyword:`async def` entraine que cette fonction coroutine " +"devient un générateur asynchrone. Par exemple ::" #: ../Doc/reference/expressions.rst:365 msgid "" @@ -390,6 +567,9 @@ msgid "" "functions are described separately in section :ref:`asynchronous-generator-" "functions`." msgstr "" +"Les fonctions générateurs sont décrites plus loin alors que les fonctions " +"générateurs asynchrones sont décrites séparément dans la section :ref:" +"`asynchronous-generator-functions`." #: ../Doc/reference/expressions.rst:369 msgid "" @@ -410,6 +590,23 @@ msgid "" "`~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:388 msgid "" @@ -419,6 +616,12 @@ msgid "" "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:394 msgid "" @@ -428,6 +631,12 @@ msgid "" "meth:`~generator.close` method will be called, allowing any pending :keyword:" "`finally` clauses to execute." msgstr "" +"Les expressions yield sont autorisées partout dans un bloc :keyword:`try`. " +"Si l'exécution du générateur ne reprend pas avant qu'il ne soit finalisé " +"(parce que son compteur de référence est tombé à zéro ou parce qu'il est " +"nettoyé par le ramasse-miettes), la méthode :meth:`~generator.close` du " +"générateur-itérateur est appelée, ce qui permet l'exécution de toutes les " +"clauses :keyword:`finally` en attente." #: ../Doc/reference/expressions.rst:400 msgid "" @@ -440,6 +649,15 @@ msgid "" "exc:`AttributeError` or :exc:`TypeError`, while :meth:`~generator.throw` " "will just raise the passed in exception immediately." msgstr "" +"L'utilisation de ``yield from `` traite l'expression passée en " +"paramètre comme un sous-itérateur. Toutes les valeurs produites par ce sous-" +"itérateur sont directement passées à l'appelant des méthodes du générateur " +"courant. Toute valeur passée par :meth:`~generator.send` ou toute exception " +"passée par :meth:`~generator.throw` est transmise à l'itérateur sous-jacent " +"s'il possède les méthodes appropriées. Si ce n'est pas le cas, alors :meth:" +"`~generator.send` lève une :exc:`AttributeError` ou une :exc:`TypeError`, " +"alors que :meth:`~generator.throw` ne fait que propager l'exception " +"immédiatement." #: ../Doc/reference/expressions.rst:409 msgid "" @@ -449,16 +667,25 @@ msgid "" "`StopIteration`, or automatically when the sub-iterator is a generator (by " "returning a value from the sub-generator)." msgstr "" +"Quand l'itérateur sous-jacent a terminé, l'attribut :attr:`~StopIteration." +"value` de l'instance :exc:`StopIteration` qui a été levée devient la valeur " +"produite par l'expression yield. Elle peut être définie explicitement quand " +"vous levez :exc:`StopIteration` ou automatiquement que le sous-itérateur est " +"un générateur (en renvoyant une valeur par le sous-générateur)." #: ../Doc/reference/expressions.rst:415 msgid "Added ``yield from `` to delegate control flow to a subiterator." msgstr "" +"``yield from `` a été ajoutée pour déléguer le contrôle du flot " +"d'exécution à un sous-itérateur." #: ../Doc/reference/expressions.rst:418 msgid "" "The parentheses may be omitted when the yield expression is the sole " "expression on the right hand side of an assignment statement." msgstr "" +"Les parenthèses peuvent être omises quand l'expression yield est la seule " +"expression à droite de l'instruction de l'instruction d'assignation." #: ../Doc/reference/expressions.rst:424 msgid ":pep:`255` - Simple Generators" @@ -469,42 +696,53 @@ msgid "" "The proposal for adding generators and the :keyword:`yield` statement to " "Python." msgstr "" +"La proposition d'ajouter à Python des générateurs et l'instruction :keyword:" +"`yield`." #: ../Doc/reference/expressions.rst:428 msgid ":pep:`342` - Coroutines via Enhanced Generators" -msgstr "" +msgstr ":pep:`342` - Coroutines *via* des générateurs améliorés" #: ../Doc/reference/expressions.rst:427 msgid "" "The proposal to enhance the API and syntax of generators, making them usable " "as simple coroutines." msgstr "" +"Proposition d'améliorer l'API et la syntaxe des générateurs, de manière à " +"pouvoir les utiliser comme de simples coroutines." #: ../Doc/reference/expressions.rst:431 msgid ":pep:`380` - Syntax for Delegating to a Subgenerator" -msgstr "" +msgstr ":pep:`380` - Syntaxe pour déléguer à un sous-générateur" #: ../Doc/reference/expressions.rst:431 msgid "" "The proposal to introduce the :token:`yield_from` syntax, making delegation " "to sub-generators easy." msgstr "" +"Proposition d'introduire la syntaxe :token:`yield_from`, de manière à " +"déléguer facilement l'exécution à un sous-générateur." #: ../Doc/reference/expressions.rst:438 msgid "Generator-iterator methods" -msgstr "" +msgstr "Méthodes des générateurs-itérateurs" #: ../Doc/reference/expressions.rst:440 msgid "" "This subsection describes the methods of a generator iterator. They can be " "used to control the execution of a generator function." msgstr "" +"Cette sous-section décrit les méthodes des générateurs-itérateurs. Elles " +"peuvent être utilisées pour contrôler l'exécution des fonctions générateurs." #: ../Doc/reference/expressions.rst:443 msgid "" "Note that calling any of the generator methods below when the generator is " "already executing raises a :exc:`ValueError` exception." msgstr "" +"Notez que l'appel à une méthode ci-dessous d'un générateur alors que le " +"générateur est déjà en cours d'exécution lève une exception :exc:" +"`ValueError`." #: ../Doc/reference/expressions.rst:451 msgid "" @@ -517,12 +755,22 @@ msgid "" "generator exits without yielding another value, a :exc:`StopIteration` " "exception is raised." msgstr "" +"Démarre l'exécution d'une fonction générateur ou la reprend à la dernière " +"expression yield exécutée. Quand une fonction générateur est reprise par une " +"méthode :meth:`~generator.__next__`, l'expression yield en cours s'évalue " +"toujours à :const:`None`. L'exécution continue ensuite jusqu'à l'expression " +"yield suivante, où le générateur est à nouveau suspendu et la valeur de :" +"token:`expression_list` est renvoyée à la méthode :meth:`__next__` de " +"l'appelant. Si le générateur termine sans donner une autre valeur, une " +"exception :exc:`StopIteration` est levée." #: ../Doc/reference/expressions.rst:460 msgid "" "This method is normally called implicitly, e.g. by a :keyword:`for` loop, or " "by the built-in :func:`next` function." msgstr "" +"Cette méthode est normalement appelée implicitement, par exemple par une " +"boucle :keyword:`for` ou par la fonction native :func:`next`." #: ../Doc/reference/expressions.rst:466 msgid "" @@ -534,6 +782,13 @@ msgid "" "called with :const:`None` as the argument, because there is no yield " "expression that could receive the value." msgstr "" +"Reprend l'exécution et \"envoie\" une valeur à la fonction générateur. " +"L'argument *value* devient le résultat de l'expression yield courante. La " +"méthode :meth:`send` renvoie la valeur suivante produite par le générateur " +"ou lève :exc:`StopIteration` si le générateur termine sans produire de " +"nouvelle valeur. Quand :meth:`send` est utilisée pour démarrer le " +"générateur, elle doit avoir :const:`None` comme argument, car il n'y a " +"aucune expression yield qui peut recevoir la valeur." #: ../Doc/reference/expressions.rst:477 msgid "" @@ -544,6 +799,12 @@ msgid "" "exception, or raises a different exception, then that exception propagates " "to the caller." msgstr "" +"Leve 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:488 msgid "" @@ -555,6 +816,13 @@ msgid "" "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:499 msgid "Examples" @@ -565,16 +833,20 @@ 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:528 msgid "" "For examples using ``yield from``, see :ref:`pep-380` in \"What's New in " "Python.\"" msgstr "" +"Pour des exemples d'utilisation de ``yield from``, lisez la :ref:`pep-380` " +"dans \"Les nouveautés de Python\"." #: ../Doc/reference/expressions.rst:534 msgid "Asynchronous generator functions" -msgstr "" +msgstr "Fonctions générateurs asynchrones" #: ../Doc/reference/expressions.rst:536 msgid "" @@ -582,6 +854,9 @@ msgid "" "keyword:`async def` further defines the function as a :term:`asynchronous " "generator` function." msgstr "" +"La présence d'une expression yield dans une fonction ou une méthode définie " +"en utilisant :keyword:`async def` transforme cette fonction en fonction :" +"term:`générateur asynchrone`." #: ../Doc/reference/expressions.rst:540 msgid "" @@ -592,6 +867,12 @@ msgid "" "coroutine function analogously to how a generator object would be used in a :" "keyword:`for` statement." msgstr "" +"Quand une fonction générateur asynchrone est appelée, elle renvoie un " +"itérateur asynchrone, autrement appelé objet générateur asynchrone. Cet " +"objet contrôle l'exécution de la fonction générateur. Un objet générateur " +"asynchrone est typiquement utilisé dans une instruction :keyword:`async for` " +"à l'intérieur d'une fonction coroutine de la même manière qu'un objet " +"générateur serait utilisé dans une instruction :keyword:`for`." #: ../Doc/reference/expressions.rst:547 msgid "" @@ -610,6 +891,22 @@ msgid "" "is :const:`None`. Otherwise, if :meth:`~agen.asend` is used, then the result " "will be the value passed in to that method." msgstr "" +"L'appel d'une méthode du générateur asynchrone renvoie un objet :term:" +"`awaitable` et l'exécution commence au moment où l'on atteint une " +"instruction await le concernant. À ce moment, l'exécution se déroule jusqu'à " +"la première expression yield, où elle est suspendue et renvoie la valeur de :" +"token:`expression_list` à la coroutine en attente. Comme pour un générateur, " +"la suspension signifie que tous les états locaux sont conservés, y compris " +"les liaisons des variables locales, le pointeur d'instruction, la pile " +"d'évaluation interne et l'état de tous les gestionnaires d'exceptions. " +"Lorsque l'exécution reprend parce que l'appelant a atteint une instruction " +"*await* sur l'objet suivant retourné par les méthodes du générateur " +"asynchrone, la fonction s'exécute exactement comme si l'expression yield " +"n'avait été qu'un simple appel externe. La valeur de l'expression yield au " +"moment de la reprise dépend de la méthode qui a relancé l'exécution. Si " +"c'est :meth:`~agen.__anext__` qui a été utilisée, alors le résultat est :" +"const:`None`. Sinon, si c'est :meth:`~agen.asend` qui a été utilisée, alors " +"le résultat est la valeur transmise à cette méthode." #: ../Doc/reference/expressions.rst:563 msgid "" @@ -624,6 +921,17 @@ msgid "" "the resulting coroutine object, thus allowing any pending :keyword:`finally` " "clauses to execute." msgstr "" +"Dans une fonction générateur asynchrone, les expressions yield sont " +"autorisées n'importe où dans une construction :keyword:`try`. Cependant, si " +"l'exécution d'un générateur asynchrone n'a pas repris avant que le " +"générateur ne soit finalisé (parce que son compteur de référence a atteint " +"zéro ou parce qu'il est nettoyé par le ramasse-miettes), alors une " +"expression yield dans une construction :keyword:`try` pourrait ne pas " +"atteindre la clause :keyword:`finally` en attente. Dans ce cas, c'est la " +"responsabilité de la boucle d'événements ou du programmateur exécutant le " +"générateur asynchrone d'appeler la méthode :meth:`~agen.aclose` du " +"générateur asynchrone et d'exécuter l'objet coroutine résultant, permettant " +"ainsi à toute clause :keyword:`finally` en attente d'être exécutée." #: ../Doc/reference/expressions.rst:574 msgid "" @@ -636,22 +944,36 @@ msgid "" "*finalizer* method see the implementation of ``asyncio.Loop." "shutdown_asyncgens`` in :source:`Lib/asyncio/base_events.py`." msgstr "" +"Pour effectuer correctement la finalisation, une boucle d'événements doit " +"définir une fonction *finalizer* qui prend un générateur-itérateur " +"asynchrone, appelle sans doute :meth:`~agen.aclose` et exécute la coroutine. " +"Ce *finalizer* peut s'enregistrer en appelant :func:`sys." +"set_asyncgen_hooks`. Lors de la première itération, un générateur-itérateur " +"asynchrone stocke le *finalizer* enregistré à appeler lors de la " +"finalisation. Pour un exemple de référence relatif à une méthode de " +"*finalizer*, regardez l'implémentation de ``asyncio.Loop." +"shutdown_asyncgens`` dans :source:`Lib/asyncio/base_events.py`." #: ../Doc/reference/expressions.rst:583 msgid "" "The expression ``yield from `` is a syntax error when used in an " "asynchronous generator function." msgstr "" +"L'expression ``yield from `` produit une erreur de syntaxe quand elle " +"est utilisée dans une fonction générateur asynchrone." #: ../Doc/reference/expressions.rst:590 msgid "Asynchronous generator-iterator methods" -msgstr "" +msgstr "Méthodes des générateurs-itérateurs asynchrones" #: ../Doc/reference/expressions.rst:592 msgid "" "This subsection describes the methods of an asynchronous generator iterator, " "which are used to control the execution of a generator function." msgstr "" +"Cette sous-section décrit les méthodes des générateurs-itérateurs " +"asynchrones. Elles sont utilisées pour contrôler l’exécution des fonctions " +"générateurs." #: ../Doc/reference/expressions.rst:600 msgid "" @@ -666,11 +988,24 @@ msgid "" "another value, the awaitable instead raises an :exc:`StopAsyncIteration` " "exception, signalling that the asynchronous iteration has completed." msgstr "" +"Renvoie un *awaitable* qui, quand il a la main, démarre l'exécution du " +"générateur asynchrone ou reprend son exécution à l'endroit de la dernière " +"expression yield exécutée. Quand une fonction générateur asynchrone est " +"reprise par une méthode :meth:`~agen.__anext__`, l’expression yield en cours " +"s’évalue toujours à :const:`None` dans le *awaitable* renvoyé, et elle " +"continue son exécution jusqu’à l’expression yield suivante. La valeur de :" +"token:`expression_list` de l'expression yield est la valeur de l'exception :" +"exc:`StopIteration` levée par la coroutine qui termine. Si le générateur " +"asynchrone termine sans produire d'autre valeur, le *awaitable* lève une " +"exception :exc:`StopAsyncIteration` qui signale que l'itération asynchrone " +"est terminée." #: ../Doc/reference/expressions.rst:612 msgid "" "This method is normally called implicitly by a :keyword:`async for` loop." msgstr "" +"Cette méthode est normalement appelée implicitement par une boucle :keyword:" +"`async for`." #: ../Doc/reference/expressions.rst:617 msgid "" @@ -686,6 +1021,16 @@ msgid "" "`None` as the argument, because there is no yield expression that could " "receive the value." msgstr "" +"Renvoie un *awaitable* qui, lorsqu'il a la main, reprend l'exécution du " +"générateur asynchrone. Comme pour la méthode :meth:`~generator.send()` d'un " +"générateur, elle \"envoie\" une valeur *value* à la fonction générateur " +"asynchrone et cet argument devient le résultat de l'expression yield " +"courante. Le *awaitable* renvoyé par la méthode :meth:`asend` renvoie la " +"valeur suivante produite par le générateur comme valeur de l'exception :exc:" +"`StopIteration` levée ou lève :exc:`StopAsyncIteration` si le générateur " +"asynchrone termine sans produire de nouvelle valeur. Quand :meth:`asend` est " +"appelée pour démarrer le générateur asynchrone, l'argument doit être :const:" +"`None` car il n'y a pas d'expression yield pour recevoir la valeur." #: ../Doc/reference/expressions.rst:632 msgid "" @@ -698,6 +1043,14 @@ msgid "" "exception, or raises a different exception, then when the awaitable is run " "that exception propagates to the caller of the awaitable." msgstr "" +"Renvoie un *awaitable* qui lève une exception du type ``type`` à l'endroit " +"où le générateur asynchrone a été mis en pause et renvoie la valeur suivante " +"produite par la fonction générateur comme valeur de l'exception :exc:" +"`StopIteration` qui a été levée. Si le générateur asynchrone termine sans " +"produire de nouvelle valeur, une exception :exc:`StopAsyncIteration` est " +"levée par le *awaitable*. Si la fonction générateur ne traite pas " +"l'exception reçue ou lève une autre exception alors, quand le *awaitable* " +"est lancé, cette exception est propagée vers l'appelant du *awaitable*." #: ../Doc/reference/expressions.rst:647 msgid "" @@ -714,24 +1067,41 @@ msgid "" "due to an exception or normal exit, then further calls to :meth:`aclose` " "will return an awaitable that does nothing." msgstr "" +"Renvoie un *awaitable* qui, quand il s'exécute, lève une exception :exc:" +"`GeneratorExit` dans la fonction générateur asynchrone à l'endroit où le " +"générateur était en pause. Si la fonction générateur asynchrone termine " +"normalement, est déjà fermée ou lève :exc:`GeneratorExit` (parce qu'elle ne " +"gère pas l'exception), alors le *awaitable* renvoyé lève une exception :exc:" +"`StopIteration`. Tout nouveau *awaitable* produit par un appel postérieur au " +"générateur asynchrone lève une exception :exc:`StopAsyncIteration`. Si le " +"générateur asynchrone produit une valeur, une :exc:`RuntimeError` est levée " +"par le *awaitable*. Si le générateur asynchrone lève une autre exception, " +"elle est propagée à l'appelant du *awaitable*. Si le générateur asynchrone a " +"déjà terminé (soit par une exception, soit normalement), alors tout nouvel " +"appel à :meth:`aclose` renvoie un *awaitable* qui ne fait rien." #: ../Doc/reference/expressions.rst:663 msgid "Primaries" -msgstr "" +msgstr "Primaires" #: ../Doc/reference/expressions.rst:667 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:677 msgid "Attribute references" -msgstr "" +msgstr "Références à des attributs" #: ../Doc/reference/expressions.rst:681 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:691 msgid "" @@ -743,16 +1113,27 @@ msgid "" "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:703 msgid "Subscriptions" -msgstr "" +msgstr "Sélections" #: ../Doc/reference/expressions.rst:716 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:722 msgid "" @@ -760,12 +1141,15 @@ msgid "" "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:726 msgid "" "For built-in objects, there are two types of objects that support " "subscription:" -msgstr "" +msgstr "Pour les objets natifs, deux types d'objets gèrent la sélection :" #: ../Doc/reference/expressions.rst:728 msgid "" @@ -774,12 +1158,21 @@ msgid "" "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:733 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 "" +"Si la primaire est une séquence, la liste d'expressions (*expression_list* " +"dans la grammaire) doit pouvoir être évaluée comme un entier ou une tranche " +"(comme expliqué dans la section suivante)." #: ../Doc/reference/expressions.rst:736 msgid "" @@ -793,16 +1186,29 @@ msgid "" "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:750 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:757 msgid "Slicings" -msgstr "" +msgstr "Tranches" #: ../Doc/reference/expressions.rst:769 msgid "" @@ -810,6 +1216,12 @@ msgid "" "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:782 msgid "" @@ -820,6 +1232,15 @@ msgid "" "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:794 msgid "" @@ -835,6 +1256,20 @@ msgid "" "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:815 msgid "Calls"