# 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: 2020-10-01 16:00+0200\n" "PO-Revision-Date: 2018-12-24 14:53+0100\n" "Last-Translator: Julien Palard \n" "Language-Team: FRENCH \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" #: 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 msgid "" "This module provides a decorator and functions for automatically adding " "generated :term:`special method`\\s such as :meth:`__init__` and :meth:" "`__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 ` 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, ce code ::" #: library/dataclasses.rst:34 msgid "Will add, among other things, a :meth:`__init__` that looks like::" msgstr "" "Ajoute, 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 pas à écrire dans la définition de ``InventoryItem`` " "ci-dessus." #: library/dataclasses.rst:47 msgid "Module-level decorators, classes, and functions" msgstr "Décorateurs, classes et fonctions au niveau 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 ` générées aux classes, comme " "décrit ci-dessous." #: library/dataclasses.rst:54 msgid "" "The :func:`dataclass` decorator examines the class to find ``field``\\s. A " "``field`` is defined as class variable that has a :term:`type 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 `. À 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." #: 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 #, fuzzy msgid "" "The :func:`dataclass` decorator will add various \"dunder\" methods to the " "class, described below. If any of the added methods already exist on the " "class, the behavior depends on the parameter, as documented below. The " "decorator returns the same class that 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, 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." #: 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é 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 " "équivalents ::" #: library/dataclasses.rst:86 msgid "The parameters to :func:`dataclass` are:" msgstr "Les paramètres de :func:`dataclass` sont :" #: 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." #: library/dataclasses.rst:91 msgid "" "If the class already defines :meth:`__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:94 msgid "" "``repr``: If true (the default), a :meth:`__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__` 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)``." #: library/dataclasses.rst:101 msgid "" "If the class already defines :meth:`__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:104 msgid "" "``eq``: If true (the default), an :meth:`__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 s’il s’agissait " "d’un tuple de ses champs, dans l’ordre. Les deux instances dans la " "comparaison doivent être de même type." #: library/dataclasses.rst:109 msgid "If the class already defines :meth:`__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:112 msgid "" "``order``: If true (the default is ``False``), :meth:`__lt__`, :meth:" "`__le__`, :meth:`__gt__`, and :meth:`__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 tuples, 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 ``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." 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:123 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``." #: library/dataclasses.rst:126 msgid "" ":meth:`__hash__` is used by built-in :meth:`hash()`, and when objects are " "added to hashed collections such as dictionaries and sets. Having a :meth:" "`__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:`__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épends 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:133 msgid "" "By default, :func:`dataclass` will not implicitly add a :meth:`__hash__` " "method unless it is safe to do so. Neither will it add or change an " "existing explicitly defined :meth:`__hash__` method. Setting the class " "attribute ``__hash__ = None`` has a specific meaning to Python, as described " "in the :meth:`__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 est 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__`." #: library/dataclasses.rst:139 msgid "" "If :meth:`__hash__` is not explicit defined, or if it is set to ``None``, " "then :func:`dataclass` *may* add an implicit :meth:`__hash__` method. " "Although not recommended, you can force :func:`dataclass` to create a :meth:" "`__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. C’est " "un cas très particulier qui doit être considéré avec la plus grande prudence." #: library/dataclasses.rst:146 msgid "" "Here are the rules governing implicit creation of a :meth:`__hash__` " "method. Note that you cannot both have an explicit :meth:`__hash__` method " "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:" "`__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`." #: library/dataclasses.rst:151 msgid "" "If ``eq`` and ``frozen`` are both true, by default :func:`dataclass` will " "generate a :meth:`__hash__` method for you. If ``eq`` is true and " "``frozen`` is false, :meth:`__hash__` will be set to ``None``, marking it " "unhashable (which it is, since it is mutable). If ``eq`` is false, :meth:" "`__hash__` will be left untouched meaning the :meth:`__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, 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)." #: 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 " "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:164 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 " "utilisant la syntaxe Python normale ::" #: library/dataclasses.rst:172 msgid "" "In this example, both ``a`` and ``b`` will be included in the added :meth:" "`__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:177 msgid "" ":exc:`TypeError` will be raised if a field without a default value follows a " "field with a default value. This is true either when 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, mais également si c’est le résultat d’un héritage de " "classes." #: library/dataclasses.rst:183 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 "" #: library/dataclasses.rst:196 msgid "" "As shown above, the ``MISSING`` value is a sentinel object used to detect if " "the ``default`` and ``default_factory`` parameters are provided. This " "sentinel is used because ``None`` is a valid value for ``default``. No code " "should directly use the ``MISSING`` value." msgstr "" #: library/dataclasses.rst:202 msgid "The parameters to :func:`field` are:" msgstr "" #: library/dataclasses.rst:204 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 "" #: library/dataclasses.rst:208 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 "" #: library/dataclasses.rst:214 msgid "" "``init``: If true (the default), this field is included as a parameter to " "the generated :meth:`__init__` method." msgstr "" #: 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 "" #: 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 "" #: library/dataclasses.rst:224 msgid "" "``hash``: This can be a bool or ``None``. If true, this field is included " "in the generated :meth:`__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 "" #: library/dataclasses.rst:231 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 "" #: library/dataclasses.rst:237 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 "" #: library/dataclasses.rst:245 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 "" #: 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 "" #: library/dataclasses.rst:267 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 "" #: library/dataclasses.rst:272 msgid "``name``: The name of the field." msgstr "" #: library/dataclasses.rst:274 msgid "``type``: The type of the field." msgstr "" #: library/dataclasses.rst:276 msgid "" "``default``, ``default_factory``, ``init``, ``repr``, ``hash``, ``compare``, " "and ``metadata`` have the identical meaning and values as they do in the :" "func:`field` declaration." msgstr "" #: library/dataclasses.rst:280 msgid "" "Other attributes may exist, but they are private and must not be inspected " "or relied on." msgstr "" #: library/dataclasses.rst:285 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 "" #: library/dataclasses.rst:292 msgid "" "Converts the dataclass ``instance`` 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. For example::" msgstr "" #: library/dataclasses.rst:326 msgid "Raises :exc:`TypeError` if ``instance`` is not a dataclass instance." msgstr "" #: library/dataclasses.rst:316 msgid "" "Converts the dataclass ``instance`` 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." msgstr "" #: library/dataclasses.rst:321 msgid "Continuing from the previous example::" msgstr "" #: library/dataclasses.rst:330 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``, and ``frozen`` have the same meaning as they do in :func:" "`dataclass`." msgstr "" #: library/dataclasses.rst:339 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 "" #: library/dataclasses.rst:351 msgid "Is equivalent to::" msgstr "" #: library/dataclasses.rst:364 msgid "" "Creates a new object of the same type of ``instance``, replacing fields with " "values from ``changes``. If ``instance`` is not a Data Class, raises :exc:" "`TypeError`. If values in ``changes`` do not specify fields, raises :exc:" "`TypeError`." msgstr "" #: library/dataclasses.rst:369 msgid "" "The newly returned object is created by calling the :meth:`__init__` method " "of the dataclass. This ensures that :meth:`__post_init__`, if present, is " "also called." msgstr "" #: library/dataclasses.rst:373 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:" "`__init__` and :meth:`__post_init__`." msgstr "" #: 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 "" #: library/dataclasses.rst:381 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 :meth:`__post_init__`, 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 "" #: library/dataclasses.rst:392 msgid "" "Return ``True`` if its parameter is a dataclass or an instance of one, " "otherwise return ``False``." msgstr "" #: library/dataclasses.rst:395 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 "" #: library/dataclasses.rst:403 msgid "Post-init processing" msgstr "" #: library/dataclasses.rst:405 msgid "" "The generated :meth:`__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:`__init__` method is " "generated, then :meth:`__post_init__` will not automatically be called." msgstr "" #: 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 "" #: library/dataclasses.rst:425 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 "" #: library/dataclasses.rst:430 msgid "Class variables" msgstr "" #: library/dataclasses.rst:432 msgid "" "One of two 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 "" #: library/dataclasses.rst:441 msgid "Init-only variables" msgstr "" #: library/dataclasses.rst:443 msgid "" "The other 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:`__init__` method, and are passed to the optional :meth:" "`__post_init__` method. They are not otherwise used by dataclasses." msgstr "" #: library/dataclasses.rst:453 msgid "" "For example, suppose a field will be initialized from a database, if a value " "is not provided when creating the class::" msgstr "" #: library/dataclasses.rst:468 msgid "" "In this case, :func:`fields` will return :class:`Field` objects for ``i`` " "and ``j``, but not for ``database``." msgstr "" #: library/dataclasses.rst:472 msgid "Frozen instances" msgstr "" #: library/dataclasses.rst:474 msgid "" "It is not possible to create truly immutable Python objects. However, by " "passing ``frozen=True`` to the :meth:`dataclass` decorator you can emulate " "immutability. In that case, dataclasses will add :meth:`__setattr__` and :" "meth:`__delattr__` methods to the class. These methods will raise a :exc:" "`FrozenInstanceError` when invoked." msgstr "" #: library/dataclasses.rst:480 msgid "" "There is a tiny performance penalty when using ``frozen=True``: :meth:" "`__init__` cannot use simple assignment to initialize fields, and must use :" "meth:`object.__setattr__`." msgstr "" #: library/dataclasses.rst:485 msgid "Inheritance" msgstr "Héritage" #: library/dataclasses.rst:487 msgid "" "When the dataclass is being created by the :meth:`dataclass` decorator, it " "looks through all of the class's base classes in reverse MRO (that is, " "starting at :class:`object`) and, for each dataclass that it finds, adds the " "fields from that base class to an ordered mapping of fields. After all of " "the base class fields are added, it adds its own fields to the ordered " "mapping. All of the generated methods will use this combined, calculated " "ordered mapping of fields. Because the fields are in insertion order, " "derived classes override base classes. An example::" msgstr "" #: library/dataclasses.rst:507 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 "" #: library/dataclasses.rst:510 msgid "The generated :meth:`__init__` method for ``C`` will look like::" msgstr "" #: library/dataclasses.rst:515 msgid "Default factory functions" msgstr "" #: library/dataclasses.rst:517 msgid "" "If a :func:`field` specifies a ``default_factory``, it is called with zero " "arguments when a default value for the field is needed. For example, to " "create a new instance of a list, use::" msgstr "" #: library/dataclasses.rst:523 msgid "" "If a field is excluded from :meth:`__init__` (using ``init=False``) and the " "field also specifies ``default_factory``, then the default factory function " "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 "" #: library/dataclasses.rst:530 msgid "Mutable default values" msgstr "" #: library/dataclasses.rst:532 msgid "" "Python stores default member variable values in class attributes. Consider " "this example, not using dataclasses::" msgstr "" #: library/dataclasses.rst:547 msgid "" "Note that the two instances of class ``C`` share the same class variable " "``x``, as expected." msgstr "" #: library/dataclasses.rst:550 msgid "Using dataclasses, *if* this code was valid::" msgstr "" #: library/dataclasses.rst:558 msgid "it would generate code similar to::" msgstr "" #: library/dataclasses.rst:569 msgid "" "This has the same issue as the original example using class ``C``. That is, " "two instances of class ``D`` that do not specify a value for ``x`` when " "creating a class instance will share the same copy of ``x``. Because " "dataclasses just use normal Python class creation they also share this " "behavior. There is no general way for Data Classes to detect this " "condition. Instead, dataclasses will raise a :exc:`TypeError` if it detects " "a default parameter of type ``list``, ``dict``, or ``set``. This is a " "partial solution, but it does protect against many common errors." msgstr "" #: library/dataclasses.rst:579 msgid "" "Using default factory functions is a way to create new instances of mutable " "types as default values for fields::" msgstr "" #: library/dataclasses.rst:589 msgid "Exceptions" msgstr "Exceptions" #: library/dataclasses.rst:593 msgid "" "Raised when an implicitly defined :meth:`__setattr__` or :meth:`__delattr__` " "is called on a dataclass which was defined with ``frozen=True``." msgstr ""