diff --git a/library/dataclasses.po b/library/dataclasses.po
index 174c818a..336e06a9 100644
--- a/library/dataclasses.po
+++ b/library/dataclasses.po
@@ -6,14 +6,14 @@ msgstr ""
 "Project-Id-Version: Python 3\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2021-05-19 22:36+0200\n"
-"PO-Revision-Date: 2018-12-24 14:53+0100\n"
-"Last-Translator: Julien Palard <julien@palard.fr>\n"
+"PO-Revision-Date: 2021-09-21 09:00+0200\n"
+"Last-Translator: Jean Abou Samra <jean@abou-samra.fr>\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.1.1\n"
+"X-Generator: Poedit 2.4.1\n"
 
 #: library/dataclasses.rst:2
 msgid ":mod:`dataclasses` --- Data Classes"
@@ -36,19 +36,18 @@ msgstr ""
 "l’utilisateur.  Ces classes ont été décrites dans la :pep:`557`."
 
 #: library/dataclasses.rst:19
-#, fuzzy
 msgid ""
 "The member variables to use in these generated methods are defined using :"
 "pep:`526` type annotations.  For example, this code::"
 msgstr ""
 "Les variables membres à utiliser dans ces méthodes générées sont définies en "
-"utilisant les annotations de type :pep:`526`.  Par exemple, ce code ::"
+"utilisant les annotations de type :pep:`526`.  Par exemple ::"
 
 #: library/dataclasses.rst:34
-#, fuzzy
 msgid "will add, among other things, a :meth:`__init__` that looks like::"
 msgstr ""
-"Ajoute, entre autres choses, une méthode :meth:`__init__` qui ressemble à ::"
+"Ce code ajoute à la classe, entre autres choses, une méthode :meth:"
+"`__init__` qui ressemble à ::"
 
 #: library/dataclasses.rst:41
 msgid ""
@@ -56,35 +55,33 @@ msgid ""
 "directly specified in the ``InventoryItem`` definition shown above."
 msgstr ""
 "Il est important de noter que cette méthode est ajoutée automatiquement dans "
-"la classe : elle n’est pas à écrire dans la définition de ``InventoryItem`` "
-"ci-dessus."
+"la classe. Elle n’est jamais écrite dans la définition de ``InventoryItem``."
 
 #: library/dataclasses.rst:47
 msgid "Module-level decorators, classes, and functions"
-msgstr "Décorateurs, classes et fonctions au niveau du module"
+msgstr "Décorateurs, classes et fonctions du module"
 
 #: library/dataclasses.rst:51
 msgid ""
 "This function is a :term:`decorator` that is used to add generated :term:"
 "`special method`\\s to classes, as described below."
 msgstr ""
-"Cette fonction est un :term:`décorateur` qui est utilisé pour ajouter les :"
-"term:`méthodes spéciales <special method>` générées aux classes, comme "
-"décrit ci-dessous."
+"Cette fonction est un :term:`décorateur <decorator>` qui ajoute aux classes "
+"des :term:`méthodes spéciales <special method>` générées automatiquement. "
+"Voici une description plus détaillée."
 
 #: library/dataclasses.rst:54
-#, fuzzy
 msgid ""
 "The :func:`dataclass` decorator examines the class to find ``field``\\s.  A "
 "``field`` is defined as a class variable that has a :term:`type annotation "
 "<variable annotation>`.  With two exceptions described below, nothing in :"
 "func:`dataclass` examines the type specified in the variable annotation."
 msgstr ""
-"Le décorateur :func:`dataclass` examine la classe pour trouver des ``champs``"
-"\\s.  Un ``champ`` est défini comme une variable de classe qui possède une :"
-"term:`annotation de type <variable annotation>`.  À deux exceptions près "
-"décrites plus bas, il n’y a rien dans :func:`dataclass` qui examine le type "
-"spécifié dans l’annotation de variable."
+"Le décorateur :func:`dataclass` examine la classe pour trouver des champs.  "
+"Un champ est défini comme une variable de classe qui possède une :term:"
+"`annotation de type <variable annotation>`.  À deux exceptions près décrites "
+"plus bas, :func:`dataclass` ne prend pas en considération le type donné dans "
+"l'annotation."
 
 #: library/dataclasses.rst:60
 msgid ""
@@ -95,7 +92,6 @@ msgstr ""
 "champs dans la définition de la classe."
 
 #: library/dataclasses.rst:63
-#, fuzzy
 msgid ""
 "The :func:`dataclass` decorator will add various \"dunder\" methods to the "
 "class, described below.  If any of the added methods already exist in the "
@@ -103,11 +99,10 @@ msgid ""
 "decorator returns the same class that it is called on; no new class is "
 "created."
 msgstr ""
-"Le décorateur :func:`dataclass` ajoute diverses méthodes « spéciales » à la "
+"Le décorateur :func:`dataclass` ajoute diverses méthodes spéciales à la "
 "classe, décrites ci-après.  Si l’une des méthodes ajoutées existe déjà dans "
-"la classe, le comportement dépend des paramètres, comme documenté ci-"
-"dessous. Le décorateur renvoie la classe sur laquelle il est appelé ; il n’y "
-"a pas de nouvelle classe créée."
+"la classe, le comportement dépend des paramètres. Le décorateur renvoie la "
+"classe sur laquelle il est appelé ; aucune nouvelle classe n'est créée."
 
 #: library/dataclasses.rst:69
 msgid ""
@@ -115,20 +110,20 @@ msgid ""
 "it acts as if it has the default values documented in this signature.  That "
 "is, these three uses of :func:`dataclass` are equivalent::"
 msgstr ""
-"Si :func:`dataclass` est utilisé comme simple décorateur sans paramètres, il "
-"se comporte comme si on l’avait appelé avec les valeurs par défaut présentes "
-"en signature.  Ainsi, les trois usages suivants de :func:`dataclass` sont "
+"Si :func:`dataclass` est utilisé directement, il se comporte comme si on "
+"l’avait appelé sans argument (c.-à-d. en laissant les valeurs par défaut de "
+"sa signature). Ainsi, les trois usages suivants de :func:`dataclass` sont "
 "équivalents ::"
 
 #: library/dataclasses.rst:86
 msgid "The parameters to :func:`dataclass` are:"
-msgstr "Les paramètres de :func:`dataclass` sont :"
+msgstr "Les paramètres de :func:`dataclass` sont les suivants :"
 
 #: library/dataclasses.rst:88
 msgid ""
 "``init``: If true (the default), a :meth:`__init__` method will be generated."
 msgstr ""
-"``init``: Si vrai (par défaut), une méthode :meth:`__init__` est générée."
+"*init* : si vrai (par défaut), une méthode :meth:`__init__` est générée."
 
 #: library/dataclasses.rst:91
 msgid ""
@@ -146,12 +141,12 @@ msgid ""
 "example: ``InventoryItem(name='widget', unit_price=3.0, "
 "quantity_on_hand=10)``."
 msgstr ""
-"``repr``: Si vrai (par défaut), une méthode :meth:`__repr__` sera générée.  "
-"La chaîne de représentation comportera le nom de la classe et le nom ainsi "
-"que la représentation de chaque champ, suivant leur ordre de définition.  "
-"Les champs marqués comme exclus (voir ``Field`` ci-dessous) de la "
-"représentation ne sont pas inclus.  Par exemple : "
-"``InventoryItem(name='widget', unit_price=3.0, quantity_on_hand=10)``."
+"*repr* : si vrai (par défaut), une méthode :meth:`__repr__` est générée.  La "
+"chaîne de représentation comporte le nom de la classe et le nom ainsi que la "
+"représentation de chaque champ, suivant leur ordre de définition.  Les "
+"champs marqués comme exclus de la représentation (voir ``Field`` ci-dessous) "
+"sont ignorés.  Par exemple : ``InventoryItem(name='widget', unit_price=3.0, "
+"quantity_on_hand=10)``."
 
 #: library/dataclasses.rst:101
 msgid ""
@@ -166,9 +161,9 @@ msgid ""
 "This method compares the class as if it were a tuple of its fields, in "
 "order.  Both instances in the comparison must be of the identical type."
 msgstr ""
-"``eq``: Si vrai (par défaut), une méthode :meth:`__eq__` est générée.  Cette "
-"méthode permet de comparer les instances de la classe comme s’il s’agissait "
-"d’un *n*-uplet de ses champs, dans l’ordre. Les deux instances dans la "
+"*eq* : si vrai (par défaut), une méthode :meth:`__eq__` est générée.  Cette "
+"méthode permet de comparer les instances de la classe comme si elles étaient "
+"des *n*-uplet de leurs champs, pris dans l’ordre. Les deux instances dans la "
 "comparaison doivent être de même type."
 
 #: library/dataclasses.rst:109
@@ -185,15 +180,14 @@ msgid ""
 "instances in the comparison must be of the identical type.  If ``order`` is "
 "true and ``eq`` is false, a :exc:`ValueError` is raised."
 msgstr ""
-"``order``: Si vrai (``False`` par défaut), les méthodes :meth:`__lt__`, :"
-"meth:`__le__`, :meth:`__gt__`, et :meth:`__ge__` sont générées.  Elles "
-"permettent de comparer les instances de la classe en les considérant comme "
-"des *n*-uplets, dans l’ordre de définition des champs.  Chaque instance dans "
-"la comparaison doit être de même type.  Si ``order`` est vrai mais que "
+"*order* : si vrai (``False`` par défaut), les méthodes :meth:`__lt__`, :meth:"
+"`__le__`, :meth:`__gt__`, et :meth:`__ge__` sont générées.  Elles permettent "
+"de comparer les instances de la classe en les considérant comme des *n*-"
+"uplets, dans l’ordre de définition des champs.  Toutes les instances dans la "
+"comparaison doivent être de même type.  Si ``order`` est vrai mais que "
 "``eq`` est faux, une :exc:`ValueError` est levée."
 
 #: library/dataclasses.rst:119
-#, fuzzy
 msgid ""
 "If the class already defines any of :meth:`__lt__`, :meth:`__le__`, :meth:"
 "`__gt__`, or :meth:`__ge__`, then :exc:`TypeError` is raised."
@@ -207,8 +201,8 @@ msgid ""
 "``unsafe_hash``: If ``False`` (the default), a :meth:`__hash__` method is "
 "generated according to how ``eq`` and ``frozen`` are set."
 msgstr ""
-"``unsafe_hash``: Si ``False`` (par défaut), une méthode :meth:`__hash__` est "
-"générée et son comportement dépend des valeurs de ``eq`` et ``frozen``."
+"*unsafe_hash* : si ``False`` (par défaut), une méthode :meth:`__hash__` est "
+"générée et son comportement dépend des valeurs de *eq* et *frozen*."
 
 #: library/dataclasses.rst:126
 msgid ""
@@ -223,9 +217,9 @@ msgstr ""
 "que lorsqu’un objet est inséré dans une collection utilisant du hachage, tel "
 "qu’un dictionnaire ou un ensemble.  Avoir une méthode :meth:`__hash__` "
 "implique que les instances de la classe sont immuables. La muabilité est une "
-"propriété complexe qui dépends des intentions du programmeur, de l’existence "
+"propriété complexe qui dépend des intentions du programmeur, de l’existence "
 "et du comportement de la méthode :meth:`__eq__`, et des valeurs des options "
-"``eq`` et ``frozen`` dans l’appel au décorateur :func:`dataclass`."
+"*eq* et *frozen* dans l’appel au décorateur :func:`dataclass`."
 
 #: library/dataclasses.rst:133
 msgid ""
@@ -237,13 +231,12 @@ msgid ""
 msgstr ""
 "Par défaut, :func:`dataclass` n’ajoute pas de méthode implicite :meth:"
 "`__hash__`, sauf s’il n’existe aucun risque sous-jacent.  Il n’ajoute ou ne "
-"modifie pas non plus la méthode :meth:`__hash__` si elle a est définie "
+"modifie pas non plus la méthode :meth:`__hash__` si elle a été définie "
 "explicitement.  Définir l’attribut de classe ``__hash__ = None`` a une "
-"signification particulière en Python, comme précisé dans la documentation "
-"de :meth:`__hash__`."
+"signification particulière, comme précisé dans la documentation de :meth:"
+"`__hash__`."
 
 #: library/dataclasses.rst:139
-#, fuzzy
 msgid ""
 "If :meth:`__hash__` is not explicitly defined, or if it is set to ``None``, "
 "then :func:`dataclass` *may* add an implicit :meth:`__hash__` method. "
@@ -254,11 +247,12 @@ msgid ""
 msgstr ""
 "Si :meth:`__hash__` n’est pas défini explicitement, ou s’il a pour valeur "
 "``None``, alors :func:`dataclass` *peut* ajouter une méthode :meth:"
-"`__hash__` implicite. Bien que ce ne soit pas recommandé,, vous pouvez "
+"`__hash__` implicite. Bien que ce ne soit pas recommandé, vous pouvez "
 "forcer :func:`dataclass` à créer une méthode :meth:`__hash__` en utilisant "
 "``unsafe_hash=True``. Cela pourrait être nécessaire si votre classe est "
-"logiquement immuable mais qu’une mutation est tout de même possible. C’est "
-"un cas très particulier qui doit être considéré avec la plus grande prudence."
+"logiquement immuable mais qu’une mutation est tout de même possible. Il "
+"s'agit là d'un cas particulier qui doit être considéré avec la plus grande "
+"prudence."
 
 #: library/dataclasses.rst:146
 msgid ""
@@ -267,10 +261,10 @@ msgid ""
 "in your dataclass and set ``unsafe_hash=True``; this will result in a :exc:"
 "`TypeError`."
 msgstr ""
-"Ce sont les règles autour de la création implicite de la méthode :meth:"
+"Voici les règles autour de la création implicite de la méthode :meth:"
 "`__hash__`.  Il faut noter que vous ne pouvez pas avoir à la fois une "
-"méthode :meth:`__hash__` explicite dans votre *dataclass* et définir "
-"``unsafe_hash=True``; cela lèvera une :exc:`TypeError`."
+"méthode :meth:`__hash__` explicite dans votre classe de données et définir "
+"``unsafe_hash=True`` ; cela lèvera une :exc:`TypeError`."
 
 #: library/dataclasses.rst:151
 msgid ""
@@ -282,24 +276,23 @@ msgid ""
 "superclass will be used (if the superclass is :class:`object`, this means it "
 "will fall back to id-based hashing)."
 msgstr ""
-"Si ``eq`` et ``frozen`` sont tous deux vrais, :func:`dataclass` génère par "
-"défaut une méthode :meth:`__hash__` pour vous.  Si ``eq`` est vrai mais que "
-"``frozen`` est faux, :meth:`__hash__` prend la valeur ``None``, marquant la "
-"classe comme non-hachable (et c’est le cas, puisqu’elle est modifiable).  Si "
-"``eq`` est faux, la méthode :meth:`__hash__` est laissée intacte, ce qui "
-"veut dire que la méthode :meth:`__hash__` de la classe parente sera utilisée "
-"(si la classe parente est :class:`object`, le comportement est un hachage "
-"basé sur les id)."
+"Si *eq* et *frozen* sont tous deux vrais, :func:`dataclass` génère par "
+"défaut une méthode :meth:`__hash__` pour vous.  Si *eq* est vrai mais que "
+"*frozen* est faux, :meth:`__hash__` prend la valeur ``None``, marquant la "
+"classe comme non-hachable (et c’est le cas, puisque les instances sont "
+"mutables).  Si ``eq`` est faux, la méthode :meth:`__hash__` est laissée "
+"intacte, ce qui veut dire que la méthode :meth:`__hash__` de la classe "
+"parente sera utilisée (si la classe parente est :class:`object`, le "
+"comportement est un hachage basé sur les id)."
 
 #: library/dataclasses.rst:159
-#, fuzzy
 msgid ""
 "``frozen``: If true (the default is ``False``), assigning to fields will "
 "generate an exception.  This emulates read-only frozen instances.  If :meth:"
 "`__setattr__` or :meth:`__delattr__` is defined in the class, then :exc:"
 "`TypeError` is raised.  See the discussion below."
 msgstr ""
-"``frozen``: Si vrai (faux par défaut), assigner une valeur à un champ lèvera "
+"*frozen* : si vrai (faux par défaut), assigner une valeur à un champ lève "
 "une exception.  Cela simule le comportement des instances figées en lecture "
 "seule.  Si la méthode :meth:`__setattr__` ou :meth:`__delattr__` est définie "
 "sur la classe, alors une :exc:`TypeError` est levée.  Voir la discussion ci-"
@@ -310,7 +303,7 @@ msgid ""
 "``field``\\s may optionally specify a default value, using normal Python "
 "syntax::"
 msgstr ""
-"Les ``field``\\s peuvent éventuellement spécifier une valeur par défaut, en "
+"Les champs peuvent éventuellement préciser une valeur par défaut, en "
 "utilisant la syntaxe Python normale ::"
 
 #: library/dataclasses.rst:172
@@ -322,7 +315,6 @@ msgstr ""
 "la méthode générée :meth:`__init__`, qui est définie comme suit ::"
 
 #: library/dataclasses.rst:177
-#, fuzzy
 msgid ""
 ":exc:`TypeError` will be raised if a field without a default value follows a "
 "field with a default value.  This is true whether this occurs in a single "
@@ -330,8 +322,7 @@ msgid ""
 msgstr ""
 "Une :exc:`TypeError` est levée si un champ sans valeur par défaut est défini "
 "après un champ avec une valeur par défaut.  C’est le cas que ce soit dans "
-"une seule classe, mais également si c’est le résultat d’un héritage de "
-"classes."
+"une seule classe ou si c’est le résultat d’un héritage de classes."
 
 #: library/dataclasses.rst:183
 msgid ""
@@ -341,6 +332,11 @@ msgid ""
 "replace the default field value with a call to the provided :func:`field` "
 "function.  For example::"
 msgstr ""
+"Dans les cas les plus simples et courants, ce qui a été décrit jusqu'ici "
+"suffit. Cependant, les classes de données possèdent des fonctionnalités "
+"supplémentaires fondées sur des métadonnées propres à chaque champ. Pour "
+"remplir ces métadonnées, il suffit de mettre un appel à la fonction :func:"
+"`field` à la place de la valeur par défaut, comme dans cet exemple :"
 
 #: library/dataclasses.rst:196
 msgid ""
@@ -349,10 +345,16 @@ msgid ""
 "sentinel is used because ``None`` is a valid value for ``default``.  No code "
 "should directly use the ``MISSING`` value."
 msgstr ""
+"Comme le montre la signature, la valeur ``MISSING`` est une valeur "
+"sentinelle. Elle permet de déterminer si les paramètres ``default`` et "
+"``default_factory`` ont été passés explicitement ou non. ``None`` ne "
+"conviendrait pas puisque c'est une valeur possible pour ``default``. La "
+"sentinelle ``MISSING`` est interne au module et ne doit pas être utilisée "
+"dans vos programmes."
 
 #: library/dataclasses.rst:202
 msgid "The parameters to :func:`field` are:"
-msgstr ""
+msgstr "Les paramètres de :func:`field` sont :"
 
 #: library/dataclasses.rst:204
 msgid ""
@@ -360,6 +362,9 @@ msgid ""
 "This is needed because the :meth:`field` call itself replaces the normal "
 "position of the default value."
 msgstr ""
+"*default* : s'il est fourni, il devient la valeur par défaut du champ. "
+"L'appel à :meth:`field` est mis à la place normale de la valeur par défaut, "
+"d'où la nécessité de ce paramètre."
 
 #: library/dataclasses.rst:208
 msgid ""
@@ -369,24 +374,36 @@ msgid ""
 "discussed below.  It is an error to specify both ``default`` and "
 "``default_factory``."
 msgstr ""
+"*default_factory* : s'il est fourni, ce doit être un objet appelable sans "
+"argument. Il est alors appelé à chaque fois qu'il faut une valeur par défaut "
+"pour le champ. Ceci permet, entre autres choses, de définir des champs dont "
+"les valeurs par défaut sont muables. Une erreur se produit si *default* et "
+"*default_factory* sont donnés tous les deux."
 
 #: library/dataclasses.rst:214
 msgid ""
 "``init``: If true (the default), this field is included as a parameter to "
 "the generated :meth:`__init__` method."
 msgstr ""
+"*init* : si vrai (par défaut), la méthode :meth:`__init__` générée possède "
+"un paramètre correspondant à ce champ."
 
 #: library/dataclasses.rst:217
 msgid ""
 "``repr``: If true (the default), this field is included in the string "
 "returned by the generated :meth:`__repr__` method."
 msgstr ""
+"*repr* : si vrai (par défaut), le champ est inclus dans les chaînes "
+"construites par la méthode :meth:`__repr__` générée."
 
 #: library/dataclasses.rst:220
 msgid ""
 "``compare``: If true (the default), this field is included in the generated "
 "equality and comparison methods (:meth:`__eq__`, :meth:`__gt__`, et al.)."
 msgstr ""
+"*compare* : si vrai (par défaut), le champ est considéré dans les "
+"comparaisons d'égalité et d'inégalité dans les méthodes générées :meth:"
+"`__eq__`, :meth:`__gt__`, etc."
 
 #: library/dataclasses.rst:224
 msgid ""
@@ -396,6 +413,12 @@ msgid ""
 "field should be considered in the hash if it's used for comparisons.  "
 "Setting this value to anything other than ``None`` is discouraged."
 msgstr ""
+"*hash* : ce paramètre est un booléen ou ``None``. La valeur ``False`` force "
+"la prise en compte du champ dans la méthode :meth:`__hash__` générée, alors "
+"que ``False`` force son exclusion. ``None`` revient à mettre la même valeur "
+"que *compare*, ce qui est en général correct : il faut inclure dans le "
+"hachage les champs employés pour les comparaisons. Il est déconseillé de "
+"mettre ce paramètre à autre chose que ``None``."
 
 #: library/dataclasses.rst:231
 msgid ""
@@ -405,6 +428,12 @@ msgid ""
 "hash value.  Even if a field is excluded from the hash, it will still be "
 "used for comparisons."
 msgstr ""
+"Cependant, une raison légitime de mettre *hash* à ``False`` alors que "
+"*compare* est à ``True`` est la concourance de trois facteurs : le champ est "
+"coûteux à hacher ; il est nécessaire pour les comparaisons d'égalité ; et il "
+"y a déjà d'autres champs qui participent au hachage des instances. À ce "
+"moment, on peut alors se passer du champ dans le hachage tout en le faisant "
+"participer aux comparaisons."
 
 #: library/dataclasses.rst:237
 msgid ""
@@ -415,6 +444,10 @@ msgid ""
 "Multiple third-parties can each have their own key, to use as a namespace in "
 "the metadata."
 msgstr ""
+"*metadata* : ce paramètre est un tableau associatif (*mapping* en anglais). "
+"La valeur par défaut de ``None`` est prise comme un dictionnaire vide. Le "
+"tableau associatif devient accessible sur l'objet :class:`Field`, sous la "
+"forme d'un :func:`~types.MappingProxyType` afin qu'il soit en lecture seule."
 
 #: library/dataclasses.rst:245
 msgid ""
@@ -426,12 +459,22 @@ msgid ""
 "fields, just as if the default value itself were specified.  For example, "
 "after::"
 msgstr ""
+"Si la valeur par défaut d'un champ est donnée dans un appel à :func:`field` "
+"(et pas directement), l'attribut correspondant de la classe est remplacé par "
+"cette valeur. Si le paramètre *default* n'est pas passé, l'attribut est "
+"simplement supprimé. De cette manière, après le passage du décorateur :func:"
+"`dataclass`, les attributs de la classe contiennent les valeurs par défaut "
+"des champs exactement comme si elles avaient été définies directement. Par "
+"exemple :"
 
 #: library/dataclasses.rst:261
 msgid ""
 "The class attribute ``C.z`` will be ``10``, the class attribute ``C.t`` will "
 "be ``20``, and the class attributes ``C.x`` and ``C.y`` will not be set."
 msgstr ""
+"Après l'exécution de ce code, l'attribut de classe ``C.z`` vaut ``10`` et "
+"l'attribut ``C.t`` vaut ``20``, alors que les attributs ``C.x`` et ``C.y`` "
+"n'existent pas."
 
 #: library/dataclasses.rst:267
 msgid ""
@@ -440,14 +483,19 @@ msgid ""
 "method (see below).  Users should never instantiate a :class:`Field` object "
 "directly.  Its documented attributes are:"
 msgstr ""
+"Les objets :class:`Field` contiennent des informations sur les champs. Ils "
+"sont créés en interne, et on y accède à l'aide de la méthode au niveau du "
+"module :func:`fields` (voir plus bas). Les utilisateurs ne doivent jamais "
+"instancier un objet :class:`Field` eux-mêmes. Les attributs documentés sont "
+"les suivants :"
 
 #: library/dataclasses.rst:272
 msgid "``name``: The name of the field."
-msgstr ""
+msgstr "*name* : le nom du champ ;"
 
 #: library/dataclasses.rst:274
 msgid "``type``: The type of the field."
-msgstr ""
+msgstr "*type* : le type associé au champ par l'annotation ;"
 
 #: library/dataclasses.rst:276
 msgid ""
@@ -455,12 +503,17 @@ msgid ""
 "and ``metadata`` have the identical meaning and values as they do in the :"
 "func:`field` declaration."
 msgstr ""
+"*default*, *default_factory*, *init*, *repr*, *hash*, *compare* et "
+"*metadata*, qui correspondent aux paramètres de :func:`field` et en prennent "
+"les valeurs."
 
 #: library/dataclasses.rst:280
 msgid ""
 "Other attributes may exist, but they are private and must not be inspected "
 "or relied on."
 msgstr ""
+"D'autres attributs peuvent exister, mais ils sont privés et ne sont pas "
+"censés être inspectés. Le code ne doit jamais reposer sur eux."
 
 #: library/dataclasses.rst:285
 msgid ""
@@ -469,6 +522,11 @@ msgid ""
 "Raises :exc:`TypeError` if not passed a dataclass or instance of one. Does "
 "not return pseudo-fields which are ``ClassVar`` or ``InitVar``."
 msgstr ""
+"Renvoie un *n*-uplet d'objets :class:`Field` correspondant aux champs de "
+"l'argument, à l'exclusion des pseudo-champs ``ClassVar`` ou ``InitVar``. "
+"L'argument peut être soit une classe de données, soit une instance d'une "
+"telle classe ; si ce n'est pas le cas, une exception :exc:`TypeError` est "
+"levée."
 
 #: library/dataclasses.rst:292
 msgid ""
@@ -477,10 +535,18 @@ msgid ""
 "``name: value`` pairs.  dataclasses, dicts, lists, and tuples are recursed "
 "into.  For example::"
 msgstr ""
+"Convertit *instance*, une instance d'une classe de données, en un "
+"dictionnaire. Le résultat est construit par la fonction *dict_factory*. Les "
+"clés et valeurs proviennent directement des champs. Les dictionnaires, "
+"listes, *n*-uplets et instances de classes de données sont traversés pour "
+"convertir récursivement toutes les instances de classes de données qu'ils "
+"contiennent. Voici un exemple :"
 
 #: library/dataclasses.rst:326
 msgid "Raises :exc:`TypeError` if ``instance`` is not a dataclass instance."
 msgstr ""
+"Lève :exc:`TypeError` si *instance* n'est pas une instance d'une classe de "
+"données."
 
 #: library/dataclasses.rst:316
 msgid ""
@@ -488,10 +554,14 @@ msgid ""
 "function ``tuple_factory``).  Each dataclass is converted to a tuple of its "
 "field values.  dataclasses, dicts, lists, and tuples are recursed into."
 msgstr ""
+"Convertit l'instance d'une classe de données *instance* en un *n*-uplet des "
+"valeurs de ses champs. Le résultat est construit par la fonction "
+"*tuple_factory*. Cette fonction agit récursivement sur les dictionnaires, "
+"listes, *n*-uplets et instances de classes de données."
 
 #: library/dataclasses.rst:321
 msgid "Continuing from the previous example::"
-msgstr ""
+msgstr "Pour continuer l'exemple précédent :"
 
 #: library/dataclasses.rst:330
 msgid ""
@@ -504,6 +574,14 @@ msgid ""
 "``unsafe_hash``, and ``frozen`` have the same meaning as they do in :func:"
 "`dataclass`."
 msgstr ""
+"Crée une nouvelle classe de données avec le nom *cls_name*. Les champs "
+"proviennent de l'objet itérable *fields*. Les classes mères sont lues dans "
+"*bases*. L'espace de nommage de la classe est initialisé par *namespace*. La "
+"forme la plus générale d'un élément de *fields* est un triplet ``(nom, type, "
+"objet_Field)``. Le troisième élément peut être omis. On peut aussi passer un "
+"simple nom, auquel cas le type sera ``typing.Any``. Les paramètres restants, "
+"à savoir *init*, *repr*, *eq*, *order*, *unsafe_hash* et *frozen*, sont les "
+"mêmes que dans :func:`dataclass`."
 
 #: library/dataclasses.rst:339
 msgid ""
@@ -512,10 +590,14 @@ msgid ""
 "`dataclass` function to convert that class to a dataclass.  This function is "
 "provided as a convenience.  For example::"
 msgstr ""
+"Cette fonction est pratique mais pas absolument nécessaire, puisqu'il suffit "
+"de créer par un moyen quelconque une classe avec l'attribut "
+"``__annotation__`` et de lui appliquer la fonction :func:`dataclass`, qui la "
+"convertit en une classe de données. Par exemple, ceci :"
 
 #: library/dataclasses.rst:351
 msgid "Is equivalent to::"
-msgstr ""
+msgstr "est équivalent à :"
 
 #: library/dataclasses.rst:364
 msgid ""
@@ -524,6 +606,11 @@ msgid ""
 "`TypeError`.  If values in ``changes`` do not specify fields, raises :exc:"
 "`TypeError`."
 msgstr ""
+"Crée un nouvel objet du même type que *instance* en effectuant les "
+"remplacements donnés par *changes* dans ses champs. L'argument *instance* "
+"doit être une instance d'une classe de données, sans quoi :exc:`TypeError` "
+"est levée. De même, si une clé dans *changes* ne correspond à aucun champ de "
+"l'instance, :exc:`TypeError` est levée."
 
 #: library/dataclasses.rst:369
 msgid ""
@@ -531,6 +618,9 @@ msgid ""
 "of the dataclass.  This ensures that :meth:`__post_init__`, if present, is "
 "also called."
 msgstr ""
+"L'objet renvoyé est créé à l'aide de la méthode :meth:`__init__` de la "
+"classe de données, ce qui garantit que :meth:`__post_init__` est appelée (si "
+"elle existe)."
 
 #: library/dataclasses.rst:373
 msgid ""
@@ -538,12 +628,17 @@ msgid ""
 "on the call to :func:`replace` so that they can be passed to :meth:"
 "`__init__` and :meth:`__post_init__`."
 msgstr ""
+"Si un champ d'initialisation (voir plus bas) n'a pas de valeur par défaut, "
+"il faut l'inclure dans l'appel à :func:`replace` afin qu'il soit passé à :"
+"meth:`__init__` et :meth:`__post_init__`."
 
 #: library/dataclasses.rst:377
 msgid ""
 "It is an error for ``changes`` to contain any fields that are defined as "
 "having ``init=False``.  A :exc:`ValueError` will be raised in this case."
 msgstr ""
+"Si une clé de *changes* correspond à un champ défini avec ``init=False``, :"
+"exc:`ValueError` est levée."
 
 #: library/dataclasses.rst:381
 msgid ""
@@ -555,12 +650,21 @@ msgid ""
 "perhaps a custom ``replace()`` (or similarly named) method which handles "
 "instance copying."
 msgstr ""
+"Prenez garde aux champs définis avec ``init=False`` dans un appel à :func:"
+"`replace`. Ils ne sont pas copiés automatiquement de l'instance source. "
+"C'est le rôle de :meth:`__post_init__` de les initialiser — ou pas. Les "
+"champs avec ``init=False`` doivent rarement être utilisés et seulement à bon "
+"escient. Si vous en avez, il peut être sage de traiter la copie des "
+"instances par des constructeurs de classe alternatifs, ou bien une méthode "
+"personnalisée ``replace()`` (ou un nom similaire)."
 
 #: library/dataclasses.rst:392
 msgid ""
 "Return ``True`` if its parameter is a dataclass or an instance of one, "
 "otherwise return ``False``."
 msgstr ""
+"Renvoie ``True`` si l'argument est soit une classe de données, soit une "
+"instance d'une telle classe. Sinon, renvoie ``False``."
 
 #: library/dataclasses.rst:395
 msgid ""
@@ -568,10 +672,13 @@ msgid ""
 "dataclass itself), then add a further check for ``not isinstance(obj, "
 "type)``::"
 msgstr ""
+"Pour vérifier qu'un objet *obj* est une instance d'une classe de données, et "
+"non pas lui-même une classe de données, ajoutez le test ``not "
+"isinstance(obj, type)``."
 
 #: library/dataclasses.rst:403
 msgid "Post-init processing"
-msgstr ""
+msgstr "Post-initialisation"
 
 #: library/dataclasses.rst:405
 msgid ""
@@ -582,12 +689,21 @@ msgid ""
 "order they were defined in the class.  If no :meth:`__init__` method is "
 "generated, then :meth:`__post_init__` will not automatically be called."
 msgstr ""
+"Après avoir initialisé l'objet, la méthode :meth:`__init__` générée appelle "
+"la méthode :meth:`__post_init__`, si elle est définie. :meth:`__post_init__` "
+"est habituellement appelée avec un simple ``self.__post_init__()``. "
+"Cependant, si la classe comporte des champs d'initialisation (voir plus "
+"bas), leurs valeurs sont aussi passées à :meth:`__post_init__` telles "
+"qu'elles ont été fournies à :meth:`__init__`. Si la classe est créée avec "
+"``init=False``, :meth:`__post_init__` n'est jamais appelée automatiquement."
 
 #: library/dataclasses.rst:413
 msgid ""
 "Among other uses, this allows for initializing field values that depend on "
 "one or more other fields.  For example::"
 msgstr ""
+"Cette méthode permet, entre autres, d'initialiser des champs qui dépendent "
+"d'autres champs. Par exemple :"
 
 #: library/dataclasses.rst:425
 msgid ""
@@ -596,6 +712,10 @@ msgid ""
 "`__init__` method that has to be called, it is common to call this method in "
 "a :meth:`__post_init__` method::"
 msgstr ""
+"Les méthodes :meth:`__init__` des classes mères ne sont pas appelées "
+"automatiquement par la méthode :meth:`__init__` que génère :func:"
+"`dataclass`. S'il faut appeler ces méthodes :meth:`__init__`, il est courant "
+"de le faire dans :meth:`__post_init__` :"
 
 #: library/dataclasses.rst:442
 msgid ""
@@ -603,6 +723,10 @@ msgid ""
 "methods don't need to be called, since the derived dataclass will take care "
 "of initializing all fields of any base class that is a dataclass itself."
 msgstr ""
+"Notez toutefois qu'il n'est généralement pas nécessaire d'appeler une "
+"méthode :meth:`__init__` si elle a été générée automatiquement dans une "
+"classe de données, car la classe fille initialise elle-même les champs "
+"apportés par toute classe mère qui est aussi une classe de données."
 
 #: library/dataclasses.rst:446
 msgid ""
@@ -610,10 +734,14 @@ msgid ""
 "meth:`__post_init__`.  Also see the warning about how :func:`replace` "
 "handles ``init=False`` fields."
 msgstr ""
+"Voir la section plus bas à propos des variables d'initialisation pour les "
+"moyens de passer des paramètres à :meth:`__post_init__`. Voir également "
+"l'avertissement sur le traitement par :func:`replace` des champs définis "
+"avec ``init=False``."
 
 #: library/dataclasses.rst:451
 msgid "Class variables"
-msgstr ""
+msgstr "Variables de classe"
 
 #: library/dataclasses.rst:453
 msgid ""
@@ -624,10 +752,16 @@ msgid ""
 "as a field and is ignored by the dataclass mechanisms.  Such ``ClassVar`` "
 "pseudo-fields are not returned by the module-level :func:`fields` function."
 msgstr ""
+"Voici le premier des deux cas où le type fourni dans l'annotation d'un champ "
+"est pris en compte par :func:`dataclass` au moment de l'exécution. Si ce "
+"type est ``typing.ClassVar``, le champ est considéré comme une variable de "
+"classe, notion définie dans la :pep:`526`. Les champs de ce genre sont "
+"complètement ignorés du point de vue des classes de données. Ils "
+"n'apparaissent pas dans le résultat de :func:`fields`."
 
 #: library/dataclasses.rst:462
 msgid "Init-only variables"
-msgstr ""
+msgstr "Variables d'initialisation"
 
 #: library/dataclasses.rst:464
 msgid ""
@@ -640,22 +774,33 @@ msgid ""
 "generated :meth:`__init__` method, and are passed to the optional :meth:"
 "`__post_init__` method.  They are not otherwise used by dataclasses."
 msgstr ""
+"L'autre cas où l'annotation de type influence :func:`dataclass` est le "
+"suivant : si le type est ``dataclasses.InitVar``, le nom devient un « champ "
+"d'initialisation ». Puisque ce n'est pas un vrai champ, il n'est pas inclus "
+"dans le *n*-uplet que renvoie :func:`fields`. Les champs d'initialisation "
+"sont ajoutés en tant que paramètres à la méthode :meth:`__init__` générée. "
+"Leurs valeurs sont passées à :meth:`__post_init__`, si cette méthode existe. "
+"C'est la seule manière dont elles sont utilisées."
 
 #: library/dataclasses.rst:474
 msgid ""
 "For example, suppose a field will be initialized from a database, if a value "
 "is not provided when creating the class::"
 msgstr ""
+"On peut par exemple imaginer un champ initialisé à partir d'une base de "
+"données s'il n'a pas reçu de valeur explicite :"
 
 #: library/dataclasses.rst:489
 msgid ""
 "In this case, :func:`fields` will return :class:`Field` objects for ``i`` "
 "and ``j``, but not for ``database``."
 msgstr ""
+"Ici, :func:`fields` renvoie des objets :class:`Field` correspondant à ``i`` "
+"et à ``j``, mais pas à ``database``."
 
 #: library/dataclasses.rst:493
 msgid "Frozen instances"
-msgstr ""
+msgstr "Instances figées"
 
 #: library/dataclasses.rst:495
 msgid ""
@@ -665,6 +810,11 @@ msgid ""
 "meth:`__delattr__` methods to the class.  These methods will raise a :exc:"
 "`FrozenInstanceError` when invoked."
 msgstr ""
+"Bien qu'il ne soit pas possible de créer des objets Python strictement "
+"immuables, on peut rendre les instances d'une classe de données quasi "
+"immuables en passant ``frozen=True`` au décorateur :meth:`dataclass`, ce qui "
+"lui fait générer des méthodes :meth:`__setattr__` et :meth:`__delattr__`. "
+"Celles-ci lèvent systématiquement l'exception :exc:`FrozenInstanceError`."
 
 #: library/dataclasses.rst:501
 msgid ""
@@ -672,6 +822,9 @@ msgid ""
 "`__init__` cannot use simple assignment to initialize fields, and must use :"
 "meth:`object.__setattr__`."
 msgstr ""
+"Les performances sont légèrement moins bonnes avec ``frozen=True`` car :meth:"
+"`__init__` doit passer par :meth:`object.__setattr__` au lieu de simples "
+"affectations pour initialiser les champs."
 
 #: library/dataclasses.rst:506
 msgid "Inheritance"
@@ -688,20 +841,30 @@ msgid ""
 "ordered mapping of fields.  Because the fields are in insertion order, "
 "derived classes override base classes.  An example::"
 msgstr ""
+"Au moment de la création d'une classe de données, le décorateur :meth:"
+"`dataclass` parcourt toutes les classes mères dans l'ordre inverse de "
+"résolution des méthodes (donc en commençant par :class:`object`). À chaque "
+"fois qu'une classe de données est rencontrée, ses champs sont insérés dans "
+"un tableau associatif ordonné. Pour finir, les champs de la classe elle-même "
+"sont rajoutés. Toutes les méthodes générées utilisent en interne ce même "
+"tableau associatif. Puisqu'il est ordonné, les champs des classes filles "
+"écrasent ceux des classes mères. Voici un exemple :"
 
 #: library/dataclasses.rst:528
 msgid ""
 "The final list of fields is, in order, ``x``, ``y``, ``z``.  The final type "
 "of ``x`` is ``int``, as specified in class ``C``."
 msgstr ""
+"La liste finale des champs contient, dans l'ordre, ``x``, ``y``, ``z``. Le "
+"type de ``x`` est ``int``, comme déclaré dans ``C``."
 
 #: library/dataclasses.rst:531
 msgid "The generated :meth:`__init__` method for ``C`` will look like::"
-msgstr ""
+msgstr "La méthode :meth:`__init__` générée pour ``C`` ressemble à :"
 
 #: library/dataclasses.rst:536
 msgid "Default factory functions"
-msgstr ""
+msgstr "Fabriques de valeurs par défaut"
 
 #: library/dataclasses.rst:538
 msgid ""
@@ -709,6 +872,9 @@ msgid ""
 "arguments when a default value for the field is needed.  For example, to "
 "create a new instance of a list, use::"
 msgstr ""
+"Le paramètre facultatif *default_factory* de :func:`field` est une fonction "
+"qui est appelée sans argument pour fournir des valeurs par défaut. Par "
+"exemple, voici comment donner la valeur par défaut d'une liste vide :"
 
 #: library/dataclasses.rst:544
 msgid ""
@@ -717,30 +883,38 @@ msgid ""
 "will always be called from the generated :meth:`__init__` function.  This "
 "happens because there is no other way to give the field an initial value."
 msgstr ""
+"Si un champ avec fabrique est exclu de :meth:`__init__` (par "
+"``init=False``), alors la fabrique est appelée par :meth:`__init__` pour "
+"chaque nouvelle instance, puisque c'est le seul moyen d'obtenir une valeur à "
+"laquelle initialiser le champ."
 
 #: library/dataclasses.rst:551
 msgid "Mutable default values"
-msgstr ""
+msgstr "Valeurs par défaut muables"
 
 #: library/dataclasses.rst:553
 msgid ""
 "Python stores default member variable values in class attributes. Consider "
 "this example, not using dataclasses::"
 msgstr ""
+"En Python, les valeurs par défaut des attributs sont stockées dans des "
+"attributs de la classe. Observez cet exemple, sans classe de données :"
 
 #: library/dataclasses.rst:568
 msgid ""
 "Note that the two instances of class ``C`` share the same class variable "
 "``x``, as expected."
 msgstr ""
+"Comme attendu, les deux instances de ``C`` partagent le même objet pour "
+"l'attribut ``x``."
 
 #: library/dataclasses.rst:571
 msgid "Using dataclasses, *if* this code was valid::"
-msgstr ""
+msgstr "Avec les classes de données, si ce code était valide :"
 
 #: library/dataclasses.rst:579
 msgid "it would generate code similar to::"
-msgstr ""
+msgstr "il générerait un code équivalent à :"
 
 #: library/dataclasses.rst:590
 msgid ""
@@ -753,12 +927,23 @@ msgid ""
 "a default parameter of type ``list``, ``dict``, or ``set``.  This is a "
 "partial solution, but it does protect against many common errors."
 msgstr ""
+"On se retrouve avec le même problème qu'au premier exemple avec la classe "
+"``C``. Les classes de données étant créées comme toutes les autres classes "
+"Python, leur comportement est identique. Ainsi, deux instances séparées de "
+"``D`` où l'attribut ``x`` a été laissé à sa valeur par défaut partagent le "
+"même objet dans cet attribut. Il n'y a aucun moyen pour les classes de "
+"données de détecter cette situation en général. C'est pourquoi la "
+"construction d'une classe de données lève :exc:`TypeError` si une valeur par "
+"défaut est de type ``list``, ``dict`` ou ``set``. Cette solution n'est pas "
+"parfaite, mais permet d'éviter la majorité des erreurs."
 
 #: library/dataclasses.rst:600
 msgid ""
 "Using default factory functions is a way to create new instances of mutable "
 "types as default values for fields::"
 msgstr ""
+"Pour qu'un champ d'un type muable soit par défaut initialisé à un nouvel "
+"objet pour chaque instance, utilisez une fonction de fabrique :"
 
 #: library/dataclasses.rst:610
 msgid "Exceptions"
@@ -770,3 +955,6 @@ msgid ""
 "is called on a dataclass which was defined with ``frozen=True``. It is a "
 "subclass of :exc:`AttributeError`."
 msgstr ""
+"Sous-classe de :exc:`AttributeError`, levée lorsqu'une méthode :meth:"
+"`__setattr__` ou :meth:`__delattr__` définie implicitement est appelée dans "
+"une classe de données définie avec ``frozen=True``."