# Copyright (C) 2001-2018, Python Software Foundation

# For licence information, see README file.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2023-07-23 14:38+0200\n"

"PO-Revision-Date: 2023-03-20 09:44+0100\n"

"Last-Translator: David GIRAUD <davidgiraud@protonmail.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 3.2.1\n"

#: library/dataclasses.rst:2

msgid ":mod:`dataclasses` --- Data Classes"

msgstr ":mod:`dataclasses` — Classes de données"

#: library/dataclasses.rst:10

msgid "**Source code:** :source:`Lib/dataclasses.py`"

msgstr "**Code source :** :source:`Lib/dataclasses.py`"

#: library/dataclasses.rst:14

#, fuzzy

msgid ""

"This module provides a decorator and functions for automatically adding "

"generated :term:`special method`\\s such as :meth:`~object.__init__` and :"

"meth:`~object.__repr__` to user-defined classes. It was originally "

"described in :pep:`557`."

msgstr ""

"Ce module fournit un décorateur et des fonctions pour générer "

"automatiquement les :term:`méthodes spéciales <special method>` comme :meth:"

"`__init__` et :meth:`__repr__` dans les *Classes de Données* définies par "

"l’utilisateur. Ces classes ont été décrites dans la :pep:`557`."

#: library/dataclasses.rst:19

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 ::"

#: library/dataclasses.rst:34

#, fuzzy

msgid ""

"will add, among other things, a :meth:`~object.__init__` that looks like::"

msgstr ""

"ce code ajoute à la classe, entre autres choses, une méthode :meth:"

"`__init__` qui ressemble à ::"

#: library/dataclasses.rst:41

msgid ""

"Note that this method is automatically added to the class: it is not "

"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 jamais écrite dans la définition de ``InventoryItem``."

#: library/dataclasses.rst:47

msgid "Module contents"

msgstr "Classe de données"

#: 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 <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

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. "

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

"The order of the fields in all of the generated methods is the order in "

"which they appear in the class definition."

msgstr ""

"L’ordre des paramètres des méthodes générées est celui d’apparition des "

"champs dans la définition de la classe."

#: library/dataclasses.rst:63

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 "

"class, the behavior depends on the parameter, as documented below. The "

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

"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. Le décorateur renvoie la "

"classe sur laquelle il est appelé ; aucune nouvelle classe n'est créée."

#: library/dataclasses.rst:69

msgid ""

"If :func:`dataclass` is used just as a simple decorator with no parameters, "

"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é 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:87

msgid "The parameters to :func:`dataclass` are:"

msgstr "Les paramètres de :func:`dataclass` sont les suivants :"

#: library/dataclasses.rst:89

#, fuzzy

msgid ""

"``init``: If true (the default), a :meth:`~object.__init__` method will be "

"generated."

msgstr ""

"*init* : si vrai (par défaut), une méthode :meth:`__init__` est générée."

#: library/dataclasses.rst:92

#, fuzzy

msgid ""

"If the class already defines :meth:`~object.__init__`, this parameter is "

"ignored."

msgstr ""

"Si la classe définit déjà une méthode :meth:`__init__`, ce paramètre est "

"ignoré."

#: library/dataclasses.rst:95

#, fuzzy

msgid ""

"``repr``: If true (the default), a :meth:`~object.__repr__` method will be "

"generated. The generated repr string will have the class name and the name "

"and repr of each field, in the order they are defined in the class. Fields "

"that are marked as being excluded from the repr are not included. For "

"example: ``InventoryItem(name='widget', unit_price=3.0, "

"quantity_on_hand=10)``."

msgstr ""

"*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:102

#, fuzzy

msgid ""

"If the class already defines :meth:`~object.__repr__`, this parameter is "

"ignored."

msgstr ""

"Si la classe définit déjà une méthode :meth:`__repr__`, ce paramètre est "

"ignoré."

#: library/dataclasses.rst:105

#, fuzzy

msgid ""

"``eq``: If true (the default), an :meth:`~object.__eq__` method will be "

"generated. 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 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:110

#, fuzzy

msgid ""

"If the class already defines :meth:`~object.__eq__`, this parameter is "

"ignored."

msgstr ""

"Si la classe définit déjà une méthode :meth:`__eq__`, ce paramètre est "

"ignoré."

#: library/dataclasses.rst:113

#, fuzzy

msgid ""

"``order``: If true (the default is ``False``), :meth:`~object.__lt__`, :meth:"

"`~object.__le__`, :meth:`~object.__gt__`, and :meth:`~object.__ge__` methods "

"will be generated. These compare the class as if it were a tuple of its "

"fields, in order. Both 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. 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:120

#, fuzzy

msgid ""

"If the class already defines any of :meth:`~object.__lt__`, :meth:`~object."

"__le__`, :meth:`~object.__gt__`, or :meth:`~object.__ge__`, then :exc:"

"`TypeError` is raised."

msgstr ""

"Si la classe définit déjà l’une des méthodes :meth:`__lt__`, :meth:"

"`__le__`, :meth:`__gt__`, ou :meth:`__ge__`, alors une :exc:`TypeError` est "

"levée."

#: library/dataclasses.rst:124

#, fuzzy

msgid ""

"``unsafe_hash``: If ``False`` (the default), a :meth:`~object.__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*."

#: library/dataclasses.rst:127

#, fuzzy

msgid ""

":meth:`~object.__hash__` is used by built-in :meth:`hash()`, and when "

"objects are added to hashed collections such as dictionaries and sets. "

"Having a :meth:`~object.__hash__` implies that instances of the class are "

"immutable. Mutability is a complicated property that depends on the "

"programmer's intent, the existence and behavior of :meth:`~object.__eq__`, "

"and the values of the ``eq`` and ``frozen`` flags in the :func:`dataclass` "

"decorator."

msgstr ""

":meth:`__hash__` est utilisée par la fonction native :meth:`hash()`, ainsi "

"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é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`."

#: library/dataclasses.rst:134

#, fuzzy

msgid ""

"By default, :func:`dataclass` will not implicitly add a :meth:`~object."

"__hash__` method unless it is safe to do so. Neither will it add or change "

"an existing explicitly defined :meth:`~object.__hash__` method. Setting the "

"class attribute ``__hash__ = None`` has a specific meaning to Python, as "

"described in the :meth:`~object.__hash__` documentation."

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 été définie "

"explicitement. Définir l’attribut de classe ``__hash__ = None`` a une "

"signification particulière, comme précisé dans la documentation de :meth:"

"`__hash__`."

#: library/dataclasses.rst:140

#, fuzzy

msgid ""

"If :meth:`~object.__hash__` is not explicitly defined, or if it is set to "

"``None``, then :func:`dataclass` *may* add an implicit :meth:`~object."

"__hash__` method. Although not recommended, you can force :func:`dataclass` "

"to create a :meth:`~object.__hash__` method with ``unsafe_hash=True``. This "

"might be the case if your class is logically immutable but can nonetheless "

"be mutated. This is a specialized use case and should be considered "

"carefully."

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 "

"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. Il "

"s'agit là d'un cas particulier qui doit être considéré avec la plus grande "

"prudence."

#: library/dataclasses.rst:147

#, fuzzy

msgid ""

"Here are the rules governing implicit creation of a :meth:`~object.__hash__` "

"method. Note that you cannot both have an explicit :meth:`~object.__hash__` "

"method in your dataclass and set ``unsafe_hash=True``; this will result in "

"a :exc:`TypeError`."

msgstr ""

"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 classe de données et définir "

"``unsafe_hash=True`` ; cela lèvera une :exc:`TypeError`."

#: library/dataclasses.rst:152

#, fuzzy

msgid ""

"If ``eq`` and ``frozen`` are both true, by default :func:`dataclass` will "

"generate a :meth:`~object.__hash__` method for you. If ``eq`` is true and "

"``frozen`` is false, :meth:`~object.__hash__` will be set to ``None``, "

"marking it unhashable (which it is, since it is mutable). If ``eq`` is "

"false, :meth:`~object.__hash__` will be left untouched meaning the :meth:"

"`~object.__hash__` method of the 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, 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:160

#, fuzzy

msgid ""

"``frozen``: If true (the default is ``False``), assigning to fields will "

"generate an exception. This emulates read-only frozen instances. If :meth:"

"`~object.__setattr__` or :meth:`~object.__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è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-"

"dessous."

#: library/dataclasses.rst:165

#, fuzzy

msgid ""

"``match_args``: If true (the default is ``True``), the ``__match_args__`` "

"tuple will be created from the list of parameters to the generated :meth:"

"`~object.__init__` method (even if :meth:`~object.__init__` is not "

"generated, see above). If false, or if ``__match_args__`` is already "

"defined in the class, then ``__match_args__`` will not be generated."

msgstr ""

"*match_args* : si vrai (``True`` est la valeur par défaut), le *n*-uplet "

"``__match_args__`` est créé automatiquement depuis la liste des paramètres "

"de la méthode :meth:`__init__` générée (même si :meth:`__init__` n'est pas "

"générée, voir ci-dessus). Si faux ou si ``__match_args__`` est déjà défini "

"dans la classe alors ``__match_args__`` n'est pas créé."

#: library/dataclasses.rst:174

#, fuzzy

msgid ""

"``kw_only``: If true (the default value is ``False``), then all fields will "

"be marked as keyword-only. If a field is marked as keyword-only, then the "

"only effect is that the :meth:`~object.__init__` parameter generated from a "

"keyword-only field must be specified with a keyword when :meth:`~object."

"__init__` is called. There is no effect on any other aspect of "

"dataclasses. See the :term:`parameter` glossary entry for details. Also "

"see the :const:`KW_ONLY` section."

msgstr ""

"*kw_only* : si vrai (``False`` est la valeur par défaut) alors tous les "

"champs sont marqués comme exclusivement nommés. Si un champ est marqué comme "

"exclusivement nommé, le seul impact est que le champ de la méthode :meth:"

"`__init__` générée devra être explicitement nommé lors de l'appel de la "

"méthode :meth:`__init__`. Il n'y a aucun autre effet dans les autres aspects "

"des classes de données. Voir l'entrée :term:`paramètre <parameter>` du "

"glossaire pour plus d'informations. Voir également la section :const:"

"`KW_ONLY`."

#: library/dataclasses.rst:185

#, fuzzy

msgid ""

"``slots``: If true (the default is ``False``), :attr:`~object.__slots__` "

"attribute will be generated and new class will be returned instead of the "

"original one. If :attr:`~object.__slots__` is already defined in the class, "

"then :exc:`TypeError` is raised."

msgstr ""

"*slot* : si vrai (``False`` est la valeur par défaut), l'attribut :attr:"

"`__slots__` est généré et une nouvelle classe est renvoyée à la place de "

"celle d'origine. Si :attr:`__slots__` est déjà défini dans la classe alors "

"une :exc:`TypeError` est levée."

#: library/dataclasses.rst:192

#, fuzzy

msgid ""

"If a field name is already included in the ``__slots__`` of a base class, it "

"will not be included in the generated ``__slots__`` to prevent :ref:"

"`overriding them <datamodel-note-slots>`. Therefore, do not use "

"``__slots__`` to retrieve the field names of a dataclass. Use :func:`fields` "

"instead. To be able to determine inherited slots, base class ``__slots__`` "

"may be any iterable, but *not* an iterator."

msgstr ""

"Si un nom de champ est déjà inclus dans le ``__slots__`` d'une classe mère, "

"il n'est pas inclus dans les ``__slots__`` générés pour éviter de :ref:`les "

"remplacer <datamodel-note-slots>`. Par conséquent, n'utilisez pas "

"``__slots__`` pour récupérer les noms de champ d'une classe de données. "

"Utilisez :func:`fields` à la place. Pour pouvoir déterminer les *slots* "

"hérités, ``__slots__`` de la classe mère peut être n'importe quel itérable, "

"mais *pas* un itérateur."

#: library/dataclasses.rst:202

msgid ""

"``weakref_slot``: If true (the default is ``False``), add a slot named "

"\"__weakref__\", which is required to make an instance weakref-able. It is "

"an error to specify ``weakref_slot=True`` without also specifying "

"``slots=True``."

msgstr ""

"``weakref_slot`` : s'il est vrai (la valeur par défaut est ``False``), "

"ajoute un *slot* nommé ``\"__weakref__\"``, ce qui est nécessaire pour "

"pouvoir référencer faiblement une instance. C'est une erreur de spécifier "

"``weakref_slot=True`` sans spécifier également ``slots=True``."

#: library/dataclasses.rst:209

msgid ""

"``field``\\s may optionally specify a default value, using normal Python "

"syntax::"

msgstr ""

"Les champs peuvent éventuellement préciser une valeur par défaut, en "

"utilisant la syntaxe Python normale ::"

#: library/dataclasses.rst:217

#, fuzzy

msgid ""

"In this example, both ``a`` and ``b`` will be included in the added :meth:"

"`~object.__init__` method, which will be defined as::"

msgstr ""

"Dans cet exemple, ``a`` et ``b`` sont tous deux inclus dans la signature de "

"la méthode générée :meth:`__init__`, qui est définie comme suit ::"

#: library/dataclasses.rst:222

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 "

"class, or as a result of class inheritance."

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 ou si c’est le résultat d’un héritage de classes."

#: library/dataclasses.rst:228

msgid ""

"For common and simple use cases, no other functionality is required. There "

"are, however, some dataclass features that require additional per-field "

"information. To satisfy this need for additional information, you can "

"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:241

msgid ""

"As shown above, the :const:`MISSING` value is a sentinel object used to "

"detect if some parameters are provided by the user. This sentinel is used "

"because ``None`` is a valid value for some parameters with a distinct "

"meaning. No code should directly use the :const:`MISSING` value."

msgstr ""

"Comme le montre la signature, la constante :const:`MISSING` est une valeur "

"sentinelle pour déterminer si des paramètres ont été fournis par "

"l'utilisateur. ``None`` ne conviendrait pas puisque c'est une valeur avec un "

"sens qui peut être différent pour certains paramètres. La sentinelle :const:"

"`MISSING` est interne au module et ne doit pas être utilisée dans vos "

"programmes."

#: library/dataclasses.rst:246

msgid "The parameters to :func:`field` are:"

msgstr "Les paramètres de :func:`field` sont :"

#: library/dataclasses.rst:248

msgid ""

"``default``: If provided, this will be the default value for this field. "

"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:252

msgid ""

"``default_factory``: If provided, it must be a zero-argument callable that "

"will be called when a default value is needed for this field. Among other "

"purposes, this can be used to specify fields with mutable default values, as "

"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 mutables. Une erreur se produit si *default* et "

"*default_factory* sont donnés tous les deux."

#: library/dataclasses.rst:258

#, fuzzy

msgid ""

"``init``: If true (the default), this field is included as a parameter to "

"the generated :meth:`~object.__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:261

#, fuzzy

msgid ""

"``repr``: If true (the default), this field is included in the string "

"returned by the generated :meth:`~object.__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:264

#, fuzzy

msgid ""

"``hash``: This can be a bool or ``None``. If true, this field is included "

"in the generated :meth:`~object.__hash__` method. If ``None`` (the "

"default), use the value of ``compare``: this would normally be the expected "

"behavior. A 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:271

msgid ""

"One possible reason to set ``hash=False`` but ``compare=True`` would be if a "

"field is expensive to compute a hash value for, that field is needed for "

"equality testing, and there are other fields that contribute to the type's "

"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:277

#, fuzzy

msgid ""

"``compare``: If true (the default), this field is included in the generated "

"equality and comparison methods (:meth:`~object.__eq__`, :meth:`~object."

"__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:281

msgid ""

"``metadata``: This can be a mapping or None. None is treated as an empty "

"dict. This value is wrapped in :func:`~types.MappingProxyType` to make it "

"read-only, and exposed on the :class:`Field` object. It is not used at all "

"by Data Classes, and is provided as a third-party extension mechanism. "

"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:289

#, fuzzy

msgid ""

"``kw_only``: If true, this field will be marked as keyword-only. This is "

"used when the generated :meth:`~object.__init__` method's parameters are "

"computed."

msgstr ""

"``kw_only`` : s'il est vrai, ce champ est marqué comme exclusivement nommé. "

"Cela est utilisé lors du traitement des paramètres de la méthode :meth:"

"`__init__` générée."

#: library/dataclasses.rst:295

msgid ""

"If the default value of a field is specified by a call to :func:`field()`, "

"then the class attribute for this field will be replaced by the specified "

"``default`` value. If no ``default`` is provided, then the class attribute "

"will be deleted. The intent is that after the :func:`dataclass` decorator "

"runs, the class attributes will all contain the default values for the "

"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:311

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:317

msgid ""

":class:`Field` objects describe each defined field. These objects are "

"created internally, and are returned by the :func:`fields` module-level "

"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:322

msgid "``name``: The name of the field."

msgstr "*name* : le nom du champ ;"

#: library/dataclasses.rst:324

msgid "``type``: The type of the field."

msgstr "*type* : le type associé au champ par l'annotation ;"

#: library/dataclasses.rst:326

msgid ""

"``default``, ``default_factory``, ``init``, ``repr``, ``hash``, ``compare``, "

"``metadata``, and ``kw_only`` have the identical meaning and values as they "

"do in the :func:`field` function."

msgstr ""

"``default``, ``default_factory``, ``init``, ``repr``, ``hash``, ``compare``, "

"``metadata`` et ``kw_only`` qui correspondent aux paramètres de :func:"

"`field` et en prennent les valeurs."

#: library/dataclasses.rst:330

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:335

msgid ""

"Returns a tuple of :class:`Field` objects that define the fields for this "

"dataclass. Accepts either a dataclass, or an instance of a dataclass. "

"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:342

msgid ""

"Converts the dataclass ``obj`` to a dict (by using the factory function "

"``dict_factory``). Each dataclass is converted to a dict of its fields, as "

"``name: value`` pairs. dataclasses, dicts, lists, and tuples are recursed "

"into. Other objects are copied with :func:`copy.deepcopy`."

msgstr ""

"Convertit la classe de données ``obj`` en un dictionnaire (en utilisant 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 parcourus récursivement. Les autres objets sont copiés avec :"

"func:`copy.deepcopy`."

#: library/dataclasses.rst:348

msgid "Example of using :func:`asdict` on nested dataclasses::"

msgstr ""

"Exemple d'utilisation de :func:`asdict` sur des classes de données "

"imbriquées ::"

#: library/dataclasses.rst:385

msgid "To create a shallow copy, the following workaround may be used::"

msgstr ""

"Pour créer une copie superficielle, la solution de contournement suivante "

"peut être utilisée ::"

#: library/dataclasses.rst:369

msgid ""

":func:`asdict` raises :exc:`TypeError` if ``obj`` is not a dataclass "

"instance."

msgstr ""

":func:`asdict` lève :exc:`TypeError` si ``obj`` n'est pas une instance d'une "

"classe de données."

#: library/dataclasses.rst:374

msgid ""

"Converts the dataclass ``obj`` to a tuple (by using the factory function "

"``tuple_factory``). Each dataclass is converted to a tuple of its field "

"values. dataclasses, dicts, lists, and tuples are recursed into. Other "

"objects are copied with :func:`copy.deepcopy`."

msgstr ""

"Convertit l'instance d'une classe de données ``obj`` en un *n*-uplet (en "

"utilisant la fonction ``tuple_factory``). Chaque classe de données est "

"convertie vers un *n*-uplet des valeurs de ses champs. Cette fonction agit "

"récursivement sur les dictionnaires, listes et *n*-uplets. Les autres objets "

"sont copiés avec :func:`copy.deepcopy`."

#: library/dataclasses.rst:380

msgid "Continuing from the previous example::"

msgstr "Pour continuer l'exemple précédent ::"

#: library/dataclasses.rst:389

msgid ""

":func:`astuple` raises :exc:`TypeError` if ``obj`` is not a dataclass "

"instance."

msgstr ""

":func:`astuple` lève :exc:`TypeError` si ``obj`` n'est pas une instance "

"d'une classe de données."

#: library/dataclasses.rst:394

msgid ""

"Creates a new dataclass with name ``cls_name``, fields as defined in "

"``fields``, base classes as given in ``bases``, and initialized with a "

"namespace as given in ``namespace``. ``fields`` is an iterable whose "

"elements are each either ``name``, ``(name, type)``, or ``(name, type, "

"Field)``. If just ``name`` is supplied, ``typing.Any`` is used for "

"``type``. The values of ``init``, ``repr``, ``eq``, ``order``, "

"``unsafe_hash``, ``frozen``, ``match_args``, ``kw_only``, ``slots``, and "

"``weakref_slot`` 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 ``fields``. Les classes mères sont lues dans ``bases``. "

"L'espace de nommage de la classe est initialisé par ``namespace``. "

"``fields`` est un itérable dont les éléments sont individuellement de la "

"forme ``name``, ``(name:type)`` ou ``(name, type, Field)``. Si seul ``name`` "

"est fourni, ``typing.Any`` est utilisé pour ``type``. Les valeurs de "

"``init``, ``repr``, ``eq``, ``order``, ``unsafe_hash``, ``frozen``, "

"``match_args``, ``kw_only``, ``slots`` et ``weakref_slot`` ont la même "

"signification que dans :func:`dataclass`."

#: library/dataclasses.rst:404

msgid ""

"This function is not strictly required, because any Python mechanism for "

"creating a new class with ``__annotations__`` can then apply the :func:"

"`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:416

msgid "Is equivalent to::"

msgstr "est équivalent à ::"

#: library/dataclasses.rst:429

msgid ""

"Creates a new object of the same type as ``obj``, replacing fields with "

"values from ``changes``. If ``obj`` is not a Data Class, raises :exc:"

"`TypeError`. If values in ``changes`` do not specify fields, raises :exc:"

"`TypeError`."

msgstr ""

"Crée un nouvel objet du même type que ``obj`` en affectant aux champs les "

"valeurs données par ``changes``. Si ``obj`` n'est pas une classe de "

"données, :exc:`TypeError` est levée. Si une clé dans ``changes`` ne "

"correspond à aucun champ de l'instance, :exc:`TypeError` est levée."

#: library/dataclasses.rst:434

#, fuzzy

msgid ""

"The newly returned object is created by calling the :meth:`~object.__init__` "

"method of the dataclass. This ensures that :ref:`__post_init__ <post-init-"

"processing>`, 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:438

#, fuzzy

msgid ""

"Init-only variables without default values, if any exist, must be specified "

"on the call to :func:`replace` so that they can be passed to :meth:`~object."

"__init__` and :ref:`__post_init__ <post-init-processing>`."

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:442

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:446

#, fuzzy

msgid ""

"Be forewarned about how ``init=False`` fields work during a call to :func:"

"`replace`. They are not copied from the source object, but rather are "

"initialized in :ref:`__post_init__ <post-init-processing>`, if they're "

"initialized at all. It is expected that ``init=False`` fields will be "

"rarely and judiciously used. If they are used, it might be wise to have "

"alternate class constructors, or 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:457

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:460

msgid ""

"If you need to know if a class is an instance of a dataclass (and not a "

"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:469

msgid "A sentinel value signifying a missing default or default_factory."

msgstr ""

"Une valeur sentinelle pour dénoter l'absence de *default* ou "

"*default_factory*."

#: library/dataclasses.rst:473

#, fuzzy

msgid ""

"A sentinel value used as a type annotation. Any fields after a pseudo-field "

"with the type of :const:`KW_ONLY` are marked as keyword-only fields. Note "

"that a pseudo-field of type :const:`KW_ONLY` is otherwise completely "

"ignored. This includes the name of such a field. By convention, a name of "

"``_`` is used for a :const:`KW_ONLY` field. Keyword-only fields signify :"

"meth:`~object.__init__` parameters that must be specified as keywords when "

"the class is instantiated."

msgstr ""

"Une valeur sentinelle utilisée en tant qu'annotation de type. Chaque "

"attribut situé après un pseudo-champ ayant pour type la constante :const:"

"`KW_ONLY` est marqué comme champ exclusivement nommé. Notez que le pseudo-"

"champ ayant pour type la constante :const:`KW_ONLY` est par ailleurs "

"complètement ignoré. Par convention le nom ``_`` est utilisé pour "

"l'attribut :const:`KW_ONLY`. Les paramètres de la méthode :meth:`__init__` "

"exclusivement nommés doivent être spécifiés par leur nom lors de "

"l'instanciation de la classe."

#: library/dataclasses.rst:482

msgid ""

"In this example, the fields ``y`` and ``z`` will be marked as keyword-only "

"fields::"

msgstr ""

"Dans cet exemple ``y`` et ``z`` sont marqués comme exclusivement nommés ::"

#: library/dataclasses.rst:493

msgid ""

"In a single dataclass, it is an error to specify more than one field whose "

"type is :const:`KW_ONLY`."

msgstr ""

"Une erreur est levée s'il y a plus d'un champ de type :const:`KW_ONLY` dans "

"une unique classe de données."

#: library/dataclasses.rst:500

#, fuzzy

msgid ""

"Raised when an implicitly defined :meth:`~object.__setattr__` or :meth:"

"`~object.__delattr__` 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``."

#: library/dataclasses.rst:507

msgid "Post-init processing"

msgstr "Post-initialisation"

#: library/dataclasses.rst:509

#, fuzzy

msgid ""

"The generated :meth:`~object.__init__` code will call a method named :meth:`!"

"__post_init__`, if :meth:`!__post_init__` is defined on the class. It will "

"normally be called as ``self.__post_init__()``. However, if any ``InitVar`` "

"fields are defined, they will also be passed to :meth:`!__post_init__` in "

"the order they were defined in the class. If no :meth:`~object.__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:517

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:529

#, fuzzy

msgid ""

"The :meth:`~object.__init__` method generated by :func:`dataclass` does not "

"call base class :meth:`~object.__init__` methods. If the base class has an :"

"meth:`~object.__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:546

#, fuzzy

msgid ""

"Note, however, that in general the dataclass-generated :meth:`~object."

"__init__` 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:550

#, fuzzy

msgid ""

"See the section below on init-only variables for ways to pass parameters to :"

"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:555

msgid "Class variables"

msgstr "Variables de classe"

#: library/dataclasses.rst:557

#, fuzzy

msgid ""

"One of the few places where :func:`dataclass` actually inspects the type of "

"a field is to determine if a field is a class variable as defined in :pep:"

"`526`. It does this by checking if the type of the field is ``typing."

"ClassVar``. If a field is a ``ClassVar``, it is excluded from consideration "

"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:566

msgid "Init-only variables"

msgstr "Variables d'initialisation"

#: library/dataclasses.rst:568

#, fuzzy

msgid ""

"Another place where :func:`dataclass` inspects a type annotation is to "

"determine if a field is an init-only variable. It does this by seeing if "

"the type of a field is of type ``dataclasses.InitVar``. If a field is an "

"``InitVar``, it is considered a pseudo-field called an init-only field. As "

"it is not a true field, it is not returned by the module-level :func:"

"`fields` function. Init-only fields are added as parameters to the "

"generated :meth:`~object.__init__` method, and are passed to the optional :"

"ref:`__post_init__ <post-init-processing>` 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:578

msgid ""

"For example, suppose a field will be initialized from a database, if a value "

"is not provided when creating the class::"

msgstr ""