poursuite des fuzzys de reference (#4)

- traitement des fuzzy
- traduction de *generator function* par *fonction génératrice*

Co-authored-by: Christophe Nanteuil <christophe.nanteuil@gmail.com>
Reviewed-on: AFPy/python-docs-fr#4
Reviewed-by: Julien Palard <julien@palard.fr>
Co-authored-by: Christophe Nanteuil <christophenan@noreply.localhost>
Co-committed-by: Christophe Nanteuil <christophenan@noreply.localhost>

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 "
+"Fonction qui renvoie un :term:`itérateur de générateur asynchrone "
-"ressemble à une coroutine définie par :keyword:`async def`, sauf qu'elle "
+"<asynchronous generator iterator>`. Cela ressemble à une coroutine définie "
-"contient une ou des expressions :keyword:`yield` produisant ainsi uns série "
+"par :keyword:`async def`, sauf qu'elle contient une ou des expressions "
-"de valeurs utilisables dans une boucle :keyword:`async for`."
+":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 <asynchronous generator>`."
 
 #: 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é."

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 "
+"la section :ref:`yield`) est appelée :dfn:`fonction génératrice`. Une telle "
-"fonction, lorsqu'elle est appelée, retourne toujours un objet itérateur qui "
+"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."

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 <jean@abou-samra.fr>\n"
 "Language-Team: FRENCH <traductions@lists.afpy.org>\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 <asynchronous iterator>`. Une compréhension dans une fonction :"
-"keyword:`!async def` consiste alors à avoir une clause :keyword:`!for` or :"
+"keyword:`!async def` consiste alors à avoir, après cette expression de tête, "
-"keyword:`!async for` suivie par des clauses :keyword:`!for` ou :keyword:`!"
+"une clause :keyword:`!for` ou :keyword:`!async for` suivie par des clauses :"
-"async for` additionnelles facultatives et, possiblement, des expressions :"
+"keyword:`!for` ou :keyword:`!async for` additionnelles facultatives et, "
-"keyword:`await`. Si la compréhension contient soit des clauses :keyword:`!"
+"possiblement, des expressions :keyword:`await`. Si la compréhension contient "
-"async for`, soit des expressions :keyword:`!await`, elle est appelée :dfn:"
+"des clauses :keyword:`!async for`, des expressions :keyword:`!await` ou "
-"`compréhension asynchrone`. Une compréhension asynchrone peut suspendre "
+"d'autres compréhensions asynchrones, elle est appelée :dfn:`compréhension "
-"l'exécution de la fonction coroutine dans laquelle elle apparaît. Voir aussi "
+"asynchrone`. Une compréhension asynchrone peut suspendre l'exécution de la "
-"la :pep:`530`."
+"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:"
+"Une expression ``yield`` est utilisée pour définir une :term:`fonction "
-"`générateur` ou une fonction :term:`génératrice asynchrone <asynchronous "
+"génératrice <generator>` ou une :term:`fonction génératrice asynchrone "
-"generator>` et ne peut donc être utilisée que dans le corps de la définition "
+"<asynchronous generator>` et ne peut donc être utilisée que dans le corps de "
-"d'une fonction. L'utilisation d'une expression ``yield`` dans le corps d'une "
+"la définition d'une fonction. L'utilisation d'une expression ``yield`` dans "
-"fonction entraîne que cette fonction devient un générateur et son "
+"le corps d'une fonction entraîne que cette fonction devient une fonction "
-"utilisation dans le corps d'une fonction :keyword:`async def` entraine que "
+"génératrice et son utilisation dans le corps d'une fonction :keyword:`async "
-"cette fonction coroutine devient un générateur asynchrone. Par exemple ::"
+"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 "
+"`~python-grammar:expression_list` à l'appelant du générateur. Cette "
-"les états locaux, y compris les liaisons en cours des variables locales, le "
+"suspension conserve tous les états locaux, y compris les liaisons en cours "
-"pointeur d'instruction, la pile d'évaluation interne et l'état de tous les "
+"des variables locales, le pointeur d'instruction, la pile d'évaluation "
-"gestionnaires d'exceptions.  Lorsque l'exécution reprend en appelant l'une "
+"interne et l'état de tous les gestionnaires d'exceptions.  Lorsque "
-"des méthodes du générateur, la fonction s'exécute exactement comme si "
+"l'exécution reprend en appelant l'une des méthodes du générateur, la "
-"l'expression ``yield`` n'avait été qu'un simple appel externe. La valeur de "
+"fonction s'exécute exactement comme si l'expression ``yield`` n'avait été "
-"l'expression ``yield`` après reprise dépend de la méthode qui a permis la "
+"qu'un simple appel externe. La valeur de l'expression ``yield`` après "
-"reprise de l'exécution. Si c'est :meth:`~generator.__next__` qui a été "
+"reprise dépend de la méthode qui a permis la reprise de l'exécution. Si "
-"utilisée (typiquement *via* un :keyword:`for` ou la fonction native :func:"
+"c'est :meth:`~generator.__next__` qui a été utilisée (généralement *via* un :"
-"`next`) alors le résultat est :const:`None`. Sinon, si c'est :meth:"
+"keyword:`for` ou la fonction native :func:`next`) alors le résultat est :"
-"`~generator.send` qui a été utilisée, alors le résultat est la valeur "
+"const:`None`. Sinon, si c'est :meth:`~generator.send` qui a été utilisée, "
-"transmise à cette méthode."
+"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 à "
+"Proposition d'introduire la syntaxe :token:`~python-grammar:yield_from`, de "
-"déléguer facilement l'exécution à un sous-générateur."
+"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 "
+"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érateur est reprise par "
+"expression ``yield`` exécutée. Quand une fonction génératrice est reprise "
-"une méthode :meth:`~generator.__next__`, l'expression ``yield`` en cours "
+"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:"
+"la valeur de :token:`~python-grammar:expression_list` est renvoyée à la "
-"`__next__` de l'appelant. Si le générateur termine sans donner une autre "
+"méthode :meth:`__next__` de l'appelant. Si le générateur termine sans donner "
-"valeur, une exception :exc:`StopIteration` est levée."
+"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 "
+"Lève une exception à l'endroit où le générateur est en pause et renvoie la "
-"pause et renvoie la valeur suivante produite par la fonction générateur. Si "
+"valeur suivante produite par la fonction génératrice. Si le générateur "
-"le générateur termine sans produire de nouvelle valeur, une exception :exc:"
+"termine sans produire de nouvelle valeur, une exception :exc:`StopIteration` "
-"`StopIteration` est levée. Si la fonction génératrice ne gère pas "
+"est levée. Si la fonction génératrice ne gère pas l'exception passée ou lève "
-"l'exception passée ou lève une autre exception, alors cette exception est "
+"une autre exception, alors cette exception est propagée vers l'appelant."
-"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 "
+"la valeur de :token:`~python-grammar:expression_list` à la coroutine en "
-"un générateur, la suspension signifie que tous les états locaux sont "
+"attente. Comme pour un générateur, la suspension signifie que tous les états "
-"conservés, y compris les liaisons des variables locales, le pointeur "
+"locaux sont conservés, y compris les liaisons des variables locales, le "
-"d'instruction, la pile d'évaluation interne et l'état de tous les "
+"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 "
+"de :token:`~python-grammar:expression_list` de l'expression ``yield`` est la "
-"l'exception :exc:`StopIteration` levée par la coroutine qui termine. Si le "
+"valeur de l'exception :exc:`StopIteration` levée par la coroutine qui "
-"générateur asynchrone termine sans produire d'autre valeur, le *awaitable* "
+"termine. Si le générateur asynchrone termine sans produire d'autre valeur, "
-"lève une exception :exc:`StopAsyncIteration` qui signale que l'itération "
+"le *awaitable* lève une exception :exc:`StopAsyncIteration` qui signale que "
-"asynchrone est terminée."
+"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 <generic type>` will generally return a :ref:"
 "`GenericAlias <types-genericalias>` object."
 msgstr ""
+"L'inscription d'une instance de :ref:`classe containeur <sequence-types>` "
+"sélectionne généralement un élément du conteneur. L'inscription d'une :term:"
+"`classe générique <generic type>` renvoie généralement un objet :ref:"
+"`GenericAlias <types-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 <tuple>` 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 "
+"Si la primaire est un :term:`tableau de correspondances <mapping>`, la liste "
-"(*expression_list* dans la grammaire formelle ci-dessous) doit pouvoir être "
+"d'expressions (*expression_list* dans la grammaire formelle ci-dessous) doit "
-"évaluée comme un objet dont la valeur est une des clés du tableau de "
+"pouvoir être évaluée comme un objet dont la valeur est une des clés du "
-"correspondances et la sélection désigne la valeur qui correspond à cette clé "
+"tableau de correspondances et la sélection désigne la valeur qui correspond "
-"(la liste d'expressions est un *n*-uplet sauf si elle comporte exactement un "
+"à cette clé. Un exemple de classe implémentant le concept de tableau de "
-"élément)."
+"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* "
+"Si la primaire est une :term:`séquence <sequence>`, la liste d'expressions "
-"dans la grammaire) doit pouvoir être évaluée comme un entier ou une tranche "
+"(*expression_list* dans la grammaire) doit pouvoir être évaluée comme un :"
-"(comme expliqué dans la section suivante)."
+"class:`entier <int>` ou une :class:`tranche <slice>` (comme expliqué dans la "
+"section suivante). Des exemples de classes natives implémentant le concept "
+"de séquence sont les :class:`chaînes <str>`, :class:`listes <list>` et les :"
+"class:`n-uplets <tuple>`."
 
 #: reference/expressions.rst:865
-#, fuzzy
 msgid ""
 "The formal syntax makes no special provision for negative indices in :term:"
 "`sequences <sequence>`. 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 "
+"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 :"
+"`séquences <sequence>` ; cependant, toutes les séquences natives possèdent "
-"meth:`__getitem__` qui interprète les indices négatifs en ajoutant la "
+"une méthode :meth:`~object.__getitem__` qui interprète les indices négatifs "
-"longueur de la séquence à l'indice (de manière à ce que ``x[-1]`` "
+"en ajoutant la longueur de la séquence à l'indice (de manière à ce que "
-"sélectionne le dernier élément de ``x``). La valeur résultante doit être un "
+"``x[-1]`` sélectionne le dernier élément de ``x``). La valeur résultante "
-"entier positif ou nul, inférieur au nombre d'éléments dans la séquence ; la "
+"doit être un entier positif ou nul, inférieur au nombre d'éléments dans la "
-"sélection désigne alors l'élément dont l'indice est cette valeur (en "
+"séquence ; la sélection désigne alors l'élément dont l'indice est cette "
-"comptant à partir de zéro). Comme la gestion des indices négatifs et des "
+"valeur (en comptant à partir de zéro). Comme la gestion des indices négatifs "
-"tranches est faite par la méthode :meth:`__getitem__`, les sous-classes qui "
+"et des tranches est faite par la méthode :meth:`__getitem__`, les sous-"
-"surchargent cette méthode doivent aussi savoir les gérer, de manière "
+"classes qui surchargent cette méthode doivent aussi savoir les gérer, de "
-"explicite."
+"manière explicite."
 
 #: reference/expressions.rst:879
-#, fuzzy
 msgid ""
 "A :class:`string <str>` 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 "
+"Une :class:`chaîne <str>` est une espèce particulière de séquence dont les "
-"en tant que tel, c'est une chaîne de longueur un."
+"é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 ""
 "<parameter>` 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 "
+"*slot* est déjà rempli, une exception :exc:`TypeError` est levée. Sinon, "
-"valeur de l'argument est placée dans le *slot*, ce qui le remplit (même si "
+"l'argument est placé dans le *slot*, ce qui le remplit (même si l'expression "
-"l'expression est ``None``, cela remplit le *slot*). Quand tous les arguments "
+"est ``None``, cela remplit le *slot*). Quand tous les arguments ont été "
-"ont été traités, les *slots* qui sont toujours vides sont remplis avec la "
+"traités, les *slots* qui sont toujours vides sont remplis avec la valeur par "
-"valeur par défaut correspondante dans la définition de la fonction (les "
+"défaut correspondante dans la définition de la fonction (les valeurs par "
-"valeurs par défaut sont calculées, une seule fois, lorsque la fonction est "
+"défaut sont calculées, une seule fois, lorsque la fonction est définie ; "
-"définie ; ainsi, un objet mutable tel qu'une liste ou un dictionnaire "
+"ainsi, un objet mutable tel qu'une liste ou un dictionnaire utilisé en tant "
-"utilisé en tant valeur par défaut sera partagé entre tous les appels qui ne "
+"valeur par défaut sera partagé entre tous les appels qui ne spécifient pas "
-"spécifient pas de valeur d argument pour ce *slot* ; on évite généralement "
+"de valeur d argument pour ce *slot* ; on évite généralement de faire ça). "
-"de faire ça). S'il reste des *slots* pour lesquels aucune valeur par défaut "
+"S'il reste des *slots* pour lesquels aucune valeur par défaut n'est définie, "
-"n'est définie, une exception :exc:`TypeError` est levée. Sinon, la liste des "
+"une exception :exc:`TypeError` est levée. Sinon, la liste des *slots* "
-"*slots* remplie est utilisée en tant que liste des arguments pour l'appel."
+"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é "
+"et seulement si toutes leurs paires ``(clé, valeur)`` sont égales.  "
-"des clés et des valeurs met en œuvre la réflexivité."
+"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:"
+"« expression morse ») affecte l':token:`expression <~python-grammar:"
-"`identifiant` et renvoie la valeur de l':token:`expression`."
+"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 <await>`"
-msgstr ":keyword:`await` ``x``"
+msgstr ":keyword:`await x <await>`"
 
 #: 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 <not>`"
-msgstr ":keyword:`not` ``x``"
+msgstr ":keyword:`not x <not>`"
 
 #: reference/expressions.rst:1925
 msgid "Boolean NOT"

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