From 012906e70364c01439b21a0ccf8aba2eb4712d5d Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Fri, 25 May 2018 23:06:54 +0200 Subject: [PATCH 1/2] =?UTF-8?q?'Reference=20-=20Expressions'=20translation?= =?UTF-8?q?.=20Travail=20en=20cours.=20Vocabulaire=20=C3=A0=20valider=20(n?= =?UTF-8?q?on=20exhaustif)=20:=20display=20-=20agencement=20yield=20expres?= =?UTF-8?q?sion=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" From 28a8a795e9e58d83c452466f824cebe7e6fb2404 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Sat, 2 Jun 2018 00:47:25 +0200 Subject: [PATCH 2/2] 'Reference - Expressions' translation completed. --- reference/expressions.po | 566 +++++++++++++++++++++++++++++++++++---- 1 file changed, 515 insertions(+), 51 deletions(-) diff --git a/reference/expressions.po b/reference/expressions.po index c8344fd8..d8ecba95 100644 --- a/reference/expressions.po +++ b/reference/expressions.po @@ -8,7 +8,7 @@ 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: 2018-05-25 23:00+0200\n" +"PO-Revision-Date: 2018-06-02 00:44+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" @@ -1280,12 +1280,17 @@ msgid "" "A call calls a callable object (e.g., a :term:`function`) with a possibly " "empty series of :term:`arguments `:" msgstr "" +"Un appel (*call* dans la grammaire ci-dessous) appelle un objet appelable " +"(par exemple, une :term:`fonction `) avec, possiblement, une liste " +"d'\\ :term:`arguments ` :" #: ../Doc/reference/expressions.rst:833 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:839 msgid "" @@ -1296,6 +1301,13 @@ msgid "" "attempted. Please refer to section :ref:`function` for the syntax of " "formal :term:`parameter` lists." msgstr "" +"La primaire doit s'évaluer à un objet appelable (une fonction définie par " +"l'utilisateur, une fonction native, une méthode d'objet natif, un objet de " +"classe, une méthode d'instance de classe ou tout objet possédant une " +"méthode :meth:`__call__` est un appelable). Toutes les expressions des " +"arguments sont évaluées avant que l'appel ne soit exécuté. Référez-vous à la " +"section :ref:`function` pour la syntaxe des listes de :term:`paramètres " +"` formels." #: ../Doc/reference/expressions.rst:847 msgid "" @@ -1318,6 +1330,25 @@ msgid "" "Otherwise, the list of filled slots is used as the argument list for the " "call." msgstr "" +"Si des arguments par mots-clés sont présents, ils sont d'abord convertis en " +"arguments positionnels, comme suit. Pour commencer, une liste de *slots* " +"vides est créée pour les paramètres formels. S'il y a N arguments " +"positionnels, ils sont placés dans les N premiers *slots*. Ensuite, pour " +"chaque argument par mot-clé, l'identifiant est utilisé pour déterminer le " +"*slot* correspondant (si l'identifiant est le même que le nom du premier " +"paramètre formel, le premier *slot* est utilisé, et ainsi de suite). Si le " +"*slot* est déjà rempli, une exception :exc:`TypeError` est levée. Sinon, la " +"valeur de l'argument est placée dans le *slot*, ce qui le remplit (même si " +"l'expression est ``None``, cela remplit le *slot*). Quand tous les arguments " +"ont été traités, les *slots* qui sont toujours vides sont remplis avec la " +"valeur par défaut correspondante dans la définition de la fonction (les " +"valeurs par défaut sont calculées, une seule fois, lorsque la fonction est " +"définie ; ainsi, un objet mutable tel qu'une liste ou un dictionnaire " +"utilisé en tant valeur par défaut sera partagé entre tous les appels qui ne " +"spécifient pas de valeur d argument pour ce *slot* ; on évite généralement " +"de faire ça). S'il reste des *slots* pour lesquels aucune valeur par défaut " +"n'est définie, une exception :exc:`TypeError` est levée. Sinon, la liste des " +"*slots* remplie est utilisée en tant que liste des arguments pour l'appel." #: ../Doc/reference/expressions.rst:867 msgid "" @@ -1327,6 +1358,11 @@ msgid "" "CPython, this is the case for functions implemented in C that use :c:func:" "`PyArg_ParseTuple` to parse their arguments." msgstr "" +"Une implémentation peut fournir des fonctions natives dont les paramètres " +"positionnels n'ont pas de nom, même s'ils sont \"nommés\" pour les besoins " +"de la documentation. Ils ne peuvent donc pas être spécifiés par mot-clé. En " +"CPython, les fonctions implémentées en C qui utilisent :c:func:" +"`PyArg_ParseTuple` pour analyser leurs arguments en font partie." #: ../Doc/reference/expressions.rst:873 msgid "" @@ -1336,6 +1372,11 @@ msgid "" "parameter receives a tuple containing the excess positional arguments (or an " "empty tuple if there were no excess positional arguments)." msgstr "" +"S'il y a plus d'arguments positionnels que de *slots* de paramètres formels, " +"une exception :exc:`TypeError` est levée, à moins qu'un paramètre formel " +"n'utilise la syntaxe ``*identifier`` ; dans ce cas, le paramètre formel " +"reçoit un n-uplet contenant les arguments positionnels en supplément (ou un " +"n-uplet vide s'il n'y avait pas d'arguments positionnel en trop)." #: ../Doc/reference/expressions.rst:879 msgid "" @@ -1346,6 +1387,13 @@ msgid "" "keywords as keys and the argument values as corresponding values), or a " "(new) empty dictionary if there were no excess keyword arguments." msgstr "" +"Si un argument par mot-clé ne correspond à aucun nom de paramètre formel, " +"une exception :exc:`TypeError` est levée, à moins qu'un paramètre formel " +"n'utilise la syntaxe ``**identifier`` ; dans ce cas, le paramètre formel " +"reçoit un dictionnaire contenant les arguments par mot-clé en trop (en " +"utilisant les mots-clés comme clés et les arguments comme valeurs pour ce " +"dictionnaire), ou un (nouveau) dictionnaire vide s'il n'y a pas d'argument " +"par mot-clé en trop." #: ../Doc/reference/expressions.rst:890 msgid "" @@ -1356,6 +1404,12 @@ msgid "" "this is equivalent to a call with M+4 positional arguments *x1*, *x2*, " "*y1*, ..., *yM*, *x3*, *x4*." msgstr "" +"Si la syntaxe ``*expression`` apparaît dans l'appel de la fonction, " +"``expression`` doit pouvoir s'évaluer à un :term:`itérable `. Les " +"éléments de ces itérables sont traités comme s'ils étaient des arguments " +"positionnels supplémentaires. Pour l'appel ``f(x1, x2, *y, x3, x4)``, si *y* " +"s'évalue comme une séquence *y1*, ..., *yM*, c'est équivalent à un appel " +"avec M+4 arguments positionnels *x1*, *x2*, *y1*, ..., *yM*, *x3*, *x4*." #: ../Doc/reference/expressions.rst:897 msgid "" @@ -1363,12 +1417,19 @@ msgid "" "*after* explicit keyword arguments, it is processed *before* the keyword " "arguments (and any ``**expression`` arguments -- see below). So::" msgstr "" +"Une conséquence est que bien que la syntaxe ``*expression`` puisse " +"apparaître *après* les arguments par mots-clés explicites, ils sont traités " +"*avant* les arguments par mots-clés (et avant tout argument ``**expression`` " +"-- voir ci-dessous). Ainsi ::" #: ../Doc/reference/expressions.rst:913 msgid "" "It is unusual for both keyword arguments and the ``*expression`` syntax to " "be used in the same call, so in practice this confusion does not arise." msgstr "" +"Il est inhabituel que les syntaxes d'arguments par mots-clés et " +"``*expression`` soient utilisés simultanément dans un même appel, ce qui " +"fait que la confusion reste hypothétique." #: ../Doc/reference/expressions.rst:919 msgid "" @@ -1378,12 +1439,21 @@ msgid "" "explicit keyword argument, or from another unpacking), a :exc:`TypeError` " "exception is raised." msgstr "" +"Si la syntaxe ``**expression`` apparaît dans un appel de fonction, " +"``expression`` doit pouvoir s'évaluer comme un :term:`tableau de " +"correspondances `, dont le contenu est traité comme des arguments " +"par mots-clés supplémentaires. Si un mot-clé est déjà présent (en tant " +"qu'argument par mot-clé explicite, ou venant d'un autre dépaquetage), une " +"exception :exc:`TypeError` est levée." #: ../Doc/reference/expressions.rst:925 msgid "" "Formal parameters using the syntax ``*identifier`` or ``**identifier`` " "cannot be used as positional argument slots or as keyword argument names." msgstr "" +"Les paramètres formels qui utilisent la syntaxe ``*identifier`` ou " +"``**identifier`` ne peuvent pas être utilisés comme arguments positionnels " +"ou comme noms d'arguments par mots-clés." #: ../Doc/reference/expressions.rst:928 msgid "" @@ -1391,6 +1461,11 @@ msgid "" "arguments may follow iterable unpackings (``*``), and keyword arguments may " "follow dictionary unpackings (``**``). Originally proposed by :pep:`448`." msgstr "" +"Les appels de fonction acceptent n'importe quel nombre de dépaquetages par " +"``*`` ou ``**``. Des arguments positionnels peuvent suivre les dépaquetages " +"d'itérables (``*``) et les arguments par mots-clés peuvent suivre les " +"dépaquetages de dictionnaires (``**``). Proposé pour la première fois par " +"la :pep:`448`." #: ../Doc/reference/expressions.rst:934 msgid "" @@ -1398,14 +1473,17 @@ msgid "" "exception. How this value is computed depends on the type of the callable " "object." msgstr "" +"Un appel renvoie toujours une valeur, possiblement ``None``, à moins qu'il " +"ne lève une exception. La façon dont celle valeur est calculée dépend du " +"type de l'objet appelable." #: ../Doc/reference/expressions.rst:938 msgid "If it is---" -msgstr "" +msgstr "Si c'est ---" #: ../Doc/reference/expressions.rst:951 msgid "a user-defined function:" -msgstr "" +msgstr "une fonction définie par l'utilisateur :" #: ../Doc/reference/expressions.rst:947 msgid "" @@ -1415,28 +1493,35 @@ msgid "" "block executes a :keyword:`return` statement, this specifies the return " "value of the function call." msgstr "" +"le bloc de code de la fonction est exécuté, il reçoit la liste des " +"arguments. La première chose que le bloc de code fait est de lier les " +"paramètres formels aux arguments ; ceci est décrit dans la section :ref:" +"`function`. Quand le bloc de code exécute l'instruction :keyword:`return`, " +"cela spécifie la valeur de retour de l'appel de la fonction." #: ../Doc/reference/expressions.rst:965 msgid "a built-in function or method:" -msgstr "" +msgstr "une fonction ou une méthode native :" #: ../Doc/reference/expressions.rst:964 msgid "" "The result is up to the interpreter; see :ref:`built-in-funcs` for the " "descriptions of built-in functions and methods." msgstr "" +"le résultat dépend de l'interpréteur ; lisez :ref:`built-in-funcs` pour une " +"description des fonctions et méthodes natives." #: ../Doc/reference/expressions.rst:972 msgid "a class object:" -msgstr "" +msgstr "un objet classe :" #: ../Doc/reference/expressions.rst:972 msgid "A new instance of that class is returned." -msgstr "" +msgstr "une nouvelle instance de cette classe est renvoyée." #: ../Doc/reference/expressions.rst:982 msgid "a class instance method:" -msgstr "" +msgstr "une méthode d'instance de classe :" #: ../Doc/reference/expressions.rst:980 msgid "" @@ -1444,36 +1529,46 @@ msgid "" "that is one longer than the argument list of the call: the instance becomes " "the first argument." msgstr "" +"la fonction correspondante définie par l'utilisateur est appelée, avec la " +"liste d'arguments qui est plus grande d'un élément que la liste des " +"arguments de l'appel : l'instance est placée en tête des arguments." #: ../Doc/reference/expressions.rst:991 msgid "a class instance:" -msgstr "" +msgstr "une instance de classe :" #: ../Doc/reference/expressions.rst:989 msgid "" "The class must define a :meth:`__call__` method; the effect is then the same " "as if that method was called." msgstr "" +"la classe doit définir une méthode :meth:`__call__` ; l'effet est le même " +"que si cette méthode était appelée." #: ../Doc/reference/expressions.rst:996 ../Doc/reference/expressions.rst:1702 msgid "Await expression" -msgstr "" +msgstr "Expression await" #: ../Doc/reference/expressions.rst:998 msgid "" "Suspend the execution of :term:`coroutine` on an :term:`awaitable` object. " "Can only be used inside a :term:`coroutine function`." msgstr "" +"Suspend l'exécution de la :term:`coroutine` sur un objet :term:`awaitable`. " +"Ne peut être utilisée qu'à l'intérieur d'une :term:`coroutine function`." #: ../Doc/reference/expressions.rst:1010 msgid "The power operator" -msgstr "" +msgstr "L'opérateur puissance" #: ../Doc/reference/expressions.rst:1012 msgid "" "The power operator binds more tightly than unary operators on its left; it " "binds less tightly than unary operators on its right. The syntax is:" msgstr "" +"L'opérateur puissance est plus prioritaire que les opérateurs unaires sur sa " +"gauche ; il est moins prioritaire que les opérateurs unaires sur sa droite. " +"La syntaxe est :" #: ../Doc/reference/expressions.rst:1018 msgid "" @@ -1481,6 +1576,9 @@ msgid "" "operators are evaluated from right to left (this does not constrain the " "evaluation order for the operands): ``-1**2`` results in ``-1``." msgstr "" +"Ainsi, dans une séquence sans parenthèse de puissance et d'opérateurs " +"unaires, les opérateurs sont évalués de droite à gauche (ceci ne contraint " +"pas l'ordre d'évaluation des opérandes) : ``-1**2`` donne ``-1``." #: ../Doc/reference/expressions.rst:1022 msgid "" @@ -1489,6 +1587,11 @@ msgid "" "to the power of its right argument. The numeric arguments are first " "converted to a common type, and the result is of that type." msgstr "" +"L'opérateur puissance possède la même sémantique que la fonction native :" +"func:`pow` lorsqu'elle est appelée avec deux arguments : il produit son " +"argument de gauche élevé à la puissance de son argument de droite. Les " +"arguments numériques sont d'abord convertis vers un type commun et le " +"résultat est de ce type." #: ../Doc/reference/expressions.rst:1027 msgid "" @@ -1497,6 +1600,11 @@ msgid "" "float and a float result is delivered. For example, ``10**2`` returns " "``100``, but ``10**-2`` returns ``0.01``." msgstr "" +"Pour les opérandes entiers, le résultat est du même type à moins que le " +"deuxième argument ne soit négatif ; dans ce cas, tous les arguments sont " +"convertis en nombres à virgule flottante et le résultat est un nombre à " +"virgule flottante. Par exemple, ``10**2`` renvoie ``100`` mais ``10**-2`` " +"renvoie ``0.01``." #: ../Doc/reference/expressions.rst:1032 msgid "" @@ -1504,23 +1612,31 @@ msgid "" "Raising a negative number to a fractional power results in a :class:" "`complex` number. (In earlier versions it raised a :exc:`ValueError`.)" msgstr "" +"Élever ``0.0`` à une puissance négative entraîne une :exc:" +"`ZeroDivisionError`. Élever un nombre négatif à une puissance fractionnaire " +"renvoie un nombre :class:`complexe ` (dans les versions " +"antérieures, cela levait une :exc:`ValueError`)." #: ../Doc/reference/expressions.rst:1040 msgid "Unary arithmetic and bitwise operations" -msgstr "" +msgstr "Arithmétique unaire et opérations sur les bits" #: ../Doc/reference/expressions.rst:1046 msgid "All unary arithmetic and bitwise operations have the same priority:" msgstr "" +"Toute l'arithmétique unaire et les opérations sur les bits ont la même " +"priorité :" #: ../Doc/reference/expressions.rst:1055 msgid "" "The unary ``-`` (minus) operator yields the negation of its numeric argument." msgstr "" +"L'opérateur unaire ``-`` (moins) produit l'opposé de son argument numérique." #: ../Doc/reference/expressions.rst:1059 msgid "The unary ``+`` (plus) operator yields its numeric argument unchanged." msgstr "" +"L'opérateur unaire ``+`` (plus) produit son argument numérique inchangé." #: ../Doc/reference/expressions.rst:1064 msgid "" @@ -1528,16 +1644,21 @@ msgid "" "integer argument. The bitwise inversion of ``x`` is defined as ``-(x+1)``. " "It only applies to integral numbers." msgstr "" +"L'opérateur unaire ``~`` (inversion) produit l'inversion bit à bit de son " +"argument entier. L'inversion bit à bit de ``x`` est définie comme ``-(x" +"+1)``. Elle s'applique uniquement aux nombres entiers." #: ../Doc/reference/expressions.rst:1070 msgid "" "In all three cases, if the argument does not have the proper type, a :exc:" "`TypeError` exception is raised." msgstr "" +"Dans ces trois cas, si l'argument n'est pas du bon type, une exception :exc:" +"`TypeError` est levée." #: ../Doc/reference/expressions.rst:1077 msgid "Binary arithmetic operations" -msgstr "" +msgstr "Opérations arithmétiques binaires" #: ../Doc/reference/expressions.rst:1081 msgid "" @@ -1546,6 +1667,11 @@ msgid "" "Apart from the power operator, there are only two levels, one for " "multiplicative operators and one for additive operators:" msgstr "" +"Les opérations arithmétiques binaires suivent les conventions pour les " +"priorités. Notez que certaines de ces opérations s'appliquent aussi à des " +"types non numériques. À part l'opérateur puissance, il n'y a que deux " +"niveaux, le premier pour les opérateurs multiplicatifs et le second pour les " +"opérateurs additifs :" #: ../Doc/reference/expressions.rst:1094 msgid "" @@ -1556,12 +1682,20 @@ msgid "" "case, sequence repetition is performed; a negative repetition factor yields " "an empty sequence." msgstr "" +"L'opérateur ``*`` (multiplication) produit le produit de ses arguments. Les " +"deux arguments doivent être des nombres ou alors le premier argument doit " +"être un entier et l'autre doit être une séquence. Dans le premier cas, les " +"nombres sont convertis dans un type commun puis sont multipliés entre eux. " +"Dans le dernier cas, la séquence est répétée ; une répétition négative " +"produit une séquence vide." #: ../Doc/reference/expressions.rst:1102 msgid "" "The ``@`` (at) operator is intended to be used for matrix multiplication. " "No builtin Python types implement this operator." msgstr "" +"L'opérateur ``@`` (at) a vocation à multiplier des matrices. Aucun type " +"Python natif n'implémente cet opérateur." #: ../Doc/reference/expressions.rst:1111 msgid "" @@ -1572,6 +1706,13 @@ msgid "" "with the 'floor' function applied to the result. Division by zero raises " "the :exc:`ZeroDivisionError` exception." msgstr "" +"Les opérateurs ``/`` (division) and ``//`` (division entière ou *floor " +"division* en anglais) produisent le quotient de leurs arguments. Les " +"arguments numériques sont d'abord convertis vers un type commun. La division " +"d'entiers produit un nombre à virgule flottante alors que la division " +"entière d'entiers produit un entier ; le résultat est celui de la division " +"mathématique suivie de la fonction 'floor' appliquée au résultat. Une " +"division par zéro lève une exception :exc:`ZeroDivisionError`." #: ../Doc/reference/expressions.rst:1120 msgid "" @@ -1584,6 +1725,14 @@ msgid "" "zero); the absolute value of the result is strictly smaller than the " "absolute value of the second operand [#]_." msgstr "" +"L'opérateur ``%`` (modulo) produit le reste de la division entière du " +"premier argument par le second. Les arguments numériques sont d'abord " +"convertis vers un type commun. Un zéro en second argument lève une " +"exception :exc:`ZeroDivisionError`. Les arguments peuvent être des nombres à " +"virgule flottante, par exemple ``3.14%0.7`` vaut ``0.34`` (puisque ``3.14`` " +"égale ``4*0.7+0.34``). L'opérateur modulo produit toujours un résultat du " +"même signe que le second opérande (ou zéro) ; la valeur absolue du résultat " +"est strictement inférieure à la valeur absolue du second opérande [#]_." #: ../Doc/reference/expressions.rst:1129 msgid "" @@ -1592,6 +1741,10 @@ msgid "" "connected with the built-in function :func:`divmod`: ``divmod(x, y) == (x//" "y, x%y)``. [#]_." msgstr "" +"Les opérateurs division entière et modulo sont liés par la relation " +"suivante : ``x == (x//y)*y + (x%y)``. La division entière et le module sont " +"aussi liés à la fonction native :func:`divmod` : ``divmod(x, y) == (x//y, x" +"%y)`` [#]_." #: ../Doc/reference/expressions.rst:1134 msgid "" @@ -1601,6 +1754,11 @@ msgid "" "is described in the Python Library Reference, section :ref:`old-string-" "formatting`." msgstr "" +"En plus de calculer le modulo sur les nombres, l'opérateur ``%`` est aussi " +"surchargé par les objets chaînes de caractères pour effectuer le formatage " +"de chaîne \"à l'ancienne\". La syntaxe pour le formatage de chaînes est " +"décrit dans la référence de la bibliothèque Python, dans la section :ref:" +"`old-string-formatting`." #: ../Doc/reference/expressions.rst:1139 msgid "" @@ -1608,6 +1766,10 @@ msgid "" "function are not defined for complex numbers. Instead, convert to a " "floating point number using the :func:`abs` function if appropriate." msgstr "" +"L'opérateur de division entière, l'opérateur modulo et la fonction :func:" +"`divmod` ne sont pas définis pour les nombres complexes. À la place, vous " +"pouvez, si cela a du sens pour ce que vous voulez faire, les convertir vers " +"des nombres à virgule flottante en utilisant la fonction :func:`abs`." #: ../Doc/reference/expressions.rst:1145 msgid "" @@ -1616,33 +1778,48 @@ msgid "" "type. In the former case, the numbers are converted to a common type and " "then added together. In the latter case, the sequences are concatenated." msgstr "" +"L'opérateur ``+`` (addition) produit la somme de ses arguments. Les " +"arguments doivent être tous les deux des nombres ou des séquences du même " +"type. Dans le premier cas, les nombres sont convertis vers un type commun " +"puis sont additionnés entre eux. Dans le dernier cas, les séquences sont " +"concaténées." #: ../Doc/reference/expressions.rst:1152 msgid "" "The ``-`` (subtraction) operator yields the difference of its arguments. " "The numeric arguments are first converted to a common type." msgstr "" +"L'opérateur ``-`` (soustraction) produit la différence entre ses arguments. " +"Les arguments numériques sont d'abord convertis vers un type commun." #: ../Doc/reference/expressions.rst:1159 msgid "Shifting operations" -msgstr "" +msgstr "Opérations de décalage" #: ../Doc/reference/expressions.rst:1163 msgid "" "The shifting operations have lower priority than the arithmetic operations:" msgstr "" +"Les opérations de décalage sont moins prioritaires que les opérations " +"arithmétiques :" #: ../Doc/reference/expressions.rst:1168 msgid "" "These operators accept integers as arguments. They shift the first argument " "to the left or right by the number of bits given by the second argument." msgstr "" +"Ces opérateurs prennent des entiers comme arguments. Ils décalent le premier " +"argument vers la gauche ou vers la droite du nombre de bits donné par le " +"deuxième argument." #: ../Doc/reference/expressions.rst:1173 msgid "" "A right shift by *n* bits is defined as floor division by ``pow(2,n)``. A " "left shift by *n* bits is defined as multiplication with ``pow(2,n)``." msgstr "" +"Un décalage à droite de *n* bits est défini comme la division entière par " +"``pow(2,n)``. Un décalage à gauche de *n* bits est défini comme la " +"multiplication par ``pow(2,n)``." #: ../Doc/reference/expressions.rst:1178 msgid "" @@ -1650,32 +1827,43 @@ msgid "" "most :attr:`sys.maxsize`. If the right-hand operand is larger than :attr:" "`sys.maxsize` an :exc:`OverflowError` exception is raised." msgstr "" +"Dans l'implémentation actuelle, l'opérande de droite doit être au maximum :" +"attr:`sys.maxsize`. Si l'opérande de droite est plus grand que :attr:`sys." +"maxsize`, une exception :exc:`OverflowError` est levée." #: ../Doc/reference/expressions.rst:1185 msgid "Binary bitwise operations" -msgstr "" +msgstr "Opérations binaires bit à bit" #: ../Doc/reference/expressions.rst:1189 msgid "Each of the three bitwise operations has a different priority level:" msgstr "" +"Chacune des trois opérations binaires bit à bit possède une priorité " +"différente :" #: ../Doc/reference/expressions.rst:1198 msgid "" "The ``&`` operator yields the bitwise AND of its arguments, which must be " "integers." msgstr "" +"L'opérateur ``&`` produit le ET logique de ses arguments, qui doivent être " +"des entiers." #: ../Doc/reference/expressions.rst:1205 msgid "" "The ``^`` operator yields the bitwise XOR (exclusive OR) of its arguments, " "which must be integers." msgstr "" +"L'opérateur ``^`` produit le OU EXCLUSIF (XOR) logique de ses arguments, qui " +"doivent être des entiers." #: ../Doc/reference/expressions.rst:1212 msgid "" "The ``|`` operator yields the bitwise (inclusive) OR of its arguments, which " "must be integers." msgstr "" +"L'opérateur ``|`` produit le OU logique de ses arguments, qui doivent être " +"des entiers." #: ../Doc/reference/expressions.rst:1219 msgid "Comparisons" @@ -1688,10 +1876,16 @@ msgid "" "unlike C, expressions like ``a < b < c`` have the interpretation that is " "conventional in mathematics:" msgstr "" +"Au contraire du C, toutes les opérations de comparaison en Python possèdent " +"la même priorité, qui est plus faible que celle des opérations " +"arithmétiques, décalages ou binaires bit à bit. Toujours contrairement au C, " +"les expressions telles que ``a < b < c`` sont interprétées comme elles le " +"seraient conventionnellement en mathématiques :" #: ../Doc/reference/expressions.rst:1235 msgid "Comparisons yield boolean values: ``True`` or ``False``." msgstr "" +"Les comparaisons produisent des valeurs booléennes : ``True`` ou ``False``." #: ../Doc/reference/expressions.rst:1239 msgid "" @@ -1700,6 +1894,10 @@ msgid "" "both cases ``z`` is not evaluated at all when ``x < y`` is found to be " "false)." msgstr "" +"Les comparaisons peuvent être enchaînées arbitrairement, par exemple ``x < y " +"<= z`` est équivalent à ``x < y and y <= z``, sauf que ``y`` est évalué " +"seulement une fois (mais dans les deux cas, ``z`` n'est pas évalué du tout " +"si ``x < y`` s'avère être faux)." #: ../Doc/reference/expressions.rst:1243 msgid "" @@ -1708,6 +1906,10 @@ msgid "" "z`` is equivalent to ``a op1 b and b op2 c and ... y opN z``, except that " "each expression is evaluated at most once." msgstr "" +"Formellement, si *a*, *b*, *c*, ..., *y*, *z* sont des expressions et *op1*, " +"*op2*, ..., *opN* sont des opérateurs de comparaison, alors ``a op1 b op2 " +"c ... y opN z`` est équivalent à ``a op1 b and b op2 c and ... y opN z``, " +"sauf que chaque expression est évaluée au maximum une fois." #: ../Doc/reference/expressions.rst:1248 msgid "" @@ -1715,16 +1917,21 @@ msgid "" "and *c*, so that, e.g., ``x < y > z`` is perfectly legal (though perhaps not " "pretty)." msgstr "" +"Notez que ``a op1 b op2 c`` n'implique aucune comparaison entre *a* et *c*. " +"Ainsi, par exemple, ``x < y > z`` est parfaitement légal (mais peut-être pas " +"très élégant)." #: ../Doc/reference/expressions.rst:1253 msgid "Value comparisons" -msgstr "" +msgstr "Comparaisons de valeurs" #: ../Doc/reference/expressions.rst:1255 msgid "" "The operators ``<``, ``>``, ``==``, ``>=``, ``<=``, and ``!=`` compare the " "values of two objects. The objects do not need to have the same type." msgstr "" +"Les opérateurs ``<``, ``>``, ``==``, ``>=``, ``<=`` et ``!=`` comparent les " +"valeurs de deux objets. Les objets n'ont pas besoin d'être du même type." #: ../Doc/reference/expressions.rst:1258 msgid "" @@ -1737,6 +1944,15 @@ msgid "" "object is. One can think of them as defining the value of an object " "indirectly, by means of their comparison implementation." msgstr "" +"Le chapître :ref:`objects` indique que les objets ont une valeur (en plus " +"d'un type et d'un identifiant). La valeur d'un objet est une notion plutôt " +"abstraite en Python : par exemple, il n'existe pas de méthode canonique pour " +"accéder à la valeur d'un objet. De la même manière, il n'y a aucune " +"obligation concernant la construction de la valeur d'un objet, par exemple " +"qu'elle prenne en compte toutes les données de ses attributs. Les opérateurs " +"de comparaison implémentent une notion particulière de ce qu'est la valeur " +"d'un objet. Vous pouvez vous le représenter comme une définition indirecte " +"de la valeur d'un objet, *via* l'implémentation de leur comparaison." #: ../Doc/reference/expressions.rst:1267 msgid "" @@ -1745,6 +1961,11 @@ msgid "" "customize their comparison behavior by implementing :dfn:`rich comparison " "methods` like :meth:`__lt__`, described in :ref:`customization`." msgstr "" +"Comme tous les types sont des sous-types (directs ou indirects) de la " +"classe :class:`object`, ils héritent du comportement de comparaison par " +"défaut de :class:`object`. Les types peuvent personnaliser le comportement " +"des comparaisons en implémentant des :dfn:`méthodes de comparaisons riches`, " +"comme :meth:`__lt__`, décrites dans :ref:`customization`." #: ../Doc/reference/expressions.rst:1273 msgid "" @@ -1755,6 +1976,12 @@ msgid "" "default behavior is the desire that all objects should be reflexive (i.e. " "``x is y`` implies ``x == y``)." msgstr "" +"Le comportement par défaut pour le test d'égalité (``==`` et ``!=``) se base " +"sur les identifiants des objets. Ainsi, un test d'égalité entre deux " +"instances qui ont le même identifiant est vrai, un test d'égalité entre deux " +"instances qui ont des identifiants différents est faux. La raison de ce " +"choix est que Python souhaite que tous les objets soient réflexifs, c'est-à-" +"dire que ``x is y`` implique ``x == y``." #: ../Doc/reference/expressions.rst:1280 msgid "" @@ -1762,6 +1989,9 @@ msgid "" "provided; an attempt raises :exc:`TypeError`. A motivation for this default " "behavior is the lack of a similar invariant as for equality." msgstr "" +"La relation d'ordre (``<``, ``>``, ``<=`` et ``>=``) n'est pas fournie par " +"défaut ; une tentative se solde par une :exc:`TypeError`. La raison de ce " +"choix est qu'il n'existe pas d'invariant similaire à celui de l'égalité." #: ../Doc/reference/expressions.rst:1284 msgid "" @@ -1771,12 +2001,20 @@ msgid "" "equality. Such types will need to customize their comparison behavior, and " "in fact, a number of built-in types have done that." msgstr "" +"Le comportement du test d'égalité par défaut, à savoir que les instances " +"avec des identités différentes ne sont jamais égales, peut être en " +"contradiction avec les types qui définissent la \"valeur\" d'un objet et se " +"basent sur cette \"valeur\" pour l'égalité. De tels types doivent " +"personnaliser leurs tests de comparaison et, en fait, c'est ce qu'ont fait " +"un certain nombre de types natifs." #: ../Doc/reference/expressions.rst:1290 msgid "" "The following list describes the comparison behavior of the most important " "built-in types." msgstr "" +"La liste suivante décrit le comportement des tests d'égalité pour les types " +"natifs les plus importants." #: ../Doc/reference/expressions.rst:1293 msgid "" @@ -1787,6 +2025,13 @@ msgid "" "involved, they compare mathematically (algorithmically) correct without loss " "of precision." msgstr "" +"Beaucoup de types numériques natifs (:ref:`typesnumeric`) et de types de la " +"bibliothèque standard :class:`fractions.Fraction` ainsi que :class:`decimal." +"decimal` peuvent être comparés, au sein de leur propre classe ou avec " +"d'autres objets de classes différentes. Une exception notable concerne les " +"nombres complexes qui ne gèrent pas la relation d'ordre. Dans les limites " +"des types concernés, la comparaison mathématique équivaut à la comparaison " +"algorithmique, sans perte de précision." #: ../Doc/reference/expressions.rst:1300 msgid "" @@ -1796,6 +2041,8 @@ msgid "" "number to a not-a-number value will return ``False``. For example, both ``3 " "< float('NaN')`` and ``float('NaN') < 3`` will return ``False``." msgstr "" +"Les valeurs qui ne sont pas des nombres, :const:`float('NaN')` et :const:" +"`Decimal('NaN')`, ont un traitement spécial. " #: ../Doc/reference/expressions.rst:1307 msgid "" @@ -1803,6 +2050,10 @@ msgid "" "compared within and across their types. They compare lexicographically " "using the numeric values of their elements." msgstr "" +"Les séquences binaires (instances du type :class:`bytes` ou :class:" +"`bytearray`) peuvent être comparées au sein de la classe et entre classes. " +"La comparaison est lexicographique, en utilisant la valeur numérique des " +"éléments." #: ../Doc/reference/expressions.rst:1311 msgid "" @@ -1810,10 +2061,15 @@ msgid "" "numerical Unicode code points (the result of the built-in function :func:" "`ord`) of their characters. [#]_" msgstr "" +"Les chaînes de caractères (instances de :class:`str`) respectent l'ordre " +"lexicographique en utilisant la valeur Unicode (le résultat de la fonction " +"native :func:`ord`) des caractères [#]_." #: ../Doc/reference/expressions.rst:1315 msgid "Strings and binary sequences cannot be directly compared." msgstr "" +"Les chaînes de caractères et les séquences binaires ne peuvent pas être " +"comparées directement." #: ../Doc/reference/expressions.rst:1317 msgid "" @@ -1823,12 +2079,19 @@ msgid "" "types results in inequality, and ordering comparison across these types " "raises :exc:`TypeError`." msgstr "" +"Les séquences (instances de :class:`tuple`, :class:`list` ou :class:`range`) " +"peuvent être comparées uniquement entre instances de même type, en sachant " +"que les intervalles (*range*) ne gèrent pas la relation d'ordre. Le test " +"d'égalité entre ces types renvoie faux et une comparaison entre instances de " +"types différents lève une :exc:`TypeError`." #: ../Doc/reference/expressions.rst:1323 msgid "" "Sequences compare lexicographically using comparison of corresponding " "elements, whereby reflexivity of the elements is enforced." msgstr "" +"Les séquences suivent l'ordre lexicographique en utilisant la comparaison de " +"leurs éléments, sachant que la réflexivité des éléments est appliquée." #: ../Doc/reference/expressions.rst:1326 msgid "" @@ -1842,11 +2105,22 @@ msgid "" "number values for example result in the following comparison behavior when " "used in a list::" msgstr "" +"Dans l'application de la réflexivité des éléments, la comparaison des " +"collections suppose que pour un élément de collection ``x``, ``x == x`` est " +"toujours vrai. Sur la base de cette hypothèse, l'identité des éléments est " +"d'abord testée, puis la comparaison des éléments n'est effectuée que pour " +"des éléments distincts. Cette approche donne le même résultat qu'une " +"comparaison stricte d'éléments, si les éléments comparés sont réflexifs. " +"Pour les éléments non réflexifs, le résultat est différent de celui de la " +"comparaison stricte des éléments, voire peut être surprenant : les valeurs " +"non réflexives qui ne sont pas des nombres, par exemple, aboutissent au " +"comportement suivant lorsqu'elles sont utilisées dans une liste ::" #: ../Doc/reference/expressions.rst:1344 msgid "" "Lexicographical comparison between built-in collections works as follows:" msgstr "" +"L'ordre lexicographique pour les collections natives fonctionne comme suit :" #: ../Doc/reference/expressions.rst:1346 msgid "" @@ -1854,6 +2128,9 @@ msgid "" "the same length, and each pair of corresponding elements must compare equal " "(for example, ``[1,2] == (1,2)`` is false because the type is not the same)." msgstr "" +"Deux collections sont égales si elles sont du même type, ont la même " +"longueur et si les éléments correspondants de chaque paire sont égaux. Par " +"exemple, ``[1,2] == (1,2)`` est faux car les types sont différents." #: ../Doc/reference/expressions.rst:1351 msgid "" @@ -1863,6 +2140,11 @@ msgid "" "shorter collection is ordered first (for example, ``[1,2] < [1,2,3]`` is " "true)." msgstr "" +"Les collections qui gèrent la relation d'ordre sont ordonnées comme leur " +"premier élément différent (par exemple, ``[1,2,x] <= [1,2,y]`` a la même " +"valeur que ``x <= y``). Si un élément n'a pas de correspondant, la " +"collection la plus courte est la plus petite (par exemple, ``[1,2] < " +"[1,2,3]`` est vrai)." #: ../Doc/reference/expressions.rst:1357 msgid "" @@ -1870,17 +2152,23 @@ msgid "" "equal `(key, value)` pairs. Equality comparison of the keys and values " "enforces reflexivity." msgstr "" +"Les tableaux de correspondances (instances de :class:`dict`) sont égales si " +"et seulement si toutes leurs paires `(clé, valeur)` sont égales. L'égalité " +"des clés et des valeurs met en œuvre la réflexivité." #: ../Doc/reference/expressions.rst:1361 msgid "" "Order comparisons (``<``, ``>``, ``<=``, and ``>=``) raise :exc:`TypeError`." msgstr "" +"Les comparaisons (``<``, ``>``, ``<=`` et ``>=``) lèvent :exc:`TypeError`." #: ../Doc/reference/expressions.rst:1363 msgid "" "Sets (instances of :class:`set` or :class:`frozenset`) can be compared " "within and across their types." msgstr "" +"Les ensembles (instances de :class:`set` ou :class:`frozenset`) peuvent être " +"comparés au sein de leur propre type et entre types différents." #: ../Doc/reference/expressions.rst:1366 msgid "" @@ -1892,28 +2180,41 @@ msgid "" "func:`max`, and :func:`sorted` produce undefined results given a list of " "sets as inputs)." msgstr "" +"Les opérateurs d'inclusion et de sur-ensemble sont définis. Ces relations ne " +"sont pas des relations d'ordre total (par exemple, les deux ensembles ``{1,2}" +"`` et ``{2,3}`` ne sont pas égaux, l'un n'est pas inclus dans l'autre, l'un " +"n'est pas un sur-ensemble de l'autre). Ainsi, les ensembles ne sont pas des " +"arguments appropriés pour les fonctions qui dépendent d'un ordre total (par " +"exemple, les fonctions :func:`min`, :func:`max` et :func:`sorted` produisent " +"des résultats indéfinis si on leur donne des listes d'ensembles en entrée)." #: ../Doc/reference/expressions.rst:1374 msgid "Comparison of sets enforces reflexivity of its elements." -msgstr "" +msgstr "La comparaison des ensembles met en œuvre la réflexivité des éléments." #: ../Doc/reference/expressions.rst:1376 msgid "" "Most other built-in types have no comparison methods implemented, so they " "inherit the default comparison behavior." msgstr "" +"La plupart des autres types natifs n'implémentent pas de méthodes de " +"comparaisons, ils héritent donc du comportement par défaut." #: ../Doc/reference/expressions.rst:1379 msgid "" "User-defined classes that customize their comparison behavior should follow " "some consistency rules, if possible:" msgstr "" +"Les classes allogènes qui particularisent les opérations de comparaison " +"doivent, si possible, respecter quelques règles pour la cohérence :" #: ../Doc/reference/expressions.rst:1382 msgid "" "Equality comparison should be reflexive. In other words, identical objects " "should compare equal:" msgstr "" +"Le test d'égalité doit être réflexif. En d'autres termes, des objets " +"identiques doivent être égaux :" #: ../Doc/reference/expressions.rst:1385 msgid "``x is y`` implies ``x == y``" @@ -1924,6 +2225,8 @@ msgid "" "Comparison should be symmetric. In other words, the following expressions " "should have the same result:" msgstr "" +"La comparaison doit être symétrique. En d'autres termes, les expressions " +"suivantes doivent donner le même résultat :" #: ../Doc/reference/expressions.rst:1390 msgid "``x == y`` and ``y == x``" @@ -1946,20 +2249,22 @@ msgid "" "Comparison should be transitive. The following (non-exhaustive) examples " "illustrate that:" msgstr "" +"La comparaison doit être transitive. Les exemples suivants (liste non " +"exhaustive) illustrent ce concept :" #: ../Doc/reference/expressions.rst:1401 msgid "``x > y and y > z`` implies ``x > z``" -msgstr "``x > y et y > z`` implique ``x > z``" +msgstr "``x > y and y > z`` implique ``x > z``" #: ../Doc/reference/expressions.rst:1403 msgid "``x < y and y <= z`` implies ``x < z``" -msgstr "``x < y et y <= z`` implique ``x < z``" +msgstr "``x < y and y <= z`` implique ``x < z``" #: ../Doc/reference/expressions.rst:1405 msgid "" "Inverse comparison should result in the boolean negation. In other words, " "the following expressions should have the same result:" -msgstr "" +msgstr "Si vous inversez la comparaison, le résultat a négation " #: ../Doc/reference/expressions.rst:1408 msgid "``x == y`` and ``not x != y``" @@ -1967,11 +2272,11 @@ msgstr "``x == y`` et ``not x != y``" #: ../Doc/reference/expressions.rst:1410 msgid "``x < y`` and ``not x >= y`` (for total ordering)" -msgstr "" +msgstr "``x < y`` et ``not x >= y`` (pour une relation d'ordre total)" #: ../Doc/reference/expressions.rst:1412 msgid "``x > y`` and ``not x <= y`` (for total ordering)" -msgstr "" +msgstr "``x > y`` et ``not x <= y`` (pour une relation d'ordre total)" #: ../Doc/reference/expressions.rst:1414 msgid "" @@ -1979,22 +2284,31 @@ msgid "" "sequences, but not to sets or mappings). See also the :func:`~functools." "total_ordering` decorator." msgstr "" +"Ces deux dernières expressions s'appliquent pour les collections totalement " +"ordonnées (par exemple, les séquences mais pas les ensembles ou les tableaux " +"de correspondances). Regardez aussi le décorateur :func:`~functools." +"total_ordering`." #: ../Doc/reference/expressions.rst:1418 msgid "" "The :func:`hash` result should be consistent with equality. Objects that are " "equal should either have the same hash value, or be marked as unhashable." msgstr "" +"Le résultat de :func:`hash` doit être cohérent avec l'égalité. Les objets " +"qui sont égaux doivent avoir la même empreinte ou être marqués comme non-" +"hachables." #: ../Doc/reference/expressions.rst:1422 msgid "" "Python does not enforce these consistency rules. In fact, the not-a-number " "values are an example for not following these rules." msgstr "" +"Python ne vérifie pas ces règles de cohérence. En fait, l'utilisation de " +"valeurs non numériques est un exemple de non-respect de ces règles." #: ../Doc/reference/expressions.rst:1431 msgid "Membership test operations" -msgstr "" +msgstr "Opérations de tests d’appartenance à un ensemble" #: ../Doc/reference/expressions.rst:1433 msgid "" @@ -2006,6 +2320,15 @@ msgid "" "types such as list, tuple, set, frozenset, dict, or collections.deque, the " "expression ``x in y`` is equivalent to ``any(x is e or x == e for e in y)``." msgstr "" +"Les opérateurs :keyword:`in` et :keyword:`not in` testent l’appartenance. " +"``x in s`` s’évalue à ``True`` si *x* appartient à *s* et à ``False`` sinon. " +"``x not in s`` renvoie la négation de ``x in s``. Tous les types séquences " +"et ensembles natifs gèrent ces opérateurs, ainsi que les dictionnaires pour " +"lesquels :keyword:`in` teste si dictionnaire possède une clé donnée. Pour " +"les types conteneurs tels que les listes, n-uplets (*tuple*), ensembles " +"(*set*), ensembles gelés (*frozen set*), dictionnaires (*dict*) ou " +"*collections.deque*, l’expression ``x in y`` est équivalente à ``any(x is e " +"or x == e for e in y)``." #: ../Doc/reference/expressions.rst:1441 msgid "" @@ -2014,6 +2337,10 @@ msgid "" "strings are always considered to be a substring of any other string, so ``" "\"\" in \"abc\"`` will return ``True``." msgstr "" +"Pour les chaînes de caractères et chaînes d'octets, ``x in y`` vaut ``True`` " +"si et seulement si *x* est une sous-chaîne de *y*. Un test équivalent est " +"``y.find(x) != -1``. Une chaîne vide est considérée comme une sous-chaîne de " +"toute autre chaîne, ainsi ``\"\" in \"abc\"`` renvoie ``True``." #: ../Doc/reference/expressions.rst:1446 msgid "" @@ -2021,6 +2348,9 @@ msgid "" "in y`` returns ``True`` if ``y.__contains__(x)`` returns a true value, and " "``False`` otherwise." msgstr "" +"Pour les classes allogènes qui définissent la méthode :meth:`__contains__`, " +"``x in y`` renvoie ``True`` si ``y.__contains__(x)`` renvoie vrai, et " +"``False`` sinon." #: ../Doc/reference/expressions.rst:1450 msgid "" @@ -2029,6 +2359,11 @@ msgid "" "== z`` is produced while iterating over ``y``. If an exception is raised " "during the iteration, it is as if :keyword:`in` raised that exception." msgstr "" +"Pour les classes allogènes qui ne définissent pas :meth:`__contains__` mais " +"qui définissent :meth:`__iter__`, ``x in y`` vaut ``True`` s'il existe une " +"valeur ``z`` telle que ``x == z`` renvoie vrai lors de l'itération sur " +"``y``. Si une exception est levée pendant l'itération, c'est comme si :" +"keyword:`in` avait levé cette exception." #: ../Doc/reference/expressions.rst:1455 msgid "" @@ -2038,16 +2373,24 @@ msgid "" "not raise :exc:`IndexError` exception. (If any other exception is raised, " "it is as if :keyword:`in` raised that exception)." msgstr "" +"Enfin, le protocole d'itération \"à l'ancienne\" est essayé : si la classe " +"définit :meth:`__getitem__`, ``x in y`` est ``True`` si et seulement si il " +"existe un entier positif ou nul *i*, représentant l'indice, tel que ``x == " +"y[i]`` et que tout indice inférieur ne lève pas d'exception :exc:" +"`IndexError` (si toute autre exception est levée, c'est comme si :keyword:" +"`in` avait levé cette exception)." #: ../Doc/reference/expressions.rst:1467 msgid "" "The operator :keyword:`not in` is defined to have the inverse true value of :" "keyword:`in`." msgstr "" +"L'opérateur :keyword:`not in` est défini comme produisant le contraire de :" +"keyword:`in`." #: ../Doc/reference/expressions.rst:1480 msgid "Identity comparisons" -msgstr "" +msgstr "Comparaisons d'identifiants" #: ../Doc/reference/expressions.rst:1482 msgid "" @@ -2056,10 +2399,15 @@ msgid "" "identity is determined using the :meth:`id` function. ``x is not y`` yields " "the inverse truth value. [#]_" msgstr "" +"Les opérateurs :keyword:`is` et :keyword:`is not` testent l'égalité des " +"identifiants des objets : ``x is y`` est vrai si et seulement si *x* et *y* " +"sont le même objet. L'identifiant d'un objet est déterminé en utilisant la " +"fonction :meth:`id`. ``x is not y`` renvoie le résultat contraire de " +"l'égalité des identifiants [#]_." #: ../Doc/reference/expressions.rst:1494 msgid "Boolean operations" -msgstr "" +msgstr "Opérations booléennes" #: ../Doc/reference/expressions.rst:1505 msgid "" @@ -2071,24 +2419,40 @@ msgid "" "objects can customize their truth value by providing a :meth:`__bool__` " "method." msgstr "" +"Dans le contexte des opérations booléennes et quand des expressions sont " +"utilisées par des instructions de contrôle du flux d'exécution, les valeurs " +"suivantes sont considérées comme fausses : ``False``, ``None``, zéro quel " +"que soit le type, la chaîne vide et tout conteneur vide (y compris les " +"chaînes, n-uplets, listes, dictionnaires, ensembles, ensembles gelés). " +"Toutes les autres valeurs sont considérées comme vraies. Les objets " +"allogènes peuvent personnaliser leur table de vérité en implémentant une " +"méthode :meth:`__bool__`." #: ../Doc/reference/expressions.rst:1514 msgid "" "The operator :keyword:`not` yields ``True`` if its argument is false, " "``False`` otherwise." msgstr "" +"L'opérateur :keyword:`not` produit ``True`` si son argument est faux, " +"``False`` sinon." #: ../Doc/reference/expressions.rst:1519 msgid "" "The expression ``x and y`` first evaluates *x*; if *x* is false, its value " "is returned; otherwise, *y* is evaluated and the resulting value is returned." msgstr "" +"L'expression ``x and y`` commence par évaluer *x* ; si *x* est faux, sa " +"valeur est renvoyée ; sinon, *y* est évalué et la valeur résultante est " +"renvoyée." #: ../Doc/reference/expressions.rst:1524 msgid "" "The expression ``x or y`` first evaluates *x*; if *x* is true, its value is " "returned; otherwise, *y* is evaluated and the resulting value is returned." msgstr "" +"L'expression ``x or y`` commence par évaluer *x* ; si *x* est vrai, sa " +"valeur est renvoyée ; sinon, *y* est évalué et la valeur résultante est " +"renvoyée." #: ../Doc/reference/expressions.rst:1527 msgid "" @@ -2100,16 +2464,26 @@ msgid "" "create a new value, it returns a boolean value regardless of the type of its " "argument (for example, ``not 'foo'`` produces ``False`` rather than ``''``.)" msgstr "" +"Notez que ni :keyword:`and` ni :keyword:`or` ne restreignent la valeur et le " +"type qu'ils renvoient à ``False`` et ``True`` : ils renvoient le dernier " +"argument évalué. Ceci peut être utile, par exemple : si une chaîne ``s`` " +"doit être remplacée par une valeur par défaut si elle est vide, l'expression " +"``s or 'truc'`` produit la valeur voulue. Comme :keyword:`not` doit créer " +"une nouvelle valeur, il renvoie une valeur booléenne quel que soit le type " +"de son argument (par exemple, ``not 'truc'`` produit ``False`` plutôt que " +"``''``." #: ../Doc/reference/expressions.rst:1537 msgid "Conditional expressions" -msgstr "" +msgstr "Expressions conditionnelles" #: ../Doc/reference/expressions.rst:1548 msgid "" "Conditional expressions (sometimes called a \"ternary operator\") have the " "lowest priority of all Python operations." msgstr "" +"Les expressions conditionnelles (parfois appelées \"opérateur ternaire\") " +"sont les moins prioritaires de toutes les opérations Python." #: ../Doc/reference/expressions.rst:1551 msgid "" @@ -2117,14 +2491,18 @@ msgid "" "than *x*. If *C* is true, *x* is evaluated and its value is returned; " "otherwise, *y* is evaluated and its value is returned." msgstr "" +"L'expression ``x if C else y`` commence par évaluer la condition *C*. Si *C* " +"est vrai, alors *x* est évalué et sa valeur est renvoyée ; sinon, *y* est " +"évalué et sa valeur est renvoyée." #: ../Doc/reference/expressions.rst:1555 msgid "See :pep:`308` for more details about conditional expressions." msgstr "" +"Voir la :pep:`308` pour plus de détails sur les expressions conditionnelles." #: ../Doc/reference/expressions.rst:1562 msgid "Lambdas" -msgstr "" +msgstr "Expressions lambda" #: ../Doc/reference/expressions.rst:1573 msgid "" @@ -2133,6 +2511,9 @@ msgid "" "a function object. The unnamed object behaves like a function object " "defined with:" msgstr "" +"Les expressions lambda sont utilisées pour créer des fonctions anonymes. " +"L'expression ``lambda arguments: expression`` produit un objet fonction. Cet " +"objet anonyme se comporte comme un objet fonction défini par :" #: ../Doc/reference/expressions.rst:1582 msgid "" @@ -2140,10 +2521,13 @@ msgid "" "functions created with lambda expressions cannot contain statements or " "annotations." msgstr "" +"Voir la section :ref:`function` pour la syntaxe des listes de paramètres. " +"Notez que les fonctions créées par des expressions lambda ne peuvent pas " +"contenir d'instructions ou d'annotations." #: ../Doc/reference/expressions.rst:1590 msgid "Expression lists" -msgstr "" +msgstr "Listes d'expressions" #: ../Doc/reference/expressions.rst:1602 msgid "" @@ -2151,6 +2535,10 @@ msgid "" "least one comma yields a tuple. The length of the tuple is the number of " "expressions in the list. The expressions are evaluated from left to right." msgstr "" +"Sauf lorsqu'elle fait partie d'un agencement de liste ou d'ensemble, une " +"liste d'expressions qui contient au moins une virgule produit un n-uplet " +"(*tuple*). La longueur du n-uplet est le nombre d'expressions dans la liste. " +"Les expressions sont évaluées de la gauche vers la droite." #: ../Doc/reference/expressions.rst:1611 msgid "" @@ -2159,11 +2547,17 @@ msgid "" "which are included in the new tuple, list, or set, at the site of the " "unpacking." msgstr "" +"Un astérisque ``*`` indique :dfn:`dépaquetage d'itérable` (*iterable " +"unpacking* en anglais). Son opérande doit être un :term:`iterable`. " +"L'itérable est développé en une séquence d'éléments qui sont inclus dans un " +"nouvel objet *tuple*, *list* ou *set* à l'emplacement du dépaquetage." #: ../Doc/reference/expressions.rst:1616 msgid "" "Iterable unpacking in expression lists, originally proposed by :pep:`448`." msgstr "" +"dépaquetage d'itérables dans les listes d'expressions, proposé à l'origine " +"par la :pep:`448`." #: ../Doc/reference/expressions.rst:1621 msgid "" @@ -2173,10 +2567,15 @@ msgid "" "of that expression. (To create an empty tuple, use an empty pair of " "parentheses: ``()``.)" msgstr "" +"La virgule finale est nécessaire pour créer un singleton (c'est-à-dire un n-" +"uplet composé d'un seul élément) : elle est optionnelle dans tous les autres " +"cas. Une expression seule sans virgule finale ne crée pas un n-uplet mais " +"produit la valeur de cette expression (pour créer un *tuple* vide, utilisez " +"une paire de parenthèses vide : ``()``)." #: ../Doc/reference/expressions.rst:1631 msgid "Evaluation order" -msgstr "" +msgstr "Ordre d'évaluation" #: ../Doc/reference/expressions.rst:1635 msgid "" @@ -2184,16 +2583,21 @@ msgid "" "evaluating an assignment, the right-hand side is evaluated before the left-" "hand side." msgstr "" +"Python évalue les expressions de la gauche vers la droite. Remarquez que " +"lors de l'évaluation d'une assignation, la partie droite de l'assignation " +"est évaluée avant la partie gauche." #: ../Doc/reference/expressions.rst:1638 msgid "" "In the following lines, expressions will be evaluated in the arithmetic " "order of their suffixes::" msgstr "" +"Dans les lignes qui suivent, les expressions sont évaluées suivant l'ordre " +"arithmétique de leurs suffixes ::" #: ../Doc/reference/expressions.rst:1652 msgid "Operator precedence" -msgstr "" +msgstr "Priorités des opérateurs" #: ../Doc/reference/expressions.rst:1656 msgid "" @@ -2203,6 +2607,12 @@ msgid "" "explicitly given, operators are binary. Operators in the same box group " "left to right (except for exponentiation, which groups from right to left)." msgstr "" +"Le tableau suivant résume les priorités des opérateurs en Python, du moins " +"prioritaire au plus prioritaire. Les opérateurs qui sont dans la même case " +"ont la même priorité. À moins que la syntaxe ne soit explicitement indiquée, " +"les opérateurs sont binaires. Les opérateurs dans la même cases regroupent " +"de la gauche vers la droite (sauf pour la puissance qui regroupe de la " +"droite vers la gauche). " #: ../Doc/reference/expressions.rst:1662 msgid "" @@ -2210,10 +2620,13 @@ msgid "" "same precedence and have a left-to-right chaining feature as described in " "the :ref:`comparisons` section." msgstr "" +"Notez que les comparaisons, les tests d'appartenance et les tests " +"d'identifiants possèdent tous la même priorité et s'enchaînent de la gauche " +"vers la droite comme décrit dans la section :ref:`comparisons`." #: ../Doc/reference/expressions.rst:1668 msgid "Operator" -msgstr "" +msgstr "Opérateur" #: ../Doc/reference/expressions.rst:1668 msgid "Description" @@ -2221,7 +2634,7 @@ msgstr "Description" #: ../Doc/reference/expressions.rst:1670 msgid ":keyword:`lambda`" -msgstr "" +msgstr ":keyword:`lambda`" #: ../Doc/reference/expressions.rst:1670 msgid "Lambda expression" @@ -2229,69 +2642,72 @@ msgstr "Expression lambda" #: ../Doc/reference/expressions.rst:1672 msgid ":keyword:`if` -- :keyword:`else`" -msgstr "" +msgstr ":keyword:`if` -- :keyword:`else`" #: ../Doc/reference/expressions.rst:1672 msgid "Conditional expression" -msgstr "" +msgstr "Expressions conditionnelle" #: ../Doc/reference/expressions.rst:1674 msgid ":keyword:`or`" -msgstr "" +msgstr ":keyword:`or`" #: ../Doc/reference/expressions.rst:1674 msgid "Boolean OR" -msgstr "" +msgstr "OR (booléen)" #: ../Doc/reference/expressions.rst:1676 msgid ":keyword:`and`" -msgstr "" +msgstr ":keyword:`and`" #: ../Doc/reference/expressions.rst:1676 msgid "Boolean AND" -msgstr "" +msgstr "AND (booléen)" #: ../Doc/reference/expressions.rst:1678 msgid ":keyword:`not` ``x``" -msgstr "" +msgstr ":keyword:`not` ``x``" #: ../Doc/reference/expressions.rst:1678 msgid "Boolean NOT" -msgstr "" +msgstr "NOT (booléen)" #: ../Doc/reference/expressions.rst:1680 msgid "" ":keyword:`in`, :keyword:`not in`, :keyword:`is`, :keyword:`is not`, ``<``, " "``<=``, ``>``, ``>=``, ``!=``, ``==``" msgstr "" +":keyword:`in`, :keyword:`not in`, :keyword:`is`, :keyword:`is not`, ``<``, " +"``<=``, ``>``, ``>=``, ``!=``, ``==``" #: ../Doc/reference/expressions.rst:1680 msgid "Comparisons, including membership tests and identity tests" msgstr "" +"Comparaisons, y compris les tests d'appartenance et les tests d'identifiants" #: ../Doc/reference/expressions.rst:1684 msgid "``|``" -msgstr "" +msgstr "``|``" #: ../Doc/reference/expressions.rst:1684 msgid "Bitwise OR" -msgstr "" +msgstr "OR (bit à bit)" #: ../Doc/reference/expressions.rst:1686 msgid "``^``" -msgstr "" +msgstr "``^``" #: ../Doc/reference/expressions.rst:1686 msgid "Bitwise XOR" -msgstr "" +msgstr "XOR (bit à bit)" #: ../Doc/reference/expressions.rst:1688 msgid "``&``" -msgstr "" +msgstr "``&``" #: ../Doc/reference/expressions.rst:1688 msgid "Bitwise AND" -msgstr "" +msgstr "AND (bit à bit)" #: ../Doc/reference/expressions.rst:1690 msgid "``<<``, ``>>``" @@ -2299,7 +2715,7 @@ msgstr "``<<``, ``>>``" #: ../Doc/reference/expressions.rst:1690 msgid "Shifts" -msgstr "" +msgstr "décalages" #: ../Doc/reference/expressions.rst:1692 msgid "``+``, ``-``" @@ -2307,7 +2723,7 @@ msgstr "``+``, ``-``" #: ../Doc/reference/expressions.rst:1692 msgid "Addition and subtraction" -msgstr "" +msgstr "Addition et soustraction" #: ../Doc/reference/expressions.rst:1694 msgid "``*``, ``@``, ``/``, ``//``, ``%``" @@ -2318,6 +2734,8 @@ msgid "" "Multiplication, matrix multiplication, division, floor division, remainder " "[#]_" msgstr "" +"Multiplication, multiplication de matrices, division, division entière, " +"reste [#]_" #: ../Doc/reference/expressions.rst:1698 msgid "``+x``, ``-x``, ``~x``" @@ -2325,15 +2743,15 @@ msgstr "``+x``, ``-x``, ``~x``" #: ../Doc/reference/expressions.rst:1698 msgid "Positive, negative, bitwise NOT" -msgstr "" +msgstr "NOT (positif, négatif, bit à bit)" #: ../Doc/reference/expressions.rst:1700 msgid "``**``" -msgstr "" +msgstr "``**``" #: ../Doc/reference/expressions.rst:1700 msgid "Exponentiation [#]_" -msgstr "" +msgstr "Puissance [#]_" #: ../Doc/reference/expressions.rst:1702 msgid "``await`` ``x``" @@ -2342,20 +2760,25 @@ msgstr "``await`` ``x``" #: ../Doc/reference/expressions.rst:1704 msgid "``x[index]``, ``x[index:index]``, ``x(arguments...)``, ``x.attribute``" msgstr "" +"``x[indice]``, ``x[indice:indice]``, ``x(arguments...)``, ``x.attribut``" #: ../Doc/reference/expressions.rst:1704 msgid "Subscription, slicing, call, attribute reference" -msgstr "" +msgstr "indiçage, tranches, appel, référence à un attribut" #: ../Doc/reference/expressions.rst:1707 msgid "" "``(expressions...)``, ``[expressions...]``, ``{key: value...}``, " "``{expressions...}``" msgstr "" +"``(expressions...)``, ``[expressions...]``, ``{clé: valeur...}``, " +"``{expressions...}``" #: ../Doc/reference/expressions.rst:1707 msgid "Binding or tuple display, list display, dictionary display, set display" msgstr "" +"liaison ou agencement de n-uplet, agencement de liste, agencement de " +"dictionnaire, agencement d'ensemble" #: ../Doc/reference/expressions.rst:1715 msgid "Footnotes" @@ -2372,6 +2795,15 @@ msgid "" "the first argument instead, and so returns ``-1e-100`` in this case. Which " "approach is more appropriate depends on the application." msgstr "" +"Bien que ``abs(x%y) < abs(y)`` soit vrai mathématiquement, ce n'est pas " +"toujours vrai pour les nombres à virgule flottante en raison des arrondis. " +"Par exemple, en supposant que Python tourne sur une plateforme où les " +"*float* sont des nombres à double précision IEEE 754, afin que ``-1e-100 % " +"1e100`` soit du même signe que ``1e100``, le résultat calculé est ``-1e-100 " +"+ 1e100``, qui vaut exactement ``1e100`` dans ce standard. Or, la fonction :" +"func:`math.fmod` renvoie un résultat dont le signe est le signe du premier " +"argument, c'est-à-dire ``-1e-100`` dans ce cas. La meilleure approche dépend " +"de l'application." #: ../Doc/reference/expressions.rst:1725 msgid "" @@ -2380,6 +2812,10 @@ msgid "" "Python returns the latter result, in order to preserve that ``divmod(x,y)[0] " "* y + x % y`` be very close to ``x``." msgstr "" +"Si x est très proche d'un multiple entier de y, il est possible que ``x/y`` " +"soit supérieur de un par rapport à ``(x-x%y)//y`` en raison des arrondis. " +"Dans de tels cas, Python renvoie le second résultat afin d'avoir ``divmod(x," +"y)[0] * y + x % y`` le plus proche de ``x``." #: ../Doc/reference/expressions.rst:1730 msgid "" @@ -2394,6 +2830,17 @@ msgid "" "LETTER C), followed by a :dfn:`combining character` at code position U+0327 " "(COMBINING CEDILLA)." msgstr "" +"Le standard Unicode distingue les :dfn:`points codes` (*code points* en " +"anglais, par exemple U+0041) et les :dfn:`caractères abstraits` (*abstract " +"characters* en anglais, par exemple \"LATIN CAPITAL LETTER A\"). Bien que la " +"plupart des caractères abstraits de l'Unicode ne sont représentés que par un " +"seul point code, il y a un certain nombre de caractères abstraits qui " +"peuvent être représentés par une séquence de plus qu'un point code. Par " +"exemple, le caractère abstrait \"LATIN CAPITAL LETTER C WITH CEDILLA\" peut " +"être représenté comme un unique :dfn:`caractère précomposé` au point code U" +"+00C7, ou en tant que séquence d'un :dfn:`caractère de base` à la position U" +"+0043 (LATIN CAPITAL LETTER C) du code, suivi par un :dfn:`caractère " +"combiné` à la position U+0327 (COMBINING CEDILLA) du code." #: ../Doc/reference/expressions.rst:1741 msgid "" @@ -2402,12 +2849,20 @@ msgid "" "== \"\\u0043\\u0327\"`` is ``False``, even though both strings represent the " "same abstract character \"LATIN CAPITAL LETTER C WITH CEDILLA\"." msgstr "" +"Les opérateurs de comparaison des chaînes opèrent au niveau des points codes " +"Unicode. Cela peut être déroutant pour des humains. Par exemple, ``" +"\"\\u00C7\" == \"\\u0043\\u0327\"`` renvoie ``False``, bien que les deux " +"chaînes représentent le même caractère abstrait \"LATIN CAPITAL LETTER C " +"WITH CEDILLA\"." #: ../Doc/reference/expressions.rst:1746 msgid "" "To compare strings at the level of abstract characters (that is, in a way " "intuitive to humans), use :func:`unicodedata.normalize`." msgstr "" +"Pour comparer des chaînes au niveau des caractères abstraits (afin d'avoir " +"quelque chose d'intuitif pour les humains), utilisez :func:`unicodedata." +"normalize`." #: ../Doc/reference/expressions.rst:1749 msgid "" @@ -2416,15 +2871,24 @@ msgid "" "the :keyword:`is` operator, like those involving comparisons between " "instance methods, or constants. Check their documentation for more info." msgstr "" +"En raison du ramasse-miettes automatique et de la nature dynamique des " +"descripteurs, vous pouvez être confronté à un comportement semblant bizarre " +"lors de certaines utilisations de l'opérateur :keyword:`is`, par exemple si " +"cela implique des comparaisons entre des méthodes d'instances ou des " +"constantes. Allez vérifier dans la documentation pour plus d'informations." #: ../Doc/reference/expressions.rst:1754 msgid "" "The ``%`` operator is also used for string formatting; the same precedence " "applies." msgstr "" +"L'opérateur ``%`` est aussi utilisé pour formater les chaînes de " +"caractères ; il y possède la même priorité." #: ../Doc/reference/expressions.rst:1757 msgid "" "The power operator ``**`` binds less tightly than an arithmetic or bitwise " "unary operator on its right, that is, ``2**-1`` is ``0.5``." msgstr "" +"L'opérateur puissance ``**`` est moins prioritaire qu'un opérateur unaire " +"arithmétique ou bit à bit sur sa droite. Ainsi, ``2**-1`` vaut ``0.5``."