# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001 Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # # Translators: # Rafael Fontenelle , 2025 # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.14\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2025-06-13 14:21+0000\n" "PO-Revision-Date: 2025-07-18 18:48+0000\n" "Last-Translator: Rafael Fontenelle , 2025\n" "Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Language: pl\n" "Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && " "(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && " "n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n" msgid ":mod:`!dataclasses` --- Data Classes" msgstr "" msgid "**Source code:** :source:`Lib/dataclasses.py`" msgstr "**Вихідний код:** :source:`Lib/dataclasses.py`" msgid "" "This module provides a decorator and functions for automatically adding " "generated :term:`special methods ` such as :meth:`~object." "__init__` and :meth:`~object.__repr__` to user-defined classes. It was " "originally described in :pep:`557`." msgstr "" msgid "" "The member variables to use in these generated methods are defined using :" "pep:`526` type annotations. For example, this code::" msgstr "" "Змінні-члени для використання в цих згенерованих методах визначаються за " "допомогою анотацій типу :pep:`526`. Наприклад, цей код::" msgid "" "from dataclasses import dataclass\n" "\n" "@dataclass\n" "class InventoryItem:\n" " \"\"\"Class for keeping track of an item in inventory.\"\"\"\n" " name: str\n" " unit_price: float\n" " quantity_on_hand: int = 0\n" "\n" " def total_cost(self) -> float:\n" " return self.unit_price * self.quantity_on_hand" msgstr "" msgid "will add, among other things, a :meth:`!__init__` that looks like::" msgstr "" msgid "" "def __init__(self, name: str, unit_price: float, quantity_on_hand: int = " "0):\n" " self.name = name\n" " self.unit_price = unit_price\n" " self.quantity_on_hand = quantity_on_hand" msgstr "" msgid "" "Note that this method is automatically added to the class: it is not " "directly specified in the :class:`!InventoryItem` definition shown above." msgstr "" msgid "Module contents" msgstr "Зміст модуля" msgid "" "This function is a :term:`decorator` that is used to add generated :term:" "`special methods ` to classes, as described below." msgstr "" msgid "" "The ``@dataclass`` decorator examines the class to find ``field``\\s. A " "``field`` is defined as a class variable that has a :term:`type annotation " "`. With two exceptions described below, nothing in " "``@dataclass`` examines the type specified in the variable annotation." msgstr "" msgid "" "The order of the fields in all of the generated methods is the order in " "which they appear in the class definition." msgstr "" "Порядок полів у всіх згенерованих методах – це порядок, у якому вони " "з’являються у визначенні класу." msgid "" "The ``@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 "" msgid "" "If ``@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 ``@dataclass`` are equivalent::" msgstr "" msgid "" "@dataclass\n" "class C:\n" " ...\n" "\n" "@dataclass()\n" "class C:\n" " ...\n" "\n" "@dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, " "frozen=False,\n" " match_args=True, kw_only=False, slots=False, weakref_slot=False)\n" "class C:\n" " ..." msgstr "" msgid "The parameters to ``@dataclass`` are:" msgstr "" msgid "" "*init*: If true (the default), a :meth:`~object.__init__` method will be " "generated." msgstr "" msgid "" "If the class already defines :meth:`!__init__`, this parameter is ignored." msgstr "" 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 "" msgid "" "If the class already defines :meth:`!__repr__`, this parameter is ignored." msgstr "" 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 "" msgid "" "If the class already defines :meth:`!__eq__`, this parameter is ignored." msgstr "" 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 "" msgid "" "If the class already defines any of :meth:`!__lt__`, :meth:`!__le__`, :meth:" "`!__gt__`, or :meth:`!__ge__`, then :exc:`TypeError` is raised." msgstr "" msgid "" "*unsafe_hash*: If true, force ``dataclasses`` to create a :meth:`~object." "__hash__` method, even though it may not be safe to do so. Otherwise, " "generate a :meth:`~object.__hash__` method according to how *eq* and " "*frozen* are set. The default value is ``False``." msgstr "" 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 ``@dataclass`` decorator." msgstr "" msgid "" "By default, ``@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:`!__hash__` method. Setting the class " "attribute ``__hash__ = None`` has a specific meaning to Python, as described " "in the :meth:`!__hash__` documentation." msgstr "" msgid "" "If :meth:`!__hash__` is not explicitly defined, or if it is set to ``None``, " "then ``@dataclass`` *may* add an implicit :meth:`!__hash__` method. Although " "not recommended, you can force ``@dataclass`` to create a :meth:`!__hash__` " "method with ``unsafe_hash=True``. This might be the case if your class is " "logically immutable but can still be mutated. This is a specialized use case " "and should be considered carefully." msgstr "" 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 "" msgid "" "If *eq* and *frozen* are both true, by default ``@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 "" 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 "" msgid "" "*match_args*: If true (the default is ``True``), the :attr:`~object." "__match_args__` tuple will be created from the list of non keyword-only " "parameters to the generated :meth:`~object.__init__` method (even if :meth:`!" "__init__` is not generated, see above). If false, or if :attr:`!" "__match_args__` is already defined in the class, then :attr:`!" "__match_args__` will not be generated." msgstr "" 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:`!__init__` " "is called. See the :term:`parameter` glossary entry for details. Also see " "the :const:`KW_ONLY` section." msgstr "" msgid "Keyword-only fields are not included in :attr:`!__match_args__`." msgstr "" 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:`!__slots__` is already defined in the class, then :" "exc:`TypeError` is raised." msgstr "" msgid "" "Passing parameters to a base class :meth:`~object.__init_subclass__` when " "using ``slots=True`` will result in a :exc:`TypeError`. Either use " "``__init_subclass__`` with no parameters or use default values as a " "workaround. See :gh:`91126` for full details." msgstr "" msgid "" "If a field name is already included in the :attr:`!__slots__` of a base " "class, it will not be included in the generated :attr:`!__slots__` to " "prevent :ref:`overriding them `. Therefore, do not " "use :attr:`!__slots__` to retrieve the field names of a dataclass. Use :func:" "`fields` instead. To be able to determine inherited slots, base class :attr:" "`!__slots__` may be any iterable, but *not* an iterator." msgstr "" msgid "" "*weakref_slot*: If true (the default is ``False``), add a slot named " "\"__weakref__\", which is required to make an instance :func:`weakref-able " "`. It is an error to specify ``weakref_slot=True`` without also " "specifying ``slots=True``." msgstr "" msgid "" "``field``\\s may optionally specify a default value, using normal Python " "syntax::" msgstr "" "``field``\\s може додатково вказати значення за замовчуванням, " "використовуючи звичайний синтаксис Python:" msgid "" "@dataclass\n" "class C:\n" " a: int # 'a' has no default value\n" " b: int = 0 # assign a default value for 'b'" msgstr "" msgid "" "In this example, both :attr:`!a` and :attr:`!b` will be included in the " "added :meth:`~object.__init__` method, which will be defined as::" msgstr "" msgid "def __init__(self, a: int, b: int = 0):" msgstr "" 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 "" ":exc:`TypeError` буде викликано, якщо поле без значення за замовчуванням " "слідує за полем зі значенням за замовчуванням. Це вірно незалежно від того, " "чи відбувається це в одному класі, чи в результаті успадкування класу." 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 "" msgid "" "@dataclass\n" "class C:\n" " mylist: list[int] = field(default_factory=list)\n" "\n" "c = C()\n" "c.mylist += [1, 2, 3]" msgstr "" 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 "" msgid "The parameters to :func:`!field` are:" msgstr "" msgid "" "*default*: If provided, this will be the default value for this field. This " "is needed because the :func:`!field` call itself replaces the normal " "position of the default value." msgstr "" 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 "" msgid "" "*init*: If true (the default), this field is included as a parameter to the " "generated :meth:`~object.__init__` method." msgstr "" msgid "" "*repr*: If true (the default), this field is included in the string returned " "by the generated :meth:`~object.__repr__` method." msgstr "" msgid "" "*hash*: This can be a bool or ``None``. If true, this field is included in " "the generated :meth:`~object.__hash__` method. If false, this field is " "excluded from the generated :meth:`~object.__hash__`. If ``None`` (the " "default), use the value of *compare*: this would normally be the expected " "behavior, since a field should be included in the hash if it's used for " "comparisons. Setting this value to anything other than ``None`` is " "discouraged." msgstr "" 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 "" "Однією з можливих причин встановити ``hash=False``, але ``compare=True`` " "було б, якщо поле є дорогим для обчислення хеш-значення, це поле потрібне " "для перевірки рівності, і є інші поля, які сприяють хеш-значення типу. " "Навіть якщо поле виключено з хешу, воно все одно використовуватиметься для " "порівнянь." 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 "" 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 "" 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 "" msgid "Keyword-only fields are also not included in :attr:`!__match_args__`." msgstr "" msgid "*doc*: optional docstring for this field." msgstr "" 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 *default* is not 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 "" msgid "" "@dataclass\n" "class C:\n" " x: int\n" " y: int = field(repr=False)\n" " z: int = field(repr=False, default=10)\n" " t: int = 20" msgstr "" msgid "" "The class attribute :attr:`!C.z` will be ``10``, the class attribute :attr:`!" "C.t` will be ``20``, and the class attributes :attr:`!C.x` and :attr:`!C.y` " "will not be set." msgstr "" 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 "" msgid ":attr:`!name`: The name of the field." msgstr "" msgid ":attr:`!type`: The type of the field." msgstr "" msgid "" ":attr:`!default`, :attr:`!default_factory`, :attr:`!init`, :attr:`!repr`, :" "attr:`!hash`, :attr:`!compare`, :attr:`!metadata`, and :attr:`!kw_only` have " "the identical meaning and values as they do in the :func:`field` function." msgstr "" msgid "" "Other attributes may exist, but they are private and must not be inspected " "or relied on." msgstr "" "Інші атрибути можуть існувати, але вони є приватними, і їх не можна " "перевіряти чи покладатися на них." msgid "" "``InitVar[T]`` type annotations describe variables that are :ref:`init-only " "`. Fields annotated with :class:`!InitVar` " "are considered pseudo-fields, and thus are neither returned by the :func:" "`fields` function nor used in any way except adding them as parameters to :" "meth:`~object.__init__` and an optional :meth:`__post_init__`." msgstr "" 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 "" "Повертає кортеж об’єктів :class:`Field`, які визначають поля для цього класу " "даних. Приймає або клас даних, або екземпляр класу даних. Викликає :exc:" "`TypeError`, якщо не передано клас даних або його екземпляр. Не повертає " "псевдополя, які є ``ClassVar`` або ``InitVar``." 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 "" msgid "Example of using :func:`!asdict` on nested dataclasses::" msgstr "" msgid "" "@dataclass\n" "class Point:\n" " x: int\n" " y: int\n" "\n" "@dataclass\n" "class C:\n" " mylist: list[Point]\n" "\n" "p = Point(10, 20)\n" "assert asdict(p) == {'x': 10, 'y': 20}\n" "\n" "c = C([Point(0, 0), Point(10, 4)])\n" "assert asdict(c) == {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}" msgstr "" msgid "To create a shallow copy, the following workaround may be used::" msgstr "Щоб створити дрібну копію, можна використати такий обхідний шлях:" msgid "{field.name: getattr(obj, field.name) for field in fields(obj)}" msgstr "" msgid "" ":func:`!asdict` raises :exc:`TypeError` if *obj* is not a dataclass instance." msgstr "" 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 "" msgid "Continuing from the previous example::" msgstr "Продовжуючи попередній приклад:" msgid "" "assert astuple(p) == (10, 20)\n" "assert astuple(c) == ([(0, 0), (10, 4)],)" msgstr "" msgid "tuple(getattr(obj, field.name) for field in dataclasses.fields(obj))" msgstr "" msgid "" ":func:`!astuple` raises :exc:`TypeError` if *obj* is not a dataclass " "instance." msgstr "" 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, :data:`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 "" msgid "" "If *module* is defined, the :attr:`!__module__` attribute of the dataclass " "is set to that value. By default, it is set to the module name of the caller." msgstr "" msgid "" "The *decorator* parameter is a callable that will be used to create the " "dataclass. It should take the class object as a first argument and the same " "keyword arguments as :func:`@dataclass `. By default, the :func:" "`@dataclass ` function is used." msgstr "" msgid "" "This function is not strictly required, because any Python mechanism for " "creating a new class with :attr:`!__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 "" msgid "" "C = make_dataclass('C',\n" " [('x', int),\n" " 'y',\n" " ('z', int, field(default=5))],\n" " namespace={'add_one': lambda self: self.x + 1})" msgstr "" msgid "Is equivalent to::" msgstr "Еквівалентно::" msgid "" "@dataclass\n" "class C:\n" " x: int\n" " y: 'typing.Any'\n" " z: int = 5\n" "\n" " def add_one(self):\n" " return self.x + 1" msgstr "" msgid "Added the *decorator* parameter." msgstr "" 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 " "keys in *changes* are not field names of the given dataclass, raises :exc:" "`TypeError`." msgstr "" msgid "" "The newly returned object is created by calling the :meth:`~object.__init__` " "method of the dataclass. This ensures that :meth:`__post_init__`, if " "present, is also called." msgstr "" 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 "" 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 "" 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 :func:`!replace` (or similarly named) method which handles " "instance copying." msgstr "" msgid "" "Dataclass instances are also supported by generic function :func:`copy." "replace`." msgstr "" msgid "" "Return ``True`` if its parameter is a dataclass (including subclasses of a " "dataclass) or an instance of one, otherwise return ``False``." msgstr "" 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 "" "Якщо вам потрібно знати, чи є клас екземпляром класу даних (а не самим " "класом даних), тоді додайте додаткову перевірку для ``not isinstance(obj, " "type)``::" msgid "" "def is_dataclass_instance(obj):\n" " return is_dataclass(obj) and not isinstance(obj, type)" msgstr "" msgid "A sentinel value signifying a missing default or default_factory." msgstr "" 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 "" msgid "" "In this example, the fields ``y`` and ``z`` will be marked as keyword-only " "fields::" msgstr "" msgid "" "@dataclass\n" "class Point:\n" " x: float\n" " _: KW_ONLY\n" " y: float\n" " z: float\n" "\n" "p = Point(0, y=1.5, z=2.0)" msgstr "" msgid "" "In a single dataclass, it is an error to specify more than one field whose " "type is :const:`!KW_ONLY`." msgstr "" 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 "" msgid "Post-init processing" msgstr "Обробка після ініціалізації" msgid "" "When defined on the class, it will be called by the generated :meth:`~object." "__init__`, normally as :meth:`!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 "" msgid "" "Among other uses, this allows for initializing field values that depend on " "one or more other fields. For example::" msgstr "" "Серед іншого використання це дозволяє ініціалізувати значення полів, які " "залежать від одного або кількох інших полів. Наприклад::" msgid "" "@dataclass\n" "class C:\n" " a: float\n" " b: float\n" " c: float = field(init=False)\n" "\n" " def __post_init__(self):\n" " self.c = self.a + self.b" msgstr "" msgid "" "The :meth:`~object.__init__` method generated by :func:`@dataclass " "` does not call base class :meth:`!__init__` methods. If the base " "class has an :meth:`!__init__` method that has to be called, it is common to " "call this method in a :meth:`__post_init__` method::" msgstr "" msgid "" "class Rectangle:\n" " def __init__(self, height, width):\n" " self.height = height\n" " self.width = width\n" "\n" "@dataclass\n" "class Square(Rectangle):\n" " side: float\n" "\n" " def __post_init__(self):\n" " super().__init__(self.side, self.side)" msgstr "" msgid "" "Note, however, that in general the dataclass-generated :meth:`!__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 "" 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 "" msgid "Class variables" msgstr "Змінні класу" 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 :data:`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 "" msgid "Init-only variables" msgstr "Змінні лише для ініціалізації" 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 :class:`InitVar`. If a " "field is an :class:`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 :meth:`__post_init__` method. They are not otherwise used by " "dataclasses." msgstr "" msgid "" "For example, suppose a field will be initialized from a database, if a value " "is not provided when creating the class::" msgstr "" "Наприклад, припустимо, що поле буде ініціалізовано з бази даних, якщо під " "час створення класу не вказано значення::" msgid "" "@dataclass\n" "class C:\n" " i: int\n" " j: int | None = None\n" " database: InitVar[DatabaseType | None] = None\n" "\n" " def __post_init__(self, database):\n" " if self.j is None and database is not None:\n" " self.j = database.lookup('j')\n" "\n" "c = C(10, database=my_database)" msgstr "" msgid "" "In this case, :func:`fields` will return :class:`Field` objects for :attr:`!" "i` and :attr:`!j`, but not for :attr:`!database`." msgstr "" msgid "Frozen instances" msgstr "Заморожені екземпляри" msgid "" "It is not possible to create truly immutable Python objects. However, by " "passing ``frozen=True`` to the :func:`@dataclass ` decorator you " "can emulate immutability. In that case, dataclasses will add :meth:`~object." "__setattr__` and :meth:`~object.__delattr__` methods to the class. These " "methods will raise a :exc:`FrozenInstanceError` when invoked." msgstr "" msgid "" "There is a tiny performance penalty when using ``frozen=True``: :meth:" "`~object.__init__` cannot use simple assignment to initialize fields, and " "must use :meth:`!object.__setattr__`." msgstr "" msgid "Inheritance" msgstr "Dziedziczenie" msgid "" "When the dataclass is being created by the :func:`@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 "" msgid "" "@dataclass\n" "class Base:\n" " x: Any = 15.0\n" " y: int = 0\n" "\n" "@dataclass\n" "class C(Base):\n" " z: int = 10\n" " x: int = 15" msgstr "" msgid "" "The final list of fields is, in order, :attr:`!x`, :attr:`!y`, :attr:`!z`. " "The final type of :attr:`!x` is :class:`int`, as specified in class :class:`!" "C`." msgstr "" msgid "" "The generated :meth:`~object.__init__` method for :class:`!C` will look " "like::" msgstr "" msgid "def __init__(self, x: int = 15, y: int = 0, z: int = 10):" msgstr "" msgid "Re-ordering of keyword-only parameters in :meth:`!__init__`" msgstr "" msgid "" "After the parameters needed for :meth:`~object.__init__` are computed, any " "keyword-only parameters are moved to come after all regular (non-keyword-" "only) parameters. This is a requirement of how keyword-only parameters are " "implemented in Python: they must come after non-keyword-only parameters." msgstr "" msgid "" "In this example, :attr:`!Base.y`, :attr:`!Base.w`, and :attr:`!D.t` are " "keyword-only fields, and :attr:`!Base.x` and :attr:`!D.z` are regular " "fields::" msgstr "" msgid "" "@dataclass\n" "class Base:\n" " x: Any = 15.0\n" " _: KW_ONLY\n" " y: int = 0\n" " w: int = 1\n" "\n" "@dataclass\n" "class D(Base):\n" " z: int = 10\n" " t: int = field(kw_only=True, default=0)" msgstr "" msgid "The generated :meth:`!__init__` method for :class:`!D` will look like::" msgstr "" msgid "" "def __init__(self, x: Any = 15.0, z: int = 10, *, y: int = 0, w: int = 1, t: " "int = 0):" msgstr "" msgid "" "Note that the parameters have been re-ordered from how they appear in the " "list of fields: parameters derived from regular fields are followed by " "parameters derived from keyword-only fields." msgstr "" msgid "" "The relative ordering of keyword-only parameters is maintained in the re-" "ordered :meth:`!__init__` parameter list." msgstr "" msgid "Default factory functions" msgstr "Стандартні заводські функції" 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 "" msgid "mylist: list = field(default_factory=list)" msgstr "" msgid "" "If a field is excluded from :meth:`~object.__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 "" msgid "Mutable default values" msgstr "Змінні значення за замовчуванням" msgid "" "Python stores default member variable values in class attributes. Consider " "this example, not using dataclasses::" msgstr "" "Python зберігає значення змінних членів за замовчуванням в атрибутах класу. " "Розглянемо цей приклад, не використовуючи класи даних::" msgid "" "class C:\n" " x = []\n" " def add(self, element):\n" " self.x.append(element)\n" "\n" "o1 = C()\n" "o2 = C()\n" "o1.add(1)\n" "o2.add(2)\n" "assert o1.x == [1, 2]\n" "assert o1.x is o2.x" msgstr "" msgid "" "Note that the two instances of class :class:`!C` share the same class " "variable :attr:`!x`, as expected." msgstr "" msgid "Using dataclasses, *if* this code was valid::" msgstr "Використання класів даних, *якщо* цей код дійсний::" msgid "" "@dataclass\n" "class D:\n" " x: list = [] # This code raises ValueError\n" " def add(self, element):\n" " self.x.append(element)" msgstr "" msgid "it would generate code similar to::" msgstr "це створить код, подібний до::" msgid "" "class D:\n" " x = []\n" " def __init__(self, x=x):\n" " self.x = x\n" " def add(self, element):\n" " self.x.append(element)\n" "\n" "assert D().x is D().x" msgstr "" msgid "" "This has the same issue as the original example using class :class:`!C`. " "That is, two instances of class :class:`!D` that do not specify a value for :" "attr:`!x` when creating a class instance will share the same copy of :attr:`!" "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, the :func:`@dataclass ` decorator will " "raise a :exc:`ValueError` if it detects an unhashable default parameter. " "The assumption is that if a value is unhashable, it is mutable. This is a " "partial solution, but it does protect against many common errors." msgstr "" msgid "" "Using default factory functions is a way to create new instances of mutable " "types as default values for fields::" msgstr "" "Використання заводських функцій за замовчуванням — це спосіб створення нових " "екземплярів змінних типів як значень за замовчуванням для полів::" msgid "" "@dataclass\n" "class D:\n" " x: list = field(default_factory=list)\n" "\n" "assert D().x is not D().x" msgstr "" msgid "" "Instead of looking for and disallowing objects of type :class:`list`, :class:" "`dict`, or :class:`set`, unhashable objects are now not allowed as default " "values. Unhashability is used to approximate mutability." msgstr "" msgid "Descriptor-typed fields" msgstr "" msgid "" "Fields that are assigned :ref:`descriptor objects ` as their " "default value have the following special behaviors:" msgstr "" msgid "" "The value for the field passed to the dataclass's :meth:`~object.__init__` " "method is passed to the descriptor's :meth:`~object.__set__` method rather " "than overwriting the descriptor object." msgstr "" msgid "" "Similarly, when getting or setting the field, the descriptor's :meth:" "`~object.__get__` or :meth:`!__set__` method is called rather than returning " "or overwriting the descriptor object." msgstr "" msgid "" "To determine whether a field contains a default value, :func:`@dataclass " "` will call the descriptor's :meth:`!__get__` method using its " "class access form: ``descriptor.__get__(obj=None, type=cls)``. If the " "descriptor returns a value in this case, it will be used as the field's " "default. On the other hand, if the descriptor raises :exc:`AttributeError` " "in this situation, no default value will be provided for the field." msgstr "" msgid "" "class IntConversionDescriptor:\n" " def __init__(self, *, default):\n" " self._default = default\n" "\n" " def __set_name__(self, owner, name):\n" " self._name = \"_\" + name\n" "\n" " def __get__(self, obj, type):\n" " if obj is None:\n" " return self._default\n" "\n" " return getattr(obj, self._name, self._default)\n" "\n" " def __set__(self, obj, value):\n" " setattr(obj, self._name, int(value))\n" "\n" "@dataclass\n" "class InventoryItem:\n" " quantity_on_hand: IntConversionDescriptor = " "IntConversionDescriptor(default=100)\n" "\n" "i = InventoryItem()\n" "print(i.quantity_on_hand) # 100\n" "i.quantity_on_hand = 2.5 # calls __set__ with 2.5\n" "print(i.quantity_on_hand) # 2" msgstr "" msgid "" "Note that if a field is annotated with a descriptor type, but is not " "assigned a descriptor object as its default value, the field will act like a " "normal field." msgstr ""