2018-06-28 13:32:56 +00:00
|
|
|
# Copyright (C) 2001-2018, Python Software Foundation
|
2018-07-04 09:08:42 +00:00
|
|
|
# For licence information, see README file.
|
2018-06-28 13:32:56 +00:00
|
|
|
#
|
|
|
|
#, fuzzy
|
|
|
|
msgid ""
|
|
|
|
msgstr ""
|
|
|
|
"Project-Id-Version: Python 3.7\n"
|
|
|
|
"Report-Msgid-Bugs-To: \n"
|
|
|
|
"POT-Creation-Date: 2018-06-28 15:29+0200\n"
|
2018-07-03 09:14:42 +00:00
|
|
|
"PO-Revision-Date: 2018-07-03 10:54+0200\n"
|
|
|
|
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
2018-06-28 13:32:56 +00:00
|
|
|
"Language-Team: LANGUAGE <LL@li.org>\n"
|
|
|
|
"MIME-Version: 1.0\n"
|
|
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
|
|
"Content-Transfer-Encoding: 8bit\n"
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:2
|
|
|
|
msgid ":mod:`dataclasses` --- Data Classes"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:10
|
|
|
|
msgid "**Source code:** :source:`Lib/dataclasses.py`"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:32
|
|
|
|
msgid "Will add, among other things, a :meth:`__init__` that looks like::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:39
|
|
|
|
msgid ""
|
|
|
|
"Note that this method is automatically added to the class: it is not "
|
|
|
|
"directly specified in the ``InventoryItem`` definition shown above."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:45
|
|
|
|
msgid "Module-level decorators, classes, and functions"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:49
|
|
|
|
msgid ""
|
|
|
|
"This function is a :term:`decorator` that is used to add generated :term:"
|
|
|
|
"`special method`\\s to classes, as described below."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:52
|
|
|
|
msgid ""
|
|
|
|
"The :func:`dataclass` decorator examines the class to find ``field``\\s. A "
|
|
|
|
"``field`` is defined as class variable that has a type annotation. With two "
|
|
|
|
"exceptions described below, nothing in :func:`dataclass` examines the type "
|
|
|
|
"specified in the variable annotation."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:58
|
|
|
|
msgid ""
|
|
|
|
"The order of the fields in all of the generated methods is the order in "
|
|
|
|
"which they appear in the class definition."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:61
|
|
|
|
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, a :exc:`TypeError` will be raised. The decorator returns the same "
|
|
|
|
"class that is called on: no new class is created."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:66
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:83
|
|
|
|
msgid "The parameters to :func:`dataclass` are:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:85
|
|
|
|
msgid ""
|
|
|
|
"``init``: If true (the default), a :meth:`__init__` method will be generated."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:88
|
|
|
|
msgid ""
|
|
|
|
"If the class already defines :meth:`__init__`, this parameter is ignored."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:91
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:98
|
|
|
|
msgid ""
|
|
|
|
"If the class already defines :meth:`__repr__`, this parameter is ignored."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:101
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:106
|
|
|
|
msgid "If the class already defines :meth:`__eq__`, this parameter is ignored."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:109
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:116
|
|
|
|
msgid ""
|
|
|
|
"If the class already defines any of :meth:`__lt__`, :meth:`__le__`, :meth:"
|
|
|
|
"`__gt__`, or :meth:`__ge__`, then :exc:`ValueError` is raised."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:120
|
|
|
|
msgid ""
|
|
|
|
"``unsafe_hash``: If ``False`` (the default), a :meth:`__hash__` method is "
|
|
|
|
"generated according to how ``eq`` and ``frozen`` are set."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:123
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:130
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:136
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:143
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:148
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:156
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:161
|
|
|
|
msgid ""
|
|
|
|
"``field``\\s may optionally specify a default value, using normal Python "
|
|
|
|
"syntax::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:169
|
|
|
|
msgid ""
|
|
|
|
"In this example, both ``a`` and ``b`` will be included in the added :meth:"
|
|
|
|
"`__init__` method, which will be defined as::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:174
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:180
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:193
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:199
|
|
|
|
msgid "The parameters to :func:`field` are:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:201
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:205
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:211
|
|
|
|
msgid ""
|
|
|
|
"``init``: If true (the default), this field is included as a parameter to "
|
|
|
|
"the generated :meth:`__init__` method."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:214
|
|
|
|
msgid ""
|
|
|
|
"``repr``: If true (the default), this field is included in the string "
|
|
|
|
"returned by the generated :meth:`__repr__` method."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:217
|
|
|
|
msgid ""
|
|
|
|
"``compare``: If true (the default), this field is included in the generated "
|
|
|
|
"equality and comparison methods (:meth:`__eq__`, :meth:`__gt__`, et al.)."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:221
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:228
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:234
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:242
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:258
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:264
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:269
|
|
|
|
msgid "``name``: The name of the field."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:271
|
|
|
|
msgid "``type``: The type of the field."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:273
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:277
|
|
|
|
msgid ""
|
|
|
|
"Other attributes may exist, but they are private and must not be inspected "
|
|
|
|
"or relied on."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:282
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:289
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:309 ../Doc/library/dataclasses.rst:323
|
|
|
|
msgid "Raises :exc:`TypeError` if ``instance`` is not a dataclass instance."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:313
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:318
|
|
|
|
msgid "Continuing from the previous example::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:327
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:336
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:348
|
|
|
|
msgid "Is equivalent to::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:361
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:366
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:370
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:374
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:378
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:389
|
|
|
|
msgid ""
|
|
|
|
"Returns True if its parameter is a dataclass or an instance of one, "
|
|
|
|
"otherwise returns False."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:392
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:400
|
|
|
|
msgid "Post-init processing"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:402
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:410
|
|
|
|
msgid ""
|
|
|
|
"Among other uses, this allows for initializing field values that depend on "
|
|
|
|
"one or more other fields. For example::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:422
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:427
|
|
|
|
msgid "Class variables"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:429
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:438
|
|
|
|
msgid "Init-only variables"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:440
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:450
|
|
|
|
msgid ""
|
|
|
|
"For example, suppose a field will be initialzed from a database, if a value "
|
|
|
|
"is not provided when creating the class::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:465
|
|
|
|
msgid ""
|
|
|
|
"In this case, :func:`fields` will return :class:`Field` objects for ``i`` "
|
|
|
|
"and ``j``, but not for ``database``."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:469
|
|
|
|
msgid "Frozen instances"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:471
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:477
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:482
|
|
|
|
msgid "Inheritance"
|
2018-07-03 09:14:42 +00:00
|
|
|
msgstr "Héritage"
|
2018-06-28 13:32:56 +00:00
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:484
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:504
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:507
|
|
|
|
msgid "The generated :meth:`__init__` method for ``C`` will look like::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:512
|
|
|
|
msgid "Default factory functions"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:514
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:520
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:527
|
|
|
|
msgid "Mutable default values"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:529
|
|
|
|
msgid ""
|
|
|
|
"Python stores default member variable values in class attributes. Consider "
|
|
|
|
"this example, not using dataclasses::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:544
|
|
|
|
msgid ""
|
|
|
|
"Note that the two instances of class ``C`` share the same class variable "
|
|
|
|
"``x``, as expected."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:547
|
|
|
|
msgid "Using dataclasses, *if* this code was valid::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:555
|
|
|
|
msgid "it would generate code similar to::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:566
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:576
|
|
|
|
msgid ""
|
|
|
|
"Using default factory functions is a way to create new instances of mutable "
|
|
|
|
"types as default values for fields::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:586
|
|
|
|
msgid "Exceptions"
|
2018-07-03 09:14:42 +00:00
|
|
|
msgstr "Exceptions"
|
2018-06-28 13:32:56 +00:00
|
|
|
|
|
|
|
#: ../Doc/library/dataclasses.rst:590
|
|
|
|
msgid ""
|
|
|
|
"Raised when an implicitly defined :meth:`__setattr__` or :meth:`__delattr__` "
|
|
|
|
"is called on a dataclass which was defined with ``frozen=True``."
|
|
|
|
msgstr ""
|