From bb4000d922535ae595c8b0c8da373465023a9c92 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Fri, 18 Nov 2022 09:20:58 +0000 Subject: [PATCH] poursuite des fuzzys de reference (#4) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - traitement des fuzzy - traduction de *generator function* par *fonction génératrice* Co-authored-by: Christophe Nanteuil Reviewed-on: https://git.afpy.org/AFPy/python-docs-fr/pulls/4 Reviewed-by: Julien Palard Co-authored-by: Christophe Nanteuil Co-committed-by: Christophe Nanteuil --- glossary.po | 13 +- reference/datamodel.po | 10 +- reference/expressions.po | 262 +++++++++++++++++++++----------------- reference/simple_stmts.po | 10 +- 4 files changed, 161 insertions(+), 134 deletions(-) diff --git a/glossary.po b/glossary.po index f2c2fe2b..a3642f6c 100644 --- a/glossary.po +++ b/glossary.po @@ -231,10 +231,11 @@ msgid "" "that it contains :keyword:`yield` expressions for producing a series of " "values usable in an :keyword:`async for` loop." msgstr "" -"Fonction qui renvoie un :term:`asynchronous generator iterator`. Cela " -"ressemble à une coroutine définie par :keyword:`async def`, sauf qu'elle " -"contient une ou des expressions :keyword:`yield` produisant ainsi uns série " -"de valeurs utilisables dans une boucle :keyword:`async for`." +"Fonction qui renvoie un :term:`itérateur de générateur asynchrone " +"`. Cela ressemble à une coroutine définie " +"par :keyword:`async def`, sauf qu'elle contient une ou des expressions " +":keyword:`yield` produisant ainsi uns série de valeurs utilisables dans une " +"boucle :keyword:`async for`." #: glossary.rst:104 msgid "" @@ -261,7 +262,7 @@ msgstr "itérateur de générateur asynchrone" #: glossary.rst:113 msgid "An object created by a :term:`asynchronous generator` function." -msgstr "Objet créé par une fonction :term:`asynchronous generator`." +msgstr "Objet créé par un :term:`générateur asynchrone `." #: glossary.rst:115 msgid "" @@ -1144,7 +1145,7 @@ msgid "" "iterator* in some contexts. In cases where the intended meaning isn't " "clear, using the full terms avoids ambiguity." msgstr "" -"Fait généralement référence à une fonction générateur mais peut faire " +"Fait généralement référence à une fonction génératrice mais peut faire " "référence à un *itérateur de générateur* dans certains contextes. Dans les " "cas où le sens voulu n'est pas clair, utiliser les termes complets lève " "l’ambiguïté." diff --git a/reference/datamodel.po b/reference/datamodel.po index 819682ce..2f5e871f 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -1179,7 +1179,7 @@ msgstr "" #: reference/datamodel.rst:657 msgid "Generator functions" -msgstr "Fonctions générateurs" +msgstr "Fonctions génératrices (ou générateurs)" #: reference/datamodel.rst:649 #, fuzzy @@ -1195,8 +1195,8 @@ msgid "" "values to be returned." msgstr "" "Une fonction ou une méthode qui utilise l'instruction :keyword:`yield` (voir " -"la section :ref:`yield`) est appelée :dfn:`fonction générateur`. Une telle " -"fonction, lorsqu'elle est appelée, retourne toujours un objet itérateur qui " +"la section :ref:`yield`) est appelée :dfn:`fonction génératrice`. Une telle " +"fonction, lorsqu'elle est appelée, renvoie toujours un objet itérateur qui " "peut être utilisé pour exécuter le corps de la fonction : appeler la " "méthode :meth:`iterator.__next__` de l'itérateur exécute la fonction jusqu'à " "ce qu'elle renvoie une valeur à l'aide de l'instruction :keyword:`!yield`. " @@ -1224,7 +1224,7 @@ msgstr "" #: reference/datamodel.rst:687 msgid "Asynchronous generator functions" -msgstr "Fonctions générateurs asynchrones" +msgstr "Fonctions génératrices (ou générateurs) asynchrones" #: reference/datamodel.rst:674 #, fuzzy @@ -1236,7 +1236,7 @@ msgid "" "execute the body of the function." msgstr "" "Une fonction ou une méthode définie avec :keyword:`async def` et qui utilise " -"l'instruction :keyword:`yield` est appelée :dfn:`fonction générateur " +"l'instruction :keyword:`yield` est appelée :dfn:`fonction génératrice " "asynchrone`. Une telle fonction, quand elle est appelée, renvoie un objet " "itérateur asynchrone qui peut être utilisé dans des instructions :keyword:" "`async for` pour exécuter le corps de la fonction." diff --git a/reference/expressions.po b/reference/expressions.po index e4078087..f186f1d2 100644 --- a/reference/expressions.po +++ b/reference/expressions.po @@ -2,12 +2,11 @@ # For licence information, see README file. # msgid "" - msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2022-10-18 15:46+0200\n" -"PO-Revision-Date: 2022-11-11 19:48+0100\n" +"PO-Revision-Date: 2022-11-18 09:54+0100\n" "Last-Translator: Jean Abou Samra \n" "Language-Team: FRENCH \n" "Language: fr\n" @@ -16,7 +15,6 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 2.4.2\n" - #: reference/expressions.rst:6 msgid "Expressions" msgstr "Expressions" @@ -332,7 +330,6 @@ msgstr "" "la portée implicite imbriquée." #: reference/expressions.rst:215 -#, fuzzy msgid "" "Since Python 3.6, in an :keyword:`async def` function, an :keyword:`!async " "for` clause may be used to iterate over a :term:`asynchronous iterator`. A " @@ -348,14 +345,14 @@ 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` ou :keyword:`!" -"async for` additionnelles facultatives et, possiblement, des expressions :" -"keyword:`await`. Si la compréhension contient soit des clauses :keyword:`!" -"async for`, soit des expressions :keyword:`!await`, elle est appelée :dfn:" -"`compréhension asynchrone`. Une compréhension asynchrone peut suspendre " -"l'exécution de la fonction coroutine dans laquelle elle apparaît. Voir aussi " -"la :pep:`530`." +"keyword:`!async def` consiste alors à avoir, après cette expression de tête, " +"une clause :keyword:`!for` ou :keyword:`!async for` suivie par des clauses :" +"keyword:`!for` ou :keyword:`!async for` additionnelles facultatives et, " +"possiblement, des expressions :keyword:`await`. Si la compréhension contient " +"des clauses :keyword:`!async for`, des expressions :keyword:`!await` ou " +"d'autres compréhensions asynchrones, elle est appelée :dfn:`compréhension " +"asynchrone`. Une compréhension asynchrone peut suspendre l'exécution de la " +"fonction coroutine dans laquelle elle apparaît. Voir aussi la :pep:`530`." #: reference/expressions.rst:227 msgid "Asynchronous comprehensions were introduced." @@ -367,11 +364,15 @@ msgstr "" "``yield`` et ``yield from`` sont interdites dans la portée implicite " "imbriquée." +# suit un ':' #: reference/expressions.rst:233 msgid "" "Asynchronous comprehensions are now allowed inside comprehensions in " "asynchronous functions. Outer comprehensions implicitly become asynchronous." msgstr "" +"les compréhensions asynchrones sont maintenant autorisées dans les " +"compréhensions des fonctions asynchrones. Les compréhensions englobantes " +"deviennent implicitement asynchrones." #: reference/expressions.rst:242 msgid "List displays" @@ -629,7 +630,6 @@ msgid "Yield expressions" msgstr "Expressions ``yield``" #: reference/expressions.rst:427 -#, fuzzy msgid "" "The yield expression is used when defining a :term:`generator` function or " "an :term:`asynchronous generator` function and thus can only be used in the " @@ -638,13 +638,14 @@ msgid "" "keyword:`async def` function's body causes that coroutine function to be an " "asynchronous generator function. For example::" msgstr "" -"Une expression ``yield`` est utilisée pour définir une fonction :term:" -"`générateur` ou une fonction :term:`génératrice 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 ::" +"Une expression ``yield`` est utilisée pour définir une :term:`fonction " +"génératrice ` ou une :term:`fonction génératrice 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 une fonction " +"génératrice et son utilisation dans le corps d'une fonction :keyword:`async " +"def` entraine que cette fonction coroutine devient une fonction génératrice " +"asynchrone. Par exemple ::" #: reference/expressions.rst:440 msgid "" @@ -676,7 +677,6 @@ msgstr "" "`asynchronous-generator-functions`." #: reference/expressions.rst:452 -#, fuzzy msgid "" "When a generator function is called, it returns an iterator known as a " "generator. That generator then controls the execution of the generator " @@ -700,18 +700,18 @@ msgstr "" "génératrice. L'exécution commence lorsque l'une des méthodes du générateur " "est appelée. À ce moment, l'exécution se déroule jusqu'à la première " "expression ``yield``, où elle se suspend, renvoyant la valeur de :token:" -"`expression_list` à l'appelant du générateur. Cette suspension conserve tous " -"les états locaux, y compris les liaisons en cours des variables locales, le " -"pointeur d'instruction, la pile d'évaluation interne et l'état de tous les " -"gestionnaires d'exceptions. Lorsque l'exécution reprend en appelant l'une " -"des méthodes du générateur, la fonction s'exécute exactement comme si " -"l'expression ``yield`` n'avait été qu'un simple appel externe. La valeur de " -"l'expression ``yield`` après reprise dépend de la méthode qui a permis la " -"reprise de l'exécution. Si c'est :meth:`~generator.__next__` qui a été " -"utilisée (typiquement *via* un :keyword:`for` ou la fonction native :func:" -"`next`) alors le résultat est :const:`None`. Sinon, si c'est :meth:" -"`~generator.send` qui a été utilisée, alors le résultat est la valeur " -"transmise à cette méthode." +"`~python-grammar: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 (généralement *via* un :" +"keyword:`for` ou la fonction native :func:`next`) alors le résultat est :" +"const:`None`. Sinon, si c'est :meth:`~generator.send` qui a été utilisée, " +"alors le résultat est la valeur transmise à cette méthode." #: reference/expressions.rst:470 msgid "" @@ -820,13 +820,12 @@ msgid ":pep:`380` - Syntax for Delegating to a Subgenerator" msgstr ":pep:`380` -- Syntaxe pour déléguer à un sous-générateur" #: reference/expressions.rst:516 -#, fuzzy msgid "" "The proposal to introduce the :token:`~python-grammar:yield_from` syntax, " "making delegation to subgenerators 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." +"Proposition d'introduire la syntaxe :token:`~python-grammar:yield_from`, de " +"manière à déléguer facilement l'exécution à un sous-générateur." #: reference/expressions.rst:520 msgid ":pep:`525` - Asynchronous Generators" @@ -850,7 +849,7 @@ msgid "" "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." +"peuvent être utilisées pour contrôler l'exécution des fonctions génératrices." #: reference/expressions.rst:532 msgid "" @@ -862,7 +861,6 @@ msgstr "" "`ValueError`." #: reference/expressions.rst:540 -#, fuzzy msgid "" "Starts the execution of a generator function or resumes it at the last " "executed yield expression. When a generator function is resumed with a :" @@ -873,14 +871,14 @@ msgid "" "caller. If the generator exits without yielding another value, a :exc:" "`StopIteration` exception is raised." msgstr "" -"Démarre l'exécution d'une fonction générateur ou la reprend à la dernière " -"expression ``yield`` exécutée. Quand une fonction générateur est reprise par " -"une méthode :meth:`~generator.__next__`, l'expression ``yield`` en cours " +"Démarre l'exécution d'une fonction génératrice ou la reprend à la dernière " +"expression ``yield`` exécutée. Quand une fonction génératrice est reprise " +"par une méthode :meth:`~generator.__next__`, l'expression ``yield`` en cours " "s'évalue toujours à :const:`None`. L'exécution continue ensuite jusqu'à " "l'expression ``yield`` suivante, où le générateur est à nouveau suspendu et " -"la valeur de :token:`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." +"la valeur de :token:`~python-grammar:expression_list` est renvoyée à la " +"méthode :meth:`__next__` de l'appelant. Si le générateur termine sans donner " +"une autre valeur, une exception :exc:`StopIteration` est levée." #: reference/expressions.rst:549 msgid "" @@ -900,7 +898,7 @@ 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. " +"Reprend l'exécution et « envoie » une valeur à la fonction génératrice. " "L'argument *value* devient le résultat de l'expression ``yield`` courante. " "La méthode :meth:`send` renvoie la valeur suivante produite par le " "générateur ou lève :exc:`StopIteration` si le générateur termine sans " @@ -909,7 +907,6 @@ msgstr "" "aucune expression ``yield`` qui peut recevoir la valeur." #: reference/expressions.rst:567 -#, fuzzy msgid "" "Raises an exception at the point where the generator was paused, and returns " "the next value yielded by the generator function. If the generator exits " @@ -917,18 +914,19 @@ msgid "" "If the generator function does not catch the passed-in exception, or raises " "a different exception, then that exception propagates to the caller." msgstr "" -"Lève une exception de type ``type`` à l'endroit où le générateur est en " -"pause et renvoie la valeur suivante produite par la fonction générateur. Si " -"le générateur termine sans produire de nouvelle valeur, une exception :exc:" -"`StopIteration` est levée. Si la fonction génératrice ne gère pas " -"l'exception passée ou lève une autre exception, alors cette exception est " -"propagée vers l'appelant." +"Lève une exception à l'endroit où le générateur est en pause et renvoie la " +"valeur suivante produite par la fonction génératrice. Si le générateur " +"termine sans produire de nouvelle valeur, une exception :exc:`StopIteration` " +"est levée. Si la fonction génératrice ne gère pas l'exception passée ou lève " +"une autre exception, alors cette exception est propagée vers l'appelant." #: reference/expressions.rst:573 msgid "" "In typical use, this is called with a single exception instance similar to " "the way the :keyword:`raise` keyword is used." msgstr "" +"Dans son utilisation typique, elle est appelée avec une seule instance " +"d'exception, de façon similaire à l'utilisation du mot-clé :keyword:`raise`." #: reference/expressions.rst:576 msgid "" @@ -940,6 +938,13 @@ msgid "" "any existing :attr:`~BaseException.__traceback__` attribute stored in " "*value* may be cleared." msgstr "" +"Cependant, pour assurer la rétrocompatibilité, la deuxième signature est " +"prise en charge, suivant une convention des anciennes versions de Python. " +"L'argument *type* doit être une classe d'exception et *value* doit être une " +"instance d'exception. Si *value* n'est pas fournie, le constructeur de " +"*type* est appelé pour obtenir une instance. Si *traceback* est fournie, " +"elle est liée sur l'exception, sinon tout attribut :attr:`~BaseException." +"__traceback__` existant stocké dans *value* est possiblement effacé." #: reference/expressions.rst:590 msgid "" @@ -1010,7 +1015,6 @@ msgstr "" "générateur serait utilisé dans une instruction :keyword:`for`." #: reference/expressions.rst:649 -#, fuzzy msgid "" "Calling one of the asynchronous generator's methods returns an :term:" "`awaitable` object, and the execution starts when this object is awaited on. " @@ -1032,10 +1036,10 @@ msgstr "" "`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 " +"la valeur de :token:`~python-grammar: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 " @@ -1056,6 +1060,16 @@ msgid "" "the async generator by calling :meth:`~agen.aclose` method to finalize the " "generator and ultimately detach it from the event loop." msgstr "" +"Si un générateur asynchrone se termine précipitamment en raison d'un :" +"keyword:`break`, de l'annulation de la tâche de l'appelant ou d'une " +"exception, le code de nettoyage du générateur asynchrone est exécuté et lève " +"possiblement des exceptions, accède à des variables de contexte dans un " +"contexte inattendu — peut-être parce que la tâche de laquelle il dépend est " +"finie, ou pendant la fermeture de la boucle d'événements quand le point " +"d'entrée du ramasse-miettes a déjà été appelé. Afin d'éviter cette " +"situation, l'appelant doit explicitement fermer le générateur asynchrone en " +"appelant la méthode :meth:`~agen.aclose` pour « finaliser » le générateur et " +"le détacher de la boucle d'événements." #: reference/expressions.rst:674 msgid "" @@ -1083,7 +1097,6 @@ msgstr "" "ainsi à toute clause :keyword:`!finally` en attente d'être exécutée." #: reference/expressions.rst:685 -#, fuzzy msgid "" "To take care of finalization upon event loop termination, an event loop " "should define a *finalizer* function which takes an asynchronous generator-" @@ -1127,7 +1140,6 @@ msgstr "" "génératrices." #: reference/expressions.rst:711 -#, fuzzy msgid "" "Returns an awaitable which when run starts to execute the asynchronous " "generator or resumes it at the last executed yield expression. When an " @@ -1143,15 +1155,15 @@ msgid "" 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 " +"expression ``yield`` exécutée. Quand une fonction génératrice 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." +"de :token:`~python-grammar: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." #: reference/expressions.rst:723 msgid "" @@ -1176,7 +1188,7 @@ msgid "" 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 " +"générateur, elle « envoie » une valeur *value* à la fonction génératrice " "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:" @@ -1286,12 +1298,18 @@ msgid "" "term:`generic class ` will generally return a :ref:" "`GenericAlias ` object." msgstr "" +"L'inscription d'une instance de :ref:`classe containeur ` " +"sélectionne généralement un élément du conteneur. L'inscription d'une :term:" +"`classe générique ` renvoie généralement un objet :ref:" +"`GenericAlias `." #: reference/expressions.rst:839 msgid "" "When an object is subscripted, the interpreter will evaluate the primary and " "the expression list." msgstr "" +"Lorsqu'on accède à l'indice d'un objet, l'interpréteur évalue la primaire et " +"la liste d'expressions." #: reference/expressions.rst:842 msgid "" @@ -1302,6 +1320,13 @@ msgid "" "one of these methods. For more details on when ``__class_getitem__`` is " "called instead of ``__getitem__``, see :ref:`classgetitem-versus-getitem`." msgstr "" +"L'évaluation de la primaire doit produire un objet qui gère l'indiçage. Un " +"objet est susceptible de gérer l'indiçage s'il définit la ou les deux " +"méthodes :meth:`~object.__getitem__` et :meth:`~object.__class_getitem__`. " +"Quand on spécifie un indice du primaire, le résultat de l'évaluation de la " +"liste d'expression est passé à l'une de ces méthodes. Pour plus de détails " +"sur le choix de ``__class_getitem__`` ou ``__getitem__`` pour l'appel, " +"lisez :ref:`classgetitem-versus-getitem`." #: reference/expressions.rst:849 msgid "" @@ -1309,43 +1334,48 @@ msgid "" "class:`tuple` containing the items of the expression list. Otherwise, the " "expression list will evaluate to the value of the list's sole member." msgstr "" +"Si la liste d'expressions contient au moins une virgule, elle est considérée " +"comme un :class:`n-uplet ` contenant les éléments de la liste " +"d'expressions. Sinon, la liste d'expressions est évaluée à la valeur du seul " +"membre de la liste." #: reference/expressions.rst:853 -#, fuzzy msgid "" "For built-in objects, there are two types of objects that support " "subscription via :meth:`~object.__getitem__`:" -msgstr "Pour les objets natifs, deux types d'objets gèrent la sélection :" +msgstr "" +"Pour les objets natifs, deux types d'objets gèrent la sélection *via* :meth:" +"`~object.__getitem__` :" #: reference/expressions.rst:856 -#, fuzzy msgid "" "Mappings. If the primary is a :term:`mapping`, the expression list must " "evaluate to an object whose value is one of the keys of the mapping, and the " "subscription selects the value in the mapping that corresponds to that key. " "An example of a builtin mapping class is the :class:`dict` class." 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)." +"Si la primaire est un :term:`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é. Un exemple de classe implémentant le concept de tableau de " +"correspondances est la classe :class:`dict`." #: reference/expressions.rst:860 -#, fuzzy msgid "" "Sequences. If the primary is a :term:`sequence`, the expression list must " "evaluate to an :class:`int` or a :class:`slice` (as discussed in the " "following section). Examples of builtin sequence classes include the :class:" "`str`, :class:`list` and :class:`tuple` classes." 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)." +"Si la primaire est une :term:`séquence `, la liste d'expressions " +"(*expression_list* dans la grammaire) doit pouvoir être évaluée comme un :" +"class:`entier ` ou une :class:`tranche ` (comme expliqué dans la " +"section suivante). Des exemples de classes natives implémentant le concept " +"de séquence sont les :class:`chaînes `, :class:`listes ` et les :" +"class:`n-uplets `." #: reference/expressions.rst:865 -#, fuzzy msgid "" "The formal syntax makes no special provision for negative indices in :term:" "`sequences `. However, built-in sequences all provide a :meth:" @@ -1358,27 +1388,27 @@ msgid "" "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." +"La syntaxe formelle ne traite pas des cas d'indices négatifs dans les :term:" +"`séquences ` ; cependant, toutes les séquences natives possèdent " +"une méthode :meth:`~object.__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." #: reference/expressions.rst:879 -#, fuzzy msgid "" "A :class:`string ` is a special kind of sequence whose 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." +"Une :class:`chaîne ` est une espèce particulière de séquence dont les " +"éléments sont des *caractères*. Un caractère n'est pas un type en tant que " +"tel, c'est une chaîne de longueur un." #: reference/expressions.rst:887 msgid "Slicings" @@ -1484,7 +1514,6 @@ msgstr "" "` formels." #: reference/expressions.rst:983 -#, fuzzy msgid "" "If keyword arguments are present, they are first converted to positional " "arguments, as follows. First, a list of unfilled slots is created for the " @@ -1511,18 +1540,18 @@ msgstr "" "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." +"*slot* est déjà rempli, une exception :exc:`TypeError` est levée. Sinon, " +"l'argument est placé 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." #: reference/expressions.rst:1003 msgid "" @@ -1597,14 +1626,13 @@ msgstr "" "voir ci-dessous). Ainsi ::" #: reference/expressions.rst:1049 -#, fuzzy 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 often 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." +"fait que la confusion reste rare." #: reference/expressions.rst:1055 msgid "" @@ -2390,8 +2418,8 @@ msgid "" "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é." +"et seulement si toutes leurs paires ``(clé, valeur)`` sont égales. " +"L'égalité des clés et des valeurs met en œuvre la réflexivité." #: reference/expressions.rst:1547 msgid "" @@ -2719,7 +2747,6 @@ msgid "Assignment expressions" msgstr "Expressions d'affectation" #: reference/expressions.rst:1729 -#, fuzzy msgid "" "An assignment expression (sometimes also called a \"named expression\" or " "\"walrus\") assigns an :token:`~python-grammar:expression` to an :token:" @@ -2727,8 +2754,9 @@ msgid "" "`~python-grammar:expression`." msgstr "" "Une expression d'affectation (parfois aussi appelée « expression nommée » ou " -"« expression morse ») affecte l':token:`expression` à un :token:" -"`identifiant` et renvoie la valeur de l':token:`expression`." +"« expression morse ») affecte l':token:`expression <~python-grammar:" +"expression>` à un :token:`identifiant<~python-grammar:identifier>` et " +"renvoie la valeur de l':token:`~python-grammar:expression`." #: reference/expressions.rst:1734 msgid "One common use case is when handling matched regular expressions:" @@ -2929,9 +2957,8 @@ msgid "Subscription, slicing, call, attribute reference" msgstr "indiçage, tranches, appel, référence à un attribut" #: reference/expressions.rst:1901 -#, fuzzy msgid ":keyword:`await x `" -msgstr ":keyword:`await` ``x``" +msgstr ":keyword:`await x `" #: reference/expressions.rst:1903 msgid "``**``" @@ -3015,9 +3042,8 @@ msgstr "" "Comparaisons, y compris les tests d'appartenance et les tests d'identifiants" #: reference/expressions.rst:1925 -#, fuzzy msgid ":keyword:`not x `" -msgstr ":keyword:`not` ``x``" +msgstr ":keyword:`not x `" #: reference/expressions.rst:1925 msgid "Boolean NOT" diff --git a/reference/simple_stmts.po b/reference/simple_stmts.po index b8107989..a7cec20a 100644 --- a/reference/simple_stmts.po +++ b/reference/simple_stmts.po @@ -729,7 +729,7 @@ msgid "" "returned value (if any) is used as an argument to construct :exc:" "`StopIteration` and becomes the :attr:`StopIteration.value` attribute." msgstr "" -"Dans une fonction générateur, l'instruction :keyword:`return` indique que le " +"Dans une fonction génératrice, l'instruction :keyword:`return` indique que le " "générateur est terminé et provoque la levée d'une :exc:`StopIteration`. La " "valeur de retour (s'il y en a une) est utilisée comme argument pour " "construire l'exception :exc:`StopIteration` et devient l'attribut :attr:" @@ -742,10 +742,10 @@ msgid "" "`StopAsyncIteration` to be raised. A non-empty :keyword:`!return` statement " "is a syntax error in an asynchronous generator function." msgstr "" -"Dans une fonction générateur asynchrone, une instruction :keyword:`return` " +"Dans une fonction génératrice asynchrone, une instruction :keyword:`return` " "vide indique que le générateur asynchrone est terminé et provoque la levée " "d'une :exc:`StopAsyncIteration`. Une instruction :keyword:`!return` non vide " -"est une erreur de syntaxe dans une fonction générateur asynchrone." +"est une erreur de syntaxe dans une fonction génératrice asynchrone." #: reference/simple_stmts.rst:517 msgid "The :keyword:`!yield` statement" @@ -777,9 +777,9 @@ msgid "" msgstr "" "Les expressions et les instructions *yield* sont utilisées seulement dans la " "définition des fonctions :term:`générateurs ` et apparaissent " -"uniquement dans le corps de la fonction générateur. L'utilisation de *yield* " +"uniquement dans le corps de la fonction génératrice. L'utilisation de *yield* " "dans la définition d'une fonction est suffisant pour que cette définition " -"crée une fonction générateur au lieu d'une fonction normale." +"crée une fonction génératrice au lieu d'une fonction normale." #: reference/simple_stmts.rst:547 msgid ""