diff --git a/library/decimal.po b/library/decimal.po
index 0fd2c036..86ebec05 100644
--- a/library/decimal.po
+++ b/library/decimal.po
@@ -6,14 +6,14 @@ msgstr ""
 "Project-Id-Version: Python 3\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2023-04-14 13:19+0200\n"
-"PO-Revision-Date: 2022-10-18 15:52+0200\n"
-"Last-Translator: \n"
+"PO-Revision-Date: 2023-05-20 20:21+0200\n"
+"Last-Translator: Christophe Nanteuil <christophe.nanteuil@gmail.com>\n"
 "Language-Team: FRENCH <traductions@lists.afpy.org>\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 2.4.1\n"
+"X-Generator: Poedit 3.2.2\n"
 
 #: library/decimal.rst:2
 msgid ":mod:`decimal` --- Decimal fixed point and floating point arithmetic"
@@ -24,7 +24,6 @@ msgid "**Source code:** :source:`Lib/decimal.py`"
 msgstr "**Code source :** :source:`Lib/decimal.py`"
 
 #: library/decimal.rst:33
-#, fuzzy
 msgid ""
 "The :mod:`decimal` module provides support for fast correctly rounded "
 "decimal floating point arithmetic. It offers several advantages over the :"
@@ -32,7 +31,7 @@ msgid ""
 msgstr ""
 "Le module :mod:`decimal` fournit une arithmétique en virgule flottante "
 "rapide et produisant des arrondis mathématiquement corrects. Il possède "
-"plusieurs avantages en comparaison au type :class:`float` :"
+"plusieurs avantages par rapport au type :class:`float` :"
 
 #: library/decimal.rst:37
 msgid ""
@@ -45,11 +44,10 @@ msgstr ""
 "Le module ``decimal`` « est basé sur un modèle en virgule flottante conçu "
 "pour les humains, qui suit ce principe directeur : l'ordinateur doit fournir "
 "un modèle de calcul qui fonctionne de la même manière que le calcul qu'on "
-"apprend à l'école » -- extrait (traduit) de la spécification de "
+"apprend à l'école » – extrait (traduit) de la spécification de "
 "l'arithmétique décimale."
 
 #: library/decimal.rst:42
-#, fuzzy
 msgid ""
 "Decimal numbers can be represented exactly.  In contrast, numbers like "
 "``1.1`` and ``2.2`` do not have exact representations in binary floating "
@@ -57,14 +55,12 @@ msgid ""
 "``3.3000000000000003`` as it does with binary floating point."
 msgstr ""
 "Les nombres décimaux peuvent être représentés exactement en base décimale "
-"flottante. En revanche, des nombres tels que :const:`1.1` ou :const:`1.2` "
-"n'ont pas de représentation exacte en base binaire flottante. L'utilisateur "
-"final ne s'attend typiquement pas à obtenir :const:`3.3000000000000003` "
-"lorsqu'il saisit ``1.1 + 2.2``, ce qui se passe en arithmétique binaire à "
-"virgule flottante."
+"flottante. En revanche, des nombres tels que ``1.1`` ou ``1.2`` n'ont pas de "
+"représentation exacte en base binaire flottante. L'utilisateur final ne "
+"s'attend typiquement pas à obtenir ``3.3000000000000003`` lorsqu'il saisit "
+"``1.1 + 2.2``, ce qui se passe en arithmétique binaire à virgule flottante."
 
 #: library/decimal.rst:47
-#, fuzzy
 msgid ""
 "The exactness carries over into arithmetic.  In decimal floating point, "
 "``0.1 + 0.1 + 0.1 - 0.3`` is exactly equal to zero.  In binary floating "
@@ -75,14 +71,13 @@ msgid ""
 msgstr ""
 "Ces inexactitudes ont des conséquences en arithmétique. En base décimale à "
 "virgule flottante, ``0.1 + 0.1 + 0.1 - 0.3`` est exactement égal à zéro. En "
-"virgule flottante binaire, l'ordinateur l'évalue à :const:"
-"`5.5511151231257827e-017`. Bien que très proche de zéro, cette différence "
+"virgule flottante binaire, l'ordinateur l'évalue à "
+"``5.5511151231257827e-017``. Bien que très proche de zéro, cette différence "
 "induit des erreurs lors des tests d'égalité, erreurs qui peuvent "
 "s'accumuler. Pour ces raisons ``decimal`` est le module utilisé pour des "
 "applications comptables ayant des contraintes strictes de fiabilité."
 
 #: library/decimal.rst:54
-#, fuzzy
 msgid ""
 "The decimal module incorporates a notion of significant places so that "
 "``1.30 + 1.20`` is ``2.50``.  The trailing zero is kept to indicate "
@@ -91,13 +86,13 @@ msgid ""
 "multiplicands.  For instance, ``1.3 * 1.2`` gives ``1.56`` while ``1.30 * "
 "1.20`` gives ``1.5600``."
 msgstr ""
-"Le module ``decimal`` incorpore la notion de chiffres significatifs, tels "
-"que ``1.30 + 1.20`` est égal à :const:`2.50`. Le dernier zéro n'est conservé "
-"que pour respecter le nombre de chiffres significatifs. C'est également "
-"l'affichage préféré pour représenter des sommes d'argent. Pour la "
-"multiplication, l'approche « scolaire » utilise tout les chiffres présents "
-"dans les facteurs. Par exemple, ``1.3 * 1.2`` donnerait :const:`1.56` tandis "
-"que ``1.30 * 1.20`` donnerait :const:`1.5600`."
+"Le module ``decimal`` incorpore la notion de chiffres significatifs, de "
+"façon à ce que ``1.30 + 1.20`` égale ``2.50``. Le dernier zéro est conservé "
+"pour respecter le nombre de chiffres significatifs. C'est l'affichage "
+"préféré pour représenter des sommes d'argent. Pour la multiplication, "
+"l'approche « scolaire » utilise tous les chiffres présents dans les "
+"facteurs. Par exemple, ``1.3 * 1.2`` donne ``1.56`` tandis que ``1.30 * "
+"1.20`` donne ``1.5600``."
 
 #: library/decimal.rst:61
 msgid ""
@@ -123,7 +118,7 @@ msgstr ""
 "selon des standards publiés. Alors que le type ``float`` n'expose qu'une "
 "faible portion de ses capacités, le module ``decimal`` expose tous les "
 "composants nécessaires du standard. Lorsque nécessaire, le développeur a un "
-"contrôle total de la gestion de signal et de l'arrondi. Cela inclut la "
+"contrôle total de la gestion des signaux et de l'arrondi. Cela inclut la "
 "possibilité de forcer une arithmétique exacte en utilisant des exceptions "
 "pour bloquer toute opération inexacte."
 
@@ -136,7 +131,7 @@ msgid ""
 msgstr ""
 "Le module ``decimal`` a été conçu pour gérer « sans préjugé, à la fois une "
 "arithmétique décimale non-arrondie (aussi appelée arithmétique en virgule "
-"fixe) et à la fois une arithmétique en virgule flottante. » (extrait traduit "
+"fixe) et à la fois une arithmétique en virgule flottante » (extrait traduit "
 "de la spécification de l'arithmétique décimale)."
 
 #: library/decimal.rst:85
@@ -148,19 +143,18 @@ msgstr ""
 "contexte arithmétique et les signaux."
 
 #: library/decimal.rst:88
-#, fuzzy
 msgid ""
 "A decimal number is immutable.  It has a sign, coefficient digits, and an "
 "exponent.  To preserve significance, the coefficient digits do not truncate "
 "trailing zeros.  Decimals also include special values such as ``Infinity``, "
-"``-Infinity``, and ``NaN``.  The standard also differentiates ``-0`` from "
-"``+0``."
+"``-Infinity``, and ``NaN``.  The standard also differentiates ``-0`` from ``"
+"+0``."
 msgstr ""
-"Un ``Decimal`` est immuable. Il a un signe, un coefficient, et un exposant. "
+"Un ``Decimal`` est immuable. Il a un signe, un coefficient et un exposant. "
 "Pour préserver le nombre de chiffres significatifs, les zéros en fin de "
 "chaîne ne sont pas tronqués. Les décimaux incluent aussi des valeurs "
-"spéciales telles que :const:`Infinity`, :const:`-Infinity`, et :const:`NaN`. "
-"Le standard fait également la différence entre :const:`-0` et :const:`+0`."
+"spéciales telles que ``Infinity``, ``-Infinity`` et ``NaN``. Le standard "
+"fait également la différence entre ``-0`` et ``+0``."
 
 #: library/decimal.rst:94
 msgid ""
@@ -177,7 +171,7 @@ msgstr ""
 "lors d'opérations illégales) sont traités comme des exceptions Python. Les "
 "options d'arrondi incluent :const:`ROUND_CEILING`, :const:`ROUND_DOWN`, :"
 "const:`ROUND_FLOOR`, :const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :"
-"const:`ROUND_HALF_UP`, :const:`ROUND_UP`, et :const:`ROUND_05UP`."
+"const:`ROUND_HALF_UP`, :const:`ROUND_UP` et :const:`ROUND_05UP`."
 
 #: library/decimal.rst:101
 msgid ""
@@ -204,20 +198,21 @@ msgid ""
 "one, an exception is raised.  Flags are sticky, so the user needs to reset "
 "them before monitoring a calculation."
 msgstr ""
-"Chaque signal est configurable indépendamment. Quand une opération illégale "
-"survient, le signal est mis à ``1``, puis s'il est configuré pour, une "
-"exception est levée. La mise à ``1`` est persistante, l'utilisateur doit "
-"donc les remettre à zéro avant de commencer un calcul qu'il souhaite "
-"surveiller."
+"Chaque signal est configurable indépendamment, à travers un drapeau (ou "
+"option) et un activateur de déroutement. Quand une opération illégale "
+"survient, le drapeau du signal est mis à ``1`` puis, si l'activateur est "
+"configuré, une exception est levée. La mise à ``1`` du drapeau est "
+"persistante, l'utilisateur doit donc remettre les drapeaux à zéro avant de "
+"commencer un calcul qu'il souhaite surveiller."
 
 #: library/decimal.rst:116
-#, fuzzy
 msgid ""
 "IBM's General Decimal Arithmetic Specification, `The General Decimal "
 "Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."
 msgstr ""
-"La spécification d'IBM sur l'arithmétique décimale : `The General Decimal "
-"Arithmetic Specification <http://speleotrove.com/decimal/decarith.html>`_."
+"Spécification d'IBM sur l'arithmétique décimale : `The General Decimal "
+"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_ "
+"(article en anglais)."
 
 #: library/decimal.rst:125
 msgid "Quick-start Tutorial"
@@ -230,11 +225,10 @@ msgid ""
 "values for precision, rounding, or enabled traps::"
 msgstr ""
 "Commençons par importer le module, regarder le contexte actuel avec :func:"
-"`getcontext`, et si nécessaire configurer la précision, l'arrondi, et la "
+"`getcontext` et, si nécessaire, configurer la précision, l'arrondi et la "
 "gestion des signaux ::"
 
 #: library/decimal.rst:139
-#, fuzzy
 msgid ""
 "Decimal instances can be constructed from integers, strings, floats, or "
 "tuples. Construction from an integer or a float performs an exact conversion "
@@ -242,12 +236,12 @@ msgid ""
 "values such as ``NaN`` which stands for \"Not a number\", positive and "
 "negative ``Infinity``, and ``-0``::"
 msgstr ""
-"Les instances de ``Decimal`` peuvent être construites avec des ``int``, des "
-"``str``, des ``floats`` ou des ``tuples``. La construction depuis un entier "
-"ou un ``float`` effectue la conversion exacte de cet entier ou de ce "
-"``float``. Les nombres décimaux incluent des valeurs spéciales telles que :"
-"const:`NaN` qui signifie en anglais « *Not a number* », en français « pas un "
-"nombre », des :const:`Infinity` positifs ou négatifs et :const:`-0` ::"
+"Les instances de ``Decimal`` peuvent être construites avec des entiers, des "
+"chaînes de caractères, des ``floats`` ou des *n*-uplets. La construction "
+"depuis un entier ou un ``float`` effectue la conversion exacte de cet entier "
+"ou de ce ``float``. Les nombres décimaux incluent des valeurs spéciales "
+"telles que ``NaN`` qui signifie en anglais « *Not a number* », en français "
+"« pas un nombre », des ``Infinity`` positifs ou négatifs et ``-0`` ::"
 
 #: library/decimal.rst:163
 msgid ""
@@ -255,9 +249,9 @@ msgid ""
 "decimals and floats in constructors or ordering comparisons raises an "
 "exception::"
 msgstr ""
-"Si un signal :exc:`FloatOperation` est détecté, un mélange accidentel "
-"d'objets ``Decimal`` et de ``float`` dans les constructeurs ou des "
-"opérations de comparaisons, une exception est levée ::"
+"Si le signal :exc:`FloatOperation` est activé pour déroutement, un mélange "
+"accidentel d'objets ``Decimal`` et de ``float`` dans les constructeurs ou "
+"des opérations de comparaison lève une exception ::"
 
 #: library/decimal.rst:182
 msgid ""
@@ -283,7 +277,7 @@ msgid ""
 "decimal floating point flying circus:"
 msgstr ""
 "Les objets ``Decimal`` interagissent très bien avec le reste de Python. "
-"Voici quelques exemple d'opérations avec des décimaux :"
+"Voici quelques exemples d'opérations avec des décimaux :"
 
 #: library/decimal.rst:241
 msgid "And some mathematical functions are also available to Decimal:"
@@ -292,15 +286,15 @@ msgstr ""
 "instances de ``Decimal`` :"
 
 #: library/decimal.rst:253
-#, fuzzy
 msgid ""
 "The :meth:`~Decimal.quantize` method rounds a number to a fixed exponent.  "
 "This method is useful for monetary applications that often round results to "
 "a fixed number of places:"
 msgstr ""
-"La méthode :meth:`quantize` arrondit un nombre à un exposant fixe. Cette "
-"méthode est utile pour des applications monétaires qui arrondissent souvent "
-"un résultat à un nombre de chiffres significatifs exact :"
+"La méthode :meth:`~Decimal.quantize` arrondit un nombre à un exposant "
+"déterminé. Cette méthode est utile pour des applications monétaires qui "
+"arrondissent souvent un résultat à un nombre déterminé de chiffres après la "
+"virgule :"
 
 #: library/decimal.rst:262
 msgid ""
@@ -330,12 +324,11 @@ msgid ""
 "many of the traps are enabled:"
 msgstr ""
 "En accord avec le standard, le module :mod:`decimal` fournit des objets "
-"Context standards, :const:`BasicContext` et :const:`ExtendedContext`. Le "
-"premier est particulièrement utile pour le débogage car beaucoup des pièges "
-"sont activés dans cet objet :"
+"*Context* standards, :const:`BasicContext` et :const:`ExtendedContext`. Le "
+"premier est particulièrement utile pour le débogage car beaucoup des signaux "
+"ont leur déroutement activé :"
 
 #: library/decimal.rst:299
-#, fuzzy
 msgid ""
 "Contexts also have signal flags for monitoring exceptional conditions "
 "encountered during computations.  The flags remain set until explicitly "
@@ -346,28 +339,26 @@ msgstr ""
 "illégales lors des calculs. Ces options restent activées jusqu'à ce qu'elles "
 "soit remises à zéro de manière explicite. Il convient donc de remettre à "
 "zéro ces options avant chaque inspection de chaque calcul, avec la méthode :"
-"meth:`clear_flags`. ::"
+"meth:`~Context.clear_flags`. ::"
 
 #: library/decimal.rst:312
-#, fuzzy
 msgid ""
 "The *flags* entry shows that the rational approximation to pi was rounded "
 "(digits beyond the context precision were thrown away) and that the result "
 "is inexact (some of the discarded digits were non-zero)."
 msgstr ""
-"Les options montrent que l'approximation de :const:`Pi` par une fraction a "
-"été arrondie (les chiffres au delà de la précision spécifiée par l'objet "
-"Context ont été tronqués) et que le résultat est différent (certains des "
+"Les options montrent que l'approximation de π par une fraction a été "
+"arrondie (les chiffres au-delà de la précision spécifiée par l'objet "
+"*Context* ont été tronqués) et que le résultat est différent (certains des "
 "chiffres tronqués étaient différents de zéro)."
 
 #: library/decimal.rst:316
-#, fuzzy
 msgid ""
 "Individual traps are set using the dictionary in the :attr:`~Context.traps` "
 "attribute of a context:"
 msgstr ""
-"L'activation des pièges se fait en utilisant un dictionnaire dans "
-"l'attribut :attr:`traps` de l'objet Context :"
+"L'activation du déroutement se fait en utilisant un dictionnaire dans "
+"l'attribut :attr:`~Context.traps` du contexte :"
 
 #: library/decimal.rst:331
 msgid ""
@@ -379,18 +370,18 @@ msgid ""
 msgstr ""
 "La plupart des applications n'ajustent l'objet ``Context`` qu'une seule "
 "fois, au démarrage. Et, dans beaucoup d'applications, les données sont "
-"convertie une fois pour toutes en :class:`Decimal`. Une fois le ``Context`` "
-"initialisé, et les objets ``Decimal`` créés, l'essentiel du programme "
-"manipule la donnée de la même manière qu'avec les autres types numériques "
+"converties une fois pour toutes en :class:`Decimal`. Une fois le ``Context`` "
+"initialisé et les objets ``Decimal`` créés, la majeure partie du programme "
+"manipule les données de la même manière qu'avec d'autres types numériques "
 "Python."
 
 #: library/decimal.rst:343
 msgid "Decimal objects"
-msgstr "Les objets Decimal"
+msgstr "Les objets *Decimal*"
 
 #: library/decimal.rst:348
 msgid "Construct a new :class:`Decimal` object based from *value*."
-msgstr "Construire un nouvel objet :class:`Decimal` à partir de *value*."
+msgstr "Construit un nouvel objet :class:`Decimal` à partir de *value*."
 
 #: library/decimal.rst:350
 msgid ""
@@ -400,11 +391,11 @@ msgid ""
 "after leading and trailing whitespace characters, as well as underscores "
 "throughout, are removed::"
 msgstr ""
-"*value* peut être un entier, une chaîne de caractères, un *n*-uplet, :class:"
-"`float`, ou une autre instance de :class:`Decimal`. Si *value* n'est pas "
-"fourni, le constructeur renvoie ``Decimal('0')``. Si *value* est une chaîne "
-"de caractère, elle doit correspondre à la syntaxe décimale en dehors des "
-"espaces de début et de fin, ou des tirets bas, qui sont enlevés ::"
+"*value* peut être un entier, une chaîne de caractères, un *n*-uplet, un :"
+"class:`float` ou une autre instance de :class:`Decimal`. Si *value* n'est "
+"pas fourni, le constructeur renvoie ``Decimal('0')``. Si *value* est une "
+"chaîne de caractères, elle doit correspondre à la syntaxe décimale en dehors "
+"des espaces de début et de fin, ou des tirets bas, qui sont enlevés ::"
 
 #: library/decimal.rst:366
 msgid ""
@@ -413,23 +404,22 @@ msgid ""
 "example, Arabic-Indic and Devanāgarī digits) along with the fullwidth digits "
 "``'\\uff10'`` through ``'\\uff19'``."
 msgstr ""
-"Les chiffres codés en Unicode sont aussi autorisés, là ou ``digit`` "
-"apparaît. Cela inclut des chiffres décimaux venant d'autres alphabets (par "
-"exemple les chiffres indo-arabes ou Devanagari) ainsi que les chiffres de "
-"pleine largeur ``'\\uff10'`` jusqu'à ``'\\uff19'``."
+"Les chiffres codés en Unicode sont aussi autorisés, dans les emplacements "
+"``digit`` ci-dessus. Cela inclut des chiffres décimaux venant d'autres "
+"alphabets (par exemple les chiffres indo-arabes ou Devanagari) ainsi que les "
+"chiffres de pleine largeur ``'\\uff10'`` jusqu'à ``'\\uff19'``."
 
 #: library/decimal.rst:371
-#, fuzzy
 msgid ""
 "If *value* is a :class:`tuple`, it should have three components, a sign "
 "(``0`` for positive or ``1`` for negative), a :class:`tuple` of digits, and "
 "an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), -3))`` returns "
 "``Decimal('1.414')``."
 msgstr ""
-"Si *value* est un :class:`tuple`, il doit avoir 3 éléments, le signe (:const:"
-"`0` pour positif ou :const:`1` pour négatif), un :class:`tuple` de chiffres, "
-"et un entier représentant l'exposant. Par exemple, ``Decimal((0, (1, 4, 1, "
-"4), -3))`` construit l'objet ``Decimal('1.414')``."
+"Si *value* est un :class:`n-uplet <tuple>`, il doit avoir trois éléments, le "
+"signe (``0`` pour positif ou ``1`` pour négatif), un :class:`n-uplet "
+"<tuple>` de chiffres et un entier représentant l'exposant. Par exemple, "
+"``Decimal((0, (1, 4, 1, 4), -3))`` construit l'objet ``Decimal('1.414')``."
 
 #: library/decimal.rst:376
 msgid ""
@@ -452,13 +442,12 @@ msgid ""
 "``Decimal('3.00000')`` records all five zeros even if the context precision "
 "is only three."
 msgstr ""
-"La précision spécifiée dans Context n'affecte pas le nombre de chiffres "
+"La précision spécifiée dans le contexte n'affecte pas le nombre de chiffres "
 "stockés. Cette valeur est déterminée exclusivement par le nombre de chiffres "
 "dans *value*. Par exemple, ``Decimal('3.00000')`` enregistre les 5 zéros "
 "même si la précision du contexte est de 3."
 
 #: library/decimal.rst:387
-#, fuzzy
 msgid ""
 "The purpose of the *context* argument is determining what to do if *value* "
 "is a malformed string.  If the context traps :const:`InvalidOperation`, an "
@@ -466,35 +455,38 @@ msgid ""
 "the value of ``NaN``."
 msgstr ""
 "L'objectif de l'argument *context* est de déterminer ce que Python doit "
-"faire si *value* est une chaîne avec un mauvais format. Si l'option :const:"
-"`InvalidOperation` est activée, une exception est levée, sinon le "
-"constructeur renvoie un objet ``Decimal`` avec la valeur :const:`NaN`."
+"faire si *value* est une chaîne avec un mauvais format. Si le déroutement "
+"est activé pour :const:`InvalidOperation`, une exception est levée, sinon le "
+"constructeur renvoie un objet ``Decimal`` de valeur ``NaN``."
 
 #: library/decimal.rst:392
 msgid "Once constructed, :class:`Decimal` objects are immutable."
-msgstr "Une fois construit, les objets :class:`Decimal` sont immuables."
+msgstr "Une fois construit, un objet :class:`Decimal` est immuable."
 
+# suit un :
 #: library/decimal.rst:394
 msgid ""
 "The argument to the constructor is now permitted to be a :class:`float` "
 "instance."
 msgstr ""
-"L'argument du constructeur peut désormais être un objet :class:`float`."
+"l'argument du constructeur peut désormais être un objet :class:`float`."
 
+# suit un :
 #: library/decimal.rst:398
 msgid ""
 ":class:`float` arguments raise an exception if the :exc:`FloatOperation` "
 "trap is set. By default the trap is off."
 msgstr ""
-"Un argument :class:`float` lève une exception si l'option :exc:"
-"`FloatOperation` est activé. Par défaut l'option ne l'est pas."
+"un argument :class:`float` lève une exception si le déroutement est activé "
+"pour :exc:`FloatOperation`. Par défaut le déroutement n'est pas activé."
 
+# suit un :
 #: library/decimal.rst:402
 msgid ""
 "Underscores are allowed for grouping, as with integral and floating-point "
 "literals in code."
 msgstr ""
-"Les tirets bas sont autorisés pour regrouper, tout comme pour l'arithmétique "
+"les tirets bas sont autorisés pour regrouper, tout comme pour l'arithmétique "
 "en virgule fixe et flottante."
 
 #: library/decimal.rst:406
@@ -511,7 +503,7 @@ msgstr ""
 "opérations mathématiques et méthodes sont conservées. De même les objets "
 "``Decimal`` peuvent être copiés, sérialisés via le module ``pickle``, "
 "affichés, utilisés comme clé de dictionnaire, éléments d'ensembles, "
-"comparés, classés, et convertis vers un autre type (tel que :class:`float` "
+"comparés, classés et convertis vers un autre type (tel que :class:`float` "
 "ou :class:`int`)."
 
 #: library/decimal.rst:413
@@ -524,7 +516,7 @@ msgstr ""
 "Il existe quelques différences mineures entre l'arithmétique entre les "
 "objets décimaux et l'arithmétique avec les entiers et les ``float``. Quand "
 "l'opérateur modulo ``%`` est appliqué sur des objets décimaux, le signe du "
-"résultat est le signe du *dividend* plutôt que le signe du diviseur ::"
+"résultat est le signe du *dividende* plutôt que le signe du diviseur ::"
 
 #: library/decimal.rst:423
 msgid ""
@@ -532,9 +524,9 @@ msgid ""
 "integer part of the true quotient (truncating towards zero) rather than its "
 "floor, so as to preserve the usual identity ``x == (x // y) * y + x % y``::"
 msgstr ""
-"L'opérateur division entière, ``//`` se comporte de la même manière, "
-"retournant la partie entière du quotient, plutôt que son arrondi, de manière "
-"à préserver l'identité d'Euclide ``x == (x // y) * y + x % y`` ::"
+"L'opérateur division entière (``//``) se comporte de la même manière, "
+"renvoyant la partie entière du quotient plutôt que son arrondi, de manière à "
+"préserver l'identité d'Euclide ``x == (x // y) * y + x % y`` ::"
 
 #: library/decimal.rst:432
 msgid ""
@@ -542,7 +534,7 @@ msgid ""
 "integer`` operations (respectively) as described in the specification."
 msgstr ""
 "Les opérateurs ``//`` et ``%`` implémentent la division entière et le reste "
-"(ou modulo), respectivement, tel que décrit dans la spécification."
+"(ou modulo), respectivement, tels que décrits dans la spécification."
 
 #: library/decimal.rst:436
 msgid ""
@@ -556,25 +548,28 @@ msgid ""
 msgstr ""
 "Les objets ``Decimal`` ne peuvent généralement pas être combinés avec des "
 "``float`` ou des objets :class:`fractions.Fraction` lors d'opérations "
-"arithmétiques : tout addition entre un :class:`Decimal` avec un :class:"
+"arithmétiques : toute addition entre un :class:`Decimal` et un :class:"
 "`float`, par exemple, lève une exception :exc:`TypeError`. Cependant, il est "
 "possible d'utiliser les opérateurs de comparaison entre instances de :class:"
-"`Decimal` avec les autres types numériques. Cela évite d'avoir des résultats "
+"`Decimal` et les autres types numériques. Cela évite d'avoir des résultats "
 "absurdes lors des tests d'égalité entre différents types."
 
+# suit un :
 #: library/decimal.rst:444
 msgid ""
 "Mixed-type comparisons between :class:`Decimal` instances and other numeric "
 "types are now fully supported."
 msgstr ""
-"Les comparaisons inter-types entre :class:`Decimal` et les autres types "
-"numériques sont désormais intégralement gérés."
+"les comparaisons inter-types entre :class:`Decimal` et les autres types "
+"numériques sont désormais intégralement gérées."
 
 #: library/decimal.rst:448
 msgid ""
 "In addition to the standard numeric properties, decimal floating point "
 "objects also have a number of specialized methods:"
 msgstr ""
+"En plus des propriétés numériques standard, les objets décimaux à virgule "
+"flottante ont également un certain nombre de méthodes spécialisées :"
 
 #: library/decimal.rst:454
 msgid ""
@@ -583,6 +578,10 @@ msgid ""
 "returns seven.  Used for determining the position of the most significant "
 "digit with respect to the decimal point."
 msgstr ""
+"Renvoie l'exposant ajusté après avoir décalé les chiffres les plus à droite "
+"du coefficient jusqu'à ce qu'il ne reste que le premier chiffre : "
+"``Decimal('321e+5').adjusted()`` renvoie sept. Utilisée pour déterminer la "
+"position du chiffre le plus significatif par rapport à la virgule."
 
 #: library/decimal.rst:461
 msgid ""
@@ -590,6 +589,9 @@ msgid ""
 "`Decimal` instance as a fraction, in lowest terms and with a positive "
 "denominator::"
 msgstr ""
+"Renvoie un couple d'entiers ``(n, d)`` qui représentent l'instance :class:"
+"`Decimal` donnée sous la forme d'une fraction, avec les termes les plus "
+"petits possibles et avec un dénominateur positif ::"
 
 #: library/decimal.rst:468
 msgid ""
@@ -597,13 +599,15 @@ msgid ""
 "on NaNs."
 msgstr ""
 "La conversion est exacte. Lève une ``OverflowError`` sur l'infini et "
-"``ValueError`` sur les ``Nan``'s."
+"``ValueError`` sur les *Nan*."
 
 #: library/decimal.rst:475
 msgid ""
 "Return a :term:`named tuple` representation of the number: "
 "``DecimalTuple(sign, digits, exponent)``."
 msgstr ""
+"Renvoie une représentation sous la forme d'un :term:`n-uplet nommé <named "
+"tuple>` du nombre ``DecimalTuple(sign, digits, exposant)``."
 
 #: library/decimal.rst:481
 msgid ""
@@ -611,12 +615,18 @@ msgid ""
 "a :class:`Decimal` instance is always canonical, so this operation returns "
 "its argument unchanged."
 msgstr ""
+"Renvoie la forme canonique de l'argument. Actuellement, la forme d'une "
+"instance :class:`Decimal` est toujours canonique, donc cette opération "
+"renvoie son argument inchangé."
 
 #: library/decimal.rst:487
 msgid ""
 "Compare the values of two Decimal instances.  :meth:`compare` returns a "
 "Decimal instance, and if either operand is a NaN then the result is a NaN::"
 msgstr ""
+"Compare les valeurs de deux instances *Decimal*. :meth:`compare` renvoie une "
+"instance *Decimal* et, si l'un des opérandes est un *NaN*, alors le résultat "
+"est un *NaN* ::"
 
 #: library/decimal.rst:498
 msgid ""
@@ -624,6 +634,10 @@ msgid ""
 "NaNs signal.  That is, if neither operand is a signaling NaN then any quiet "
 "NaN operand is treated as though it were a signaling NaN."
 msgstr ""
+"Cette opération est identique à la méthode :meth:`compare`, sauf que tous "
+"les *NaN* activent un déroutement. Autrement dit, si aucun des opérandes "
+"n'est un *NaN* de signalisation, alors tout opérande *NaN* silencieux est "
+"traité comme s'il s'agissait d'un *NaN* de signalisation."
 
 #: library/decimal.rst:504
 msgid ""
@@ -633,6 +647,11 @@ msgid ""
 "instances with the same numeric value but different representations compare "
 "unequal in this ordering:"
 msgstr ""
+"Compare deux opérandes en utilisant leur représentation abstraite plutôt que "
+"leur valeur numérique. Similaire à la méthode :meth:`compare`, mais le "
+"résultat donne un ordre total sur les instances :class:`Decimal`. Deux "
+"instances de :class:`Decimal` avec la même valeur numérique mais des "
+"représentations différentes se comparent de manière inégale dans cet ordre :"
 
 #: library/decimal.rst:513
 msgid ""
@@ -643,6 +662,12 @@ msgid ""
 "in the total order than the second operand.  See the specification for "
 "details of the total order."
 msgstr ""
+"Les *NaN* silencieux et de signalisation sont également inclus dans l'ordre "
+"total. Le résultat de cette fonction est ``Decimal('0')`` si les deux "
+"opérandes ont la même représentation, ``Decimal('-1')`` si le premier "
+"opérande est inférieur au second, et ``Decimal('1')`` si le premier opérande "
+"est supérieur au deuxième opérande. Voir les spécifications pour les détails "
+"de l'ordre total."
 
 #: library/decimal.rst:531 library/decimal.rst:835
 msgid ""
@@ -650,6 +675,10 @@ msgid ""
 "and no rounding is performed.  As an exception, the C version may raise "
 "InvalidOperation if the second operand cannot be converted exactly."
 msgstr ""
+"Cette opération ne dépend pas du contexte et est silencieuse : aucun "
+"indicateur n'est modifié et aucun arrondi n'est effectué. "
+"Exceptionnellement, la version C peut lever une *InvalidOperation* si le "
+"deuxième opérande ne peut pas être converti exactement."
 
 #: library/decimal.rst:526
 msgid ""
@@ -658,30 +687,44 @@ msgid ""
 "``x.compare_total_mag(y)`` is equivalent to ``x.copy_abs().compare_total(y."
 "copy_abs())``."
 msgstr ""
+"Compare deux opérandes en utilisant leur représentation abstraite plutôt que "
+"leur valeur comme dans :meth:`compare_total`, mais en ignorant le signe de "
+"chaque opérande. ``x.compare_total_mag(y)`` est équivalent à ``x.copy_abs()."
+"compare_total(y.copy_abs())``."
 
 #: library/decimal.rst:537
 msgid ""
 "Just returns self, this method is only to comply with the Decimal "
 "Specification."
 msgstr ""
+"Ne fait que renvoyer self ; cette méthode existe uniquement pour se "
+"conformer à la spécification."
 
 #: library/decimal.rst:542
 msgid ""
 "Return the absolute value of the argument.  This operation is unaffected by "
 "the context and is quiet: no flags are changed and no rounding is performed."
 msgstr ""
+"Renvoie la valeur absolue de l'argument. Cette opération ne dépend pas du "
+"contexte et est silencieuse : aucun drapeau n'est modifié et aucun arrondi "
+"n'est effectué."
 
 #: library/decimal.rst:548
 msgid ""
 "Return the negation of the argument.  This operation is unaffected by the "
 "context and is quiet: no flags are changed and no rounding is performed."
 msgstr ""
+"Renvoie la négation de l'argument. Cette opération ne dépend pas du contexte "
+"et est silencieuse : aucun drapeau n'est modifié et aucun arrondi n'est "
+"effectué."
 
 #: library/decimal.rst:553
 msgid ""
 "Return a copy of the first operand with the sign set to be the same as the "
 "sign of the second operand.  For example:"
 msgstr ""
+"Renvoie une copie du premier opérande mais avec le même signe que celui du "
+"deuxième opérande. Par exemple :"
 
 #: library/decimal.rst:565
 msgid ""
@@ -689,12 +732,17 @@ msgid ""
 "number.  The result is correctly rounded using the :const:`ROUND_HALF_EVEN` "
 "rounding mode."
 msgstr ""
+"Renvoie la valeur ``e**x`` (fonction exponentielle) du nombre donné. Le "
+"résultat est correctement arrondi en utilisant le mode d'arrondi :const:"
+"`ROUND_HALF_EVEN`."
 
 #: library/decimal.rst:576
 msgid ""
 "Alternative constructor that only accepts instances of :class:`float` or :"
 "class:`int`."
 msgstr ""
+"Constructeur alternatif qui n'accepte que les instances de :class:`float` "
+"ou :class:`int`."
 
 #: library/decimal.rst:579
 msgid ""
@@ -704,18 +752,29 @@ msgid ""
 "``0x1.999999999999ap-4``.  That equivalent value in decimal is "
 "``0.1000000000000000055511151231257827021181583404541015625``."
 msgstr ""
+"Remarquez que ``Decimal.from_float(0.1)`` est différent de "
+"``Decimal('0.1')``. Puisque 0.1 n'est pas exactement représentable en "
+"virgule flottante binaire, la valeur est stockée comme la valeur "
+"représentable la plus proche qui est ``0x1.999999999999ap-4``. La valeur "
+"équivalente en décimal est "
+"``0.1000000000000000055511151231257827021181583404541015625``."
 
+# suit un :
 #: library/decimal.rst:585
 msgid ""
 "From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed "
 "directly from a :class:`float`."
 msgstr ""
+"depuis Python 3.2, une instance :class:`Decimal` peut également être "
+"construite directement à partir d'un :class:`float`."
 
 #: library/decimal.rst:603
 msgid ""
 "Fused multiply-add.  Return self*other+third with no rounding of the "
 "intermediate product self*other."
 msgstr ""
+"Multiplier-ajouter fusionné. Renvoie ``self*other+third`` sans arrondir le "
+"produit intermédiaire ``self*other``."
 
 #: library/decimal.rst:611
 msgid ""
@@ -733,36 +792,39 @@ msgid ""
 "if the argument is an infinity or a NaN."
 msgstr ""
 "Renvoie :const:`True` si l'argument est un nombre fini et :const:`False` si "
-"l'argument est un infini ou NaN."
+"l'argument est un infini ou un *NaN*."
 
 #: library/decimal.rst:622
 msgid ""
 "Return :const:`True` if the argument is either positive or negative infinity "
 "and :const:`False` otherwise."
 msgstr ""
-"Renvoie :const:`True` si l'argument est un infini positif ou négatif et :"
-"const:`False` sinon."
+"Renvoie :const:`True` si l'argument est un infini positif ou négatif, :const:"
+"`False` sinon."
 
 #: library/decimal.rst:627
 msgid ""
 "Return :const:`True` if the argument is a (quiet or signaling) NaN and :"
 "const:`False` otherwise."
 msgstr ""
-"Renvoie :const:`True` si l'argument est un NaN (signalétique ou silencieux) "
-"et :const:`False` sinon."
+"Renvoie :const:`True` si l'argument est un *NaN* (signalétique ou "
+"silencieux), :const:`False` sinon."
 
 #: library/decimal.rst:632
 msgid ""
 "Return :const:`True` if the argument is a *normal* finite number.  Return :"
 "const:`False` if the argument is zero, subnormal, infinite or a NaN."
 msgstr ""
+"Renvoie :const:`True` si l'argument est un nombre fini *normal*. Renvoie :"
+"const:`False` si l'argument est zéro, infini, résultat d'un dépassement par "
+"valeur inférieure ou un *NaN*."
 
 #: library/decimal.rst:637
 msgid ""
 "Return :const:`True` if the argument is a quiet NaN, and :const:`False` "
 "otherwise."
 msgstr ""
-"Renvoie :const:`True` si l'argument est un NaN silencieux et :const:`False` "
+"Renvoie :const:`True` si l'argument est un *NaN* silencieux, :const:`False` "
 "sinon."
 
 #: library/decimal.rst:642
@@ -770,15 +832,15 @@ msgid ""
 "Return :const:`True` if the argument has a negative sign and :const:`False` "
 "otherwise.  Note that zeros and NaNs can both carry signs."
 msgstr ""
-"Renvoie :const:`True` si l'argument est négatif et :const:`False` sinon. "
-"Notez que les zéros et les NaNs peuvent être signés."
+"Renvoie :const:`True` si l'argument est négatif, :const:`False` sinon. "
+"Remarquez que les zéros et les *NaN* peuvent être signés."
 
 #: library/decimal.rst:647
 msgid ""
 "Return :const:`True` if the argument is a signaling NaN and :const:`False` "
 "otherwise."
 msgstr ""
-"Renvoie :const:`True` si l'argument est un NaN signalétique et :const:"
+"Renvoie :const:`True` si l'argument est un *NaN* signalétique, :const:"
 "`False` sinon."
 
 #: library/decimal.rst:652
@@ -786,14 +848,16 @@ msgid ""
 "Return :const:`True` if the argument is subnormal, and :const:`False` "
 "otherwise."
 msgstr ""
+"Renvoie :const:`True` si l'argument est le résultat d'un dépassement par "
+"valeur inférieure, :const:`False` sinon."
 
 #: library/decimal.rst:657
 msgid ""
 "Return :const:`True` if the argument is a (positive or negative) zero and :"
 "const:`False` otherwise."
 msgstr ""
-"Renvoie :const:`True` si l'argument est un zéro (positif ou négatif) et :"
-"const:`False` sinon."
+"Renvoie :const:`True` si l'argument est un zéro (positif ou négatif), :const:"
+"`False` sinon."
 
 #: library/decimal.rst:662
 msgid ""
@@ -818,6 +882,10 @@ msgid ""
 "Infinity')`` is returned and the :const:`DivisionByZero` flag is raised.  If "
 "the operand is an infinity then ``Decimal('Infinity')`` is returned."
 msgstr ""
+"Pour un nombre non nul, renvoie l'exposant ajusté de son opérande en tant "
+"qu'instance :class:`Decimal`. Si l'opérande est un zéro alors ``Decimal('-"
+"Infinity')`` est renvoyé et le drapeau :const:`DivisionByZero` est levé. Si "
+"l'opérande est un infini alors ``Decimal('Infinity')`` est renvoyé."
 
 #: library/decimal.rst:680
 msgid ""
@@ -825,12 +893,17 @@ msgid ""
 "operands* (see :ref:`logical_operands_label`).  The result is the digit-wise "
 "``and`` of the two operands."
 msgstr ""
+":meth:`logical_and` est une opération logique qui prend deux *opérandes "
+"logiques* (voir :ref:`logical_operands_label`). Le résultat est le *ET* des "
+"chiffres des deux opérandes."
 
 #: library/decimal.rst:686
 msgid ""
 ":meth:`logical_invert` is a logical operation.  The result is the digit-wise "
 "inversion of the operand."
 msgstr ""
+":meth:`logical_invert` est une opération logique. Le résultat est "
+"l'inversion de chacun des chiffres de l'opérande."
 
 #: library/decimal.rst:691
 msgid ""
@@ -838,6 +911,9 @@ msgid ""
 "(see :ref:`logical_operands_label`).  The result is the digit-wise ``or`` of "
 "the two operands."
 msgstr ""
+":meth:`logical_or` est une opération logique qui prend deux *opérandes "
+"logiques* (voir :ref:`logical_operands_label`). Le résultat est le *OU* des "
+"chiffres des deux opérandes."
 
 #: library/decimal.rst:697
 msgid ""
@@ -845,6 +921,9 @@ msgid ""
 "operands* (see :ref:`logical_operands_label`).  The result is the digit-wise "
 "exclusive or of the two operands."
 msgstr ""
+":meth:`logical_xor` est une opération logique qui prend deux *opérandes "
+"logiques* (voir :ref:`logical_operands_label`). Le résultat est le *OU "
+"EXCLUSIF* des chiffres des deux opérandes."
 
 #: library/decimal.rst:703
 msgid ""
@@ -852,12 +931,17 @@ msgid ""
 "before returning and that ``NaN`` values are either signaled or ignored "
 "(depending on the context and whether they are signaling or quiet)."
 msgstr ""
+"Comme ``max(self, other)`` sauf que la règle d'arrondi de *context* est "
+"appliquée avant le retour et que les valeurs ``NaN`` sont signalées ou "
+"ignorées (selon le contexte et si elles sont signalétiques ou silencieuses)."
 
 #: library/decimal.rst:710
 msgid ""
 "Similar to the :meth:`.max` method, but the comparison is done using the "
 "absolute values of the operands."
 msgstr ""
+"Semblable à la méthode :meth:`.max`, mais la comparaison est effectuée en "
+"utilisant les valeurs absolues des opérandes."
 
 #: library/decimal.rst:715
 msgid ""
@@ -865,12 +949,17 @@ msgid ""
 "before returning and that ``NaN`` values are either signaled or ignored "
 "(depending on the context and whether they are signaling or quiet)."
 msgstr ""
+"Comme ``min(self, other)`` sauf que la règle d'arrondi de *context* est "
+"appliquée avant le retour et que les valeurs ``NaN`` sont signalées ou "
+"ignorées (selon le contexte et si elles sont signalétiques ou silencieuses)."
 
 #: library/decimal.rst:722
 msgid ""
 "Similar to the :meth:`.min` method, but the comparison is done using the "
 "absolute values of the operands."
 msgstr ""
+"Semblable à la méthode :meth:`.min`, mais la comparaison est effectuée en "
+"utilisant les valeurs absolues des opérandes."
 
 #: library/decimal.rst:727
 msgid ""
@@ -878,6 +967,9 @@ msgid ""
 "current thread's context if no context is given) that is smaller than the "
 "given operand."
 msgstr ""
+"Renvoie le plus grand nombre représentable dans le *context* donné (ou dans "
+"le contexte du fil d'exécution actuel si aucun contexte n'est donné) qui est "
+"plus petit que l'opérande donné."
 
 #: library/decimal.rst:733
 msgid ""
@@ -885,6 +977,9 @@ msgid ""
 "current thread's context if no context is given) that is larger than the "
 "given operand."
 msgstr ""
+"Renvoie le plus petit nombre représentable dans le *context* donné (ou dans "
+"le contexte du fil d'exécution actuel si aucun contexte n'est donné) qui est "
+"supérieur à l'opérande donné."
 
 #: library/decimal.rst:739
 msgid ""
@@ -893,6 +988,10 @@ msgid ""
 "numerically equal, return a copy of the first operand with the sign set to "
 "be the same as the sign of the second operand."
 msgstr ""
+"Si les deux opérandes ne sont pas égaux, renvoie le nombre le plus proche du "
+"premier opérande dans la direction du deuxième opérande. Si les deux "
+"opérandes sont numériquement égaux, renvoie une copie du premier opérande "
+"avec le signe défini comme étant le même que le signe du second opérande."
 
 #: library/decimal.rst:746
 msgid ""
@@ -902,27 +1001,39 @@ msgid ""
 "example, ``Decimal('32.100')`` and ``Decimal('0.321000e+2')`` both normalize "
 "to the equivalent value ``Decimal('32.1')``."
 msgstr ""
+"Normalise le nombre en supprimant les zéros de fin les plus à droite et en "
+"convertissant tout résultat égal à ``Decimal('0')`` en ``Decimal('0e0')``. "
+"Utilisé pour produire des valeurs canoniques pour les attributs d'une classe "
+"d'équivalence. Par exemple, ``Decimal('32.100')`` et ``Decimal('0.321000e"
+"+2')`` sont tous deux normalisés à la valeur équivalente ``Decimal('32.1')``."
 
 #: library/decimal.rst:755
 msgid ""
 "Return a string describing the *class* of the operand.  The returned value "
 "is one of the following ten strings."
 msgstr ""
+"Renvoie une chaîne décrivant la *classe* de l'opérande. La valeur renvoyée "
+"est l'une des dix chaînes suivantes."
 
 # Élément d'une liste, d'où le ; final
 #: library/decimal.rst:758
 msgid "``\"-Infinity\"``, indicating that the operand is negative infinity."
 msgstr "``\"-Infinity\"``, indiquant que l'opérande est l'infini négatif ;"
 
+# Élément d'une liste, d'où le ; final
 #: library/decimal.rst:759
 msgid ""
 "``\"-Normal\"``, indicating that the operand is a negative normal number."
 msgstr ""
+"``\"-Normal\"``, indiquant que l'opérande est un nombre négatif normal ;"
 
+# Élément d'une liste, d'où le ; final
 #: library/decimal.rst:760
 msgid ""
 "``\"-Subnormal\"``, indicating that the operand is negative and subnormal."
 msgstr ""
+"``\"-Subnormal\"``, indiquant que l'opérande est négatif et qu'il est le "
+"résultat d'un dépassement par valeur inférieure ;"
 
 # Élément d'une liste, d'où le ; final
 #: library/decimal.rst:761
@@ -934,15 +1045,19 @@ msgstr "``\"-Zero\"``, indiquant que l'opérande est un zéro négatif ;"
 msgid "``\"+Zero\"``, indicating that the operand is a positive zero."
 msgstr "``\"+Zero\"``, indiquant que l'opérande est un zéro positif ;"
 
+# Élément d'une liste, d'où le ; final
 #: library/decimal.rst:763
 msgid ""
 "``\"+Subnormal\"``, indicating that the operand is positive and subnormal."
 msgstr ""
+"``\"+Subnormal\"``, indiquant que l'opérande est positif et qu'il est le "
+"résultat un dépassement par valeur inférieure ;"
 
 #: library/decimal.rst:764
 msgid ""
 "``\"+Normal\"``, indicating that the operand is a positive normal number."
 msgstr ""
+"``\"+Normal\"``, indiquant que l'opérande est un nombre positif normal ;"
 
 # Élément d'une liste, d'où le ; final
 #: library/decimal.rst:765
@@ -953,13 +1068,13 @@ msgstr "``\"+Infinity\"``, indiquant que l'opérande est l'infini positif ;"
 #: library/decimal.rst:766
 msgid "``\"NaN\"``, indicating that the operand is a quiet NaN (Not a Number)."
 msgstr ""
-"``\"NaN\"``, indiquant que l'opérande est un NaN (*Not a Number*, pas un "
+"``\"NaN\"``, indiquant que l'opérande est un *NaN* (*Not a Number*, pas un "
 "nombre) silencieux ;"
 
 #: library/decimal.rst:767
 msgid "``\"sNaN\"``, indicating that the operand is a signaling NaN."
 msgstr ""
-"``\"sNaN\"``, indiquant que l'opérande est un NaN (*Not a Number*, pas un "
+"``\"sNaN\"``, indiquant que l'opérande est un *NaN* (*Not a Number*, pas un "
 "nombre) signalétique."
 
 #: library/decimal.rst:771
@@ -967,6 +1082,8 @@ msgid ""
 "Return a value equal to the first operand after rounding and having the "
 "exponent of the second operand."
 msgstr ""
+"Renvoie une valeur égale au premier opérande après arrondi et ayant "
+"l'exposant du second opérande."
 
 #: library/decimal.rst:777
 msgid ""
@@ -975,12 +1092,20 @@ msgid ""
 "is signaled. This guarantees that, unless there is an error condition, the "
 "quantized exponent is always equal to that of the right-hand operand."
 msgstr ""
+"Contrairement aux autres opérations, si la longueur du coefficient après "
+"l'opération de quantification est supérieure à la précision, alors une :"
+"const:`InvalidOperation` est signalée. Ceci garantit que, sauf condition "
+"d'erreur, l'exposant quantifié est toujours égal à celui de l'opérande de "
+"droite."
 
 #: library/decimal.rst:783
 msgid ""
 "Also unlike other operations, quantize never signals Underflow, even if the "
 "result is subnormal and inexact."
 msgstr ""
+"Contrairement aux autres opérations, la quantification ne signale jamais de "
+"dépassement par valeur inférieure, même si le résultat est inférieur à la "
+"valeur minimale représentable et inexact."
 
 #: library/decimal.rst:786
 msgid ""
@@ -990,18 +1115,28 @@ msgid ""
 "if neither argument is given the rounding mode of the current thread's "
 "context is used."
 msgstr ""
+"Si l'exposant du deuxième opérande est supérieur à celui du premier, un "
+"arrondi peut être nécessaire. Dans ce cas, le mode d'arrondi est déterminé "
+"par l'argument ``rounding`` s'il est donné, sinon par l'argument ``context`` "
+"donné ; si aucun argument n'est donné, le mode d'arrondi du contexte du fil "
+"d'exécution courant est utilisé."
 
 #: library/decimal.rst:792
 msgid ""
 "An error is returned whenever the resulting exponent is greater than :attr:"
 "`~Context.Emax` or less than :meth:`~Context.Etiny`."
 msgstr ""
+"Une erreur est renvoyée chaque fois que l'exposant résultant est supérieur "
+"à :attr:`~Context.Emax` ou inférieur à :meth:`~Context.Etiny`."
 
 #: library/decimal.rst:797
 msgid ""
 "Return ``Decimal(10)``, the radix (base) in which the :class:`Decimal` class "
 "does all its arithmetic.  Included for compatibility with the specification."
 msgstr ""
+"Renvoie ``Decimal(10)``, la base (base) dans laquelle la classe :class:"
+"`Decimal` fait toute son arithmétique. Inclus pour la compatibilité avec la "
+"spécification."
 
 #: library/decimal.rst:803
 msgid ""
@@ -1011,10 +1146,16 @@ msgid ""
 "* other`` where ``n`` is the integer nearest to the exact value of ``self / "
 "other``, and if two integers are equally near then the even one is chosen."
 msgstr ""
+"Renvoie le reste de la division de *self* par *other*. La différence avec "
+"``self % other`` réside dans le signe du reste, qui est choisi de manière à "
+"minimiser sa valeur absolue. Plus précisément, la valeur de retour est "
+"``self - n * other`` où ``n`` est l'entier le plus proche de la valeur "
+"exacte de ``self / other`` et, si deux entiers sont également proches, alors "
+"l'entier pair est choisi."
 
 #: library/decimal.rst:810
 msgid "If the result is zero then its sign will be the sign of *self*."
-msgstr ""
+msgstr "Si le résultat est zéro, alors son signe est le signe de *self*."
 
 #: library/decimal.rst:821
 msgid ""
@@ -1027,12 +1168,21 @@ msgid ""
 "length precision if necessary.  The sign and exponent of the first operand "
 "are unchanged."
 msgstr ""
+"Renvoie le résultat de la rotation des chiffres du premier opérande d'une "
+"quantité spécifiée par le deuxième opérande. Le deuxième opérande doit être "
+"un entier compris dans la plage -précision à précision. La valeur absolue du "
+"deuxième opérande donne le nombre de rotations unitaires à faire. Si le "
+"deuxième opérande est positif alors la rotation se fait vers la gauche ; "
+"sinon la rotation se fait vers la droite. Le coefficient du premier opérande "
+"est complété à gauche avec des zéros à la précision de la longueur si "
+"nécessaire. Le signe et l'exposant du premier opérande sont inchangés."
 
 #: library/decimal.rst:832
 msgid ""
 "Test whether self and other have the same exponent or whether both are "
 "``NaN``."
 msgstr ""
+"Teste si *self* et *other* ont le même exposant ou si les deux sont ``NaN``."
 
 #: library/decimal.rst:841
 msgid ""
@@ -1040,6 +1190,9 @@ msgid ""
 "return the first operand multiplied by ``10**other``.  The second operand "
 "must be an integer."
 msgstr ""
+"Renvoie le premier opérande avec l'exposant ajusté par le second. De manière "
+"équivalente, renvoie le premier opérande multiplié par ``10**other``. Le "
+"deuxième opérande doit être entier."
 
 #: library/decimal.rst:847
 msgid ""
@@ -1051,15 +1204,25 @@ msgid ""
 "right.  Digits shifted into the coefficient are zeros.  The sign and "
 "exponent of the first operand are unchanged."
 msgstr ""
+"Renvoie le résultat du décalage des chiffres du premier opérande d'une "
+"quantité spécifiée par le deuxième opérande. Le deuxième opérande doit être "
+"un entier compris dans la plage -précision à précision. La valeur absolue du "
+"deuxième opérande donne le nombre de décalages unitaires à effectuer. Si le "
+"deuxième opérande est positif alors le décalage est vers la gauche ; sinon "
+"le décalage est vers la droite. Les chiffres insérés dans le nombre par le "
+"décalage sont des zéros. Le signe et l'exposant du premier opérande sont "
+"inchangés."
 
 #: library/decimal.rst:857
 msgid "Return the square root of the argument to full precision."
-msgstr ""
+msgstr "Renvoie la racine carrée de l'argument avec une précision maximale."
 
 #: library/decimal.rst:1457
 msgid ""
 "Convert to a string, using engineering notation if an exponent is needed."
 msgstr ""
+"Convertir en chaîne, en utilisant la notation ingénieur si un exposant est "
+"nécessaire."
 
 #: library/decimal.rst:1459
 msgid ""
@@ -1067,17 +1230,23 @@ msgid ""
 "leave up to 3 digits to the left of the decimal place and may require the "
 "addition of either one or two trailing zeros."
 msgstr ""
+"La notation ingénieur possède un exposant qui est un multiple de 3. Cela "
+"peut laisser jusqu'à 3 chiffres à gauche de la décimale et peut nécessiter "
+"l'ajout d'un ou de deux zéros à la fin."
 
 #: library/decimal.rst:868
 msgid ""
 "For example, this converts ``Decimal('123E+1')`` to ``Decimal('1.23E+3')``."
 msgstr ""
+"Par exemple, ``Decimal('123E+1')`` est converti en ``Decimal('1.23E+3')``."
 
 #: library/decimal.rst:872
 msgid ""
 "Identical to the :meth:`to_integral_value` method.  The ``to_integral`` name "
 "has been kept for compatibility with older versions."
 msgstr ""
+"Identique à la méthode :meth:`to_integral_value`. Le nom ``to_integral`` a "
+"été conservé pour la compatibilité avec les anciennes versions."
 
 #: library/decimal.rst:877
 msgid ""
@@ -1086,6 +1255,11 @@ msgid ""
 "``rounding`` parameter if given, else by the given ``context``.  If neither "
 "parameter is given then the rounding mode of the current context is used."
 msgstr ""
+"Arrondit à l'entier le plus proche, en signalant :const:`Inexact` ou :const:"
+"`Rounded` selon le cas si l'arrondi se produit. Le mode d'arrondi est "
+"déterminé par le paramètre ``rounding`` s'il est donné, sinon par le "
+"``context`` donné. Si aucun paramètre n'est donné, le mode d'arrondi du "
+"contexte courant est utilisé."
 
 #: library/decimal.rst:885
 msgid ""
@@ -1093,10 +1267,13 @@ msgid ""
 "`Rounded`.  If given, applies *rounding*; otherwise, uses the rounding "
 "method in either the supplied *context* or the current context."
 msgstr ""
+"Arrondit à l'entier le plus proche sans signaler :const:`Inexact` ou :const:"
+"`Rounded`. Si donné, applique *rounding* ; sinon, utilise la méthode "
+"d'arrondi dans le *context* fourni ou dans le contexte actuel."
 
 #: library/decimal.rst:893
 msgid "Logical operands"
-msgstr ""
+msgstr "Opérandes logiques"
 
 #: library/decimal.rst:895
 msgid ""
@@ -1106,10 +1283,15 @@ msgid ""
 "`Decimal` instance whose exponent and sign are both zero, and whose digits "
 "are all either ``0`` or ``1``."
 msgstr ""
+"Les méthodes :meth:`~Decimal.logical_and`, :meth:`~Decimal.logical_invert`, :"
+"meth:`~Decimal.logical_or` et :meth:`~Decimal.logical_xor` s'attendent à ce "
+"que leurs arguments soient des *opérandes logiques*. Un *opérande logique* "
+"est une instance :class:`Decimal` dont l'exposant et le signe sont tous les "
+"deux zéro et dont les chiffres sont tous ``0`` ou ``1``."
 
 #: library/decimal.rst:907
 msgid "Context objects"
-msgstr ""
+msgstr "Objets de contexte"
 
 #: library/decimal.rst:909
 msgid ""
@@ -1117,26 +1299,33 @@ msgid ""
 "set rules for rounding, determine which signals are treated as exceptions, "
 "and limit the range for exponents."
 msgstr ""
+"Les contextes sont des environnements pour les opérations arithmétiques. Ils "
+"régissent la précision, établissent des règles d'arrondi, déterminent quels "
+"signaux sont traités comme des exceptions et limitent la plage des exposants."
 
 #: library/decimal.rst:913
 msgid ""
 "Each thread has its own current context which is accessed or changed using "
 "the :func:`getcontext` and :func:`setcontext` functions:"
 msgstr ""
+"Chaque fil d'exécution a son propre contexte actuel qui est accessible ou "
+"modifié à l'aide des fonctions :func:`getcontext` et :func:`setcontext` :"
 
 #: library/decimal.rst:919
 msgid "Return the current context for the active thread."
-msgstr ""
+msgstr "Renvoie le contexte actuel du fil d'exécution courant."
 
 #: library/decimal.rst:924
 msgid "Set the current context for the active thread to *c*."
-msgstr ""
+msgstr "Définit le contexte du fil d'exécution courant à *c*."
 
 #: library/decimal.rst:926
 msgid ""
 "You can also use the :keyword:`with` statement and the :func:`localcontext` "
 "function to temporarily change the active context."
 msgstr ""
+"Vous pouvez également utiliser l'instruction :keyword:`with` et la fonction :"
+"func:`localcontext` pour modifier temporairement le contexte actif."
 
 #: library/decimal.rst:931
 msgid ""
@@ -1146,6 +1335,12 @@ msgid ""
 "specified, a copy of the current context is used.  The *kwargs* argument is "
 "used to set the attributes of the new context."
 msgstr ""
+"Renvoie un gestionnaire de contexte qui définira le contexte actuel du fil "
+"d'exécution actif sur une copie de *ctx* à l'entrée de l'instruction *with* "
+"et restaurera le contexte précédent lors de la sortie de l'instruction "
+"*with*. Si aucun contexte n'est spécifié, une copie du contexte actuel est "
+"utilisée. L'argument *kwargs* est utilisé pour définir les attributs du "
+"nouveau contexte."
 
 #: library/decimal.rst:937
 msgid ""
@@ -1153,10 +1348,13 @@ msgid ""
 "places, performs a calculation, and then automatically restores the previous "
 "context::"
 msgstr ""
+"Par exemple, le code suivant définit la précision décimale actuelle à 42 "
+"chiffres, effectue un calcul, puis restaure automatiquement le contexte "
+"précédent ::"
 
 #: library/decimal.rst:947
 msgid "Using keyword arguments, the code would be the following::"
-msgstr ""
+msgstr "En utilisant des arguments nommés, le code serait le suivant ::"
 
 #: library/decimal.rst:955
 msgid ""
@@ -1164,18 +1362,26 @@ msgid ""
 "`Context` doesn't support.  Raises either :exc:`TypeError` or :exc:"
 "`ValueError` if *kwargs* supplies an invalid value for an attribute."
 msgstr ""
+"Lève :exc:`TypeError` si *kwargs* fournit un attribut que :class:`Context` "
+"ne prend pas en charge. Lève soit :exc:`TypeError` ou :exc:`ValueError` si "
+"*kwargs* fournit une valeur invalide pour un attribut."
 
 #: library/decimal.rst:959
 msgid ""
 ":meth:`localcontext` now supports setting context attributes through the use "
 "of keyword arguments."
 msgstr ""
+":meth:`localcontext` prend désormais en charge la définition des attributs "
+"de contexte grâce à l'utilisation d'arguments nommés."
 
 #: library/decimal.rst:962
 msgid ""
 "New contexts can also be created using the :class:`Context` constructor "
 "described below. In addition, the module provides three pre-made contexts:"
 msgstr ""
+"De nouveaux contextes peuvent également être créés à l'aide du constructeur :"
+"class:`Context` décrit ci-dessous. De plus, le module fournit trois "
+"contextes prédéfinis :"
 
 #: library/decimal.rst:968
 msgid ""
@@ -1185,11 +1391,18 @@ msgid ""
 "exceptions) except :const:`Inexact`, :const:`Rounded`, and :const:"
 "`Subnormal`."
 msgstr ""
+"Il s'agit d'un contexte standard défini par la *General Decimal Arithmetic "
+"Specification*. La précision est fixée à neuf. L'arrondi est défini sur :"
+"const:`ROUND_HALF_UP`. Tous les drapeaux sont effacés. Tous les déroutements "
+"sont activés (ils lèvent des exceptions) sauf :const:`Inexact`, :const:"
+"`Rounded` et :const:`Subnormal`."
 
 #: library/decimal.rst:974
 msgid ""
 "Because many of the traps are enabled, this context is useful for debugging."
 msgstr ""
+"Étant donné que de nombreuses options de déroutement sont activées, ce "
+"contexte est utile pour le débogage."
 
 #: library/decimal.rst:979
 msgid ""
@@ -1198,6 +1411,10 @@ msgid ""
 "`ROUND_HALF_EVEN`.  All flags are cleared.  No traps are enabled (so that "
 "exceptions are not raised during computations)."
 msgstr ""
+"Il s'agit d'un contexte standard défini par la *General Decimal Arithmetic "
+"Specification*. La précision est fixée à neuf. L'arrondi est défini sur :"
+"const:`ROUND_HALF_EVEN`. Toutes les options de déroutement sont désactivées "
+"(afin que les exceptions ne soient pas levées pendant les calculs)."
 
 #: library/decimal.rst:984
 msgid ""
@@ -1206,6 +1423,11 @@ msgid ""
 "exceptions.  This allows an application to complete a run in the presence of "
 "conditions that would otherwise halt the program."
 msgstr ""
+"Comme les interruptions sont désactivées, ce contexte est utile pour les "
+"applications qui préfèrent avoir une valeur de résultat ``NaN`` ou "
+"``Infinity`` au lieu de lever des exceptions. Cela permet à une application "
+"de terminer une exécution en présence de conditions qui, autrement, "
+"arrêteraient le programme."
 
 #: library/decimal.rst:992
 msgid ""
@@ -1214,6 +1436,10 @@ msgid ""
 "changing the default for new contexts created by the :class:`Context` "
 "constructor."
 msgstr ""
+"Ce contexte est utilisé par le constructeur :class:`Context` comme prototype "
+"pour de nouveaux contextes. Changer un champ (par exemple la précision) a "
+"pour effet de changer la valeur par défaut pour les nouveaux contextes créés "
+"par le constructeur :class:`Context`."
 
 #: library/decimal.rst:996
 msgid ""
@@ -1222,12 +1448,21 @@ msgid ""
 "defaults.  Changing the fields after threads have started is not recommended "
 "as it would require thread synchronization to prevent race conditions."
 msgstr ""
+"Ce contexte est particulièrement utile dans les environnements à plusieurs "
+"fils d'exécution. La modification de l'un des champs avant le démarrage des "
+"fils a pour effet de définir des valeurs par défaut à l'échelle du système. "
+"La modification des champs après le démarrage des fils d'exécution n'est pas "
+"recommandée car cela nécessiterait une synchronisation des fils d'exécution "
+"pour éviter des conditions de concurrence."
 
 #: library/decimal.rst:1001
 msgid ""
 "In single threaded environments, it is preferable to not use this context at "
 "all.  Instead, simply create contexts explicitly as described below."
 msgstr ""
+"Dans les environnements à fil d'exécution unique, il est préférable de ne "
+"pas utiliser ce contexte du tout. Créez plutôt simplement des contextes "
+"explicitement comme décrit ci-dessous."
 
 #: library/decimal.rst:1004
 msgid ""
@@ -1235,12 +1470,18 @@ msgid ""
 "rounding`\\ =\\ :const:`ROUND_HALF_EVEN`, and enabled traps for :class:"
 "`Overflow`, :class:`InvalidOperation`, and :class:`DivisionByZero`."
 msgstr ""
+"Les valeurs par défaut sont :attr:`Context.prec`\\ =\\ ``28``, :attr:"
+"`Context.rounding`\\ =\\ :const:`ROUND_HALF_EVEN` et les interruptions sont "
+"activées pour :class:`Overflow`, :class:`InvalidOperation` et :class:"
+"`DivisionByZero`."
 
 #: library/decimal.rst:1009
 msgid ""
 "In addition to the three supplied contexts, new contexts can be created with "
 "the :class:`Context` constructor."
 msgstr ""
+"En plus des trois contextes fournis, de nouveaux contextes peuvent être "
+"créés avec le constructeur :class:`Context`."
 
 #: library/decimal.rst:1015
 msgid ""
@@ -1436,7 +1677,6 @@ msgid "Divides two numbers and returns the integer part of the result."
 msgstr "Renvoie la partie entière de la division entre deux nombres."
 
 #: library/decimal.rst:1212
-#, fuzzy
 msgid "Returns ``e ** x``."
 msgstr "Renvoie ``e ** x``."
 
@@ -1459,7 +1699,7 @@ msgstr "Renvoie ``True`` si *x* est infini et ``False`` sinon."
 #: library/decimal.rst:1237
 msgid "Returns ``True`` if *x* is a qNaN or sNaN; otherwise returns ``False``."
 msgstr ""
-"Renvoie ``True`` si *x* est un NaN (silencieux ou signalétique) et ``False`` "
+"Renvoie ``True`` si *x* est un *NaN* (silencieux ou signalétique), ``False`` "
 "sinon."
 
 #: library/decimal.rst:1242
@@ -1469,7 +1709,7 @@ msgstr ""
 
 #: library/decimal.rst:1247
 msgid "Returns ``True`` if *x* is a quiet NaN; otherwise returns ``False``."
-msgstr "Renvoie ``True`` si *x* est un NaN silencieux et ``False`` sinon."
+msgstr "Renvoie ``True`` si *x* est un *NaN* silencieux, ``False`` sinon."
 
 #: library/decimal.rst:1252
 msgid "Returns ``True`` if *x* is negative; otherwise returns ``False``."
@@ -1478,7 +1718,7 @@ msgstr "Renvoie ``True`` si *x* est négatif et ``False`` sinon."
 #: library/decimal.rst:1257
 msgid ""
 "Returns ``True`` if *x* is a signaling NaN; otherwise returns ``False``."
-msgstr "Renvoie ``True`` si *x* est un NaN signalétique et ``False`` sinon."
+msgstr "Renvoie ``True`` si *x* est un *NaN* signalétique, ``False`` sinon."
 
 #: library/decimal.rst:1262
 msgid "Returns ``True`` if *x* is subnormal; otherwise returns ``False``."
@@ -1628,11 +1868,11 @@ msgstr ""
 
 #: library/decimal.rst:1408
 msgid "Just returns 10, as this is Decimal, :)"
-msgstr "Renvoie 10 car c'est Decimal, :)"
+msgstr "Renvoie 10 car c'est *Decimal*, :)"
 
 #: library/decimal.rst:1413
 msgid "Returns the remainder from integer division."
-msgstr "Donne le reste de la division entière."
+msgstr "Renvoie le reste de la division entière."
 
 #: library/decimal.rst:1415
 msgid ""
@@ -1688,7 +1928,7 @@ msgid ""
 "also included in the pure Python version for compatibility."
 msgstr ""
 "Les constantes de cette section ne sont pertinentes que pour le module C. "
-"Elles sont aussi incluses pour le compatibilité dans la version en Python "
+"Elles sont aussi incluses pour la compatibilité dans la version en Python "
 "pur."
 
 #: library/decimal.rst:1484
@@ -1700,34 +1940,28 @@ msgid "64-bit"
 msgstr "64-bit"
 
 #: library/decimal.rst:1488
-#, fuzzy
 msgid "``425000000``"
-msgstr ":const:`425000000`"
+msgstr "``425000000``"
 
 #: library/decimal.rst:1488
-#, fuzzy
 msgid "``999999999999999999``"
-msgstr ":const:`999999999999999999`"
+msgstr "``999999999999999999``"
 
 #: library/decimal.rst:1490
-#, fuzzy
 msgid "``-425000000``"
-msgstr ":const:`-425000000`"
+msgstr "``-425000000``"
 
 #: library/decimal.rst:1490
-#, fuzzy
 msgid "``-999999999999999999``"
-msgstr ":const:`-999999999999999999`"
+msgstr "``-999999999999999999``"
 
 #: library/decimal.rst:1492
-#, fuzzy
 msgid "``-849999999``"
-msgstr ":const:`-849999999`"
+msgstr "``-849999999``"
 
 #: library/decimal.rst:1492
-#, fuzzy
 msgid "``-1999999999999999997``"
-msgstr ":const:`-1999999999999999997`"
+msgstr "``-1999999999999999997``"
 
 #: library/decimal.rst:1498
 msgid ""
@@ -1968,8 +2202,8 @@ msgstr ""
 #: library/decimal.rst:1748
 msgid ""
 "The number system for the :mod:`decimal` module provides special values "
-"including ``NaN``, ``sNaN``, ``-Infinity``, ``Infinity``, and two zeros, "
-"``+0`` and ``-0``."
+"including ``NaN``, ``sNaN``, ``-Infinity``, ``Infinity``, and two zeros, ``"
+"+0`` and ``-0``."
 msgstr ""
 
 #: library/decimal.rst:1752
@@ -2124,7 +2358,6 @@ msgstr ""
 "cet invariant dans l'application ?"
 
 #: library/decimal.rst:2037
-#, fuzzy
 msgid ""
 "A. Some operations like addition, subtraction, and multiplication by an "
 "integer will automatically preserve fixed point.  Others operations, like "
@@ -2135,17 +2368,16 @@ msgstr ""
 "multiplication par un entier préservent automatiquement la virgule fixe. "
 "D'autres opérations, comme la division et la multiplication par des non-"
 "entiers, changent le nombre de décimales et doivent être suivies d'une "
-"étape :meth:`quantize` :"
+"étape :meth:`~Decimal.quantize` :"
 
 #: library/decimal.rst:2055
-#, fuzzy
 msgid ""
 "In developing fixed-point applications, it is convenient to define functions "
 "to handle the :meth:`~Decimal.quantize` step:"
 msgstr ""
 "Lors du développement d'applications en virgule fixe, il est pratique de "
 "définir des fonctions pour gérer cette étape de quantification par :meth:"
-"`quantize` :"
+"`~Decimal.quantize` :"
 
 #: library/decimal.rst:2068
 msgid ""