# SOME DESCRIPTIVE TITLE.

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

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-09-22 21:56+0000\n"

"PO-Revision-Date: 2025-09-22 17:54+0000\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: zh_CN\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/dataclasses.rst:2

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

msgstr ":mod:`dataclasses` --- 数据类"

#: ../../library/dataclasses.rst:10

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

msgstr "**源码：** :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 ""

"这个模块提供了一个装饰器和一些函数，用于自动添加生成的 :term:`special method`，例如 :meth:`__init__` 和 "

":meth:`__repr__` 到用户定义的类。 它最初描述于 :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 "在这些生成的方法中使用的成员变量是使用 :pep:`526` 类型标注来定义的。例如以下代码："

#: ../../library/dataclasses.rst:34

msgid "will add, among other things, a :meth:`__init__` that looks like::"

msgstr "将在添加的内容中包括如下所示的 :meth:`__init__`::"

#: ../../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 "请注意，此方法会自动添加到类中：而不是在如上所示的 ``InventoryItem`` 定义中被直接指定。"

#: ../../library/dataclasses.rst:47

msgid "Module-level decorators, classes, and functions"

msgstr ""

#: ../../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 "这个函数是 :term:`decorator` ，用于将生成的 :term:`special method` 添加到类中，如下所述。"

#: ../../library/dataclasses.rst:54

msgid ""

"The :func:`dataclass` decorator examines the class to find ``field``\\s. A "

"``field`` is defined as a class variable that has a :term:`type annotation "

"<variable annotation>`. With two exceptions described below, nothing in "

":func:`dataclass` examines the type specified in the variable annotation."

msgstr ""

":func:`dataclass` 装饰器会检查类以查找 ``field`` —— ``field`` 被定义为具有 :term:`类型标注 "

"<variable annotation>` 的类变量。除了下面描述的两个例外，在 :func:`dataclass` "

"中没有什么东西会去检查这些变量标注成了何种类型。"

#: ../../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 "这些字段在所有生成的方法中的顺序，都是它们在类定义中出现的顺序。"

#: ../../library/dataclasses.rst:63

msgid ""

"The :func:`dataclass` decorator will add various \"dunder\" methods to the "

"class, described below. If any of the added methods already exist in the "

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

"decorator returns the same class that it is called on; no new class is "

"created."

msgstr ""

":func:`dataclass` 装饰器将向类中添加如下的各种 dunder "

"方法。如果所添加的方法已存在于类中，则行为将取决于下面所列出的形参。该装饰器会返回调用它的类；不会创建新的类。"

#: ../../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 ""

"如果 :func:`dataclass` 仅用作没有参数的简单装饰器，它将使用它的函数签名中的默认值。也就是说，这三种 "

":func:`dataclass` 用法是等价的："

#: ../../library/dataclasses.rst:86

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

msgstr ":func:`dataclass` 的参数有："

#: ../../library/dataclasses.rst:88

msgid ""

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

"generated."

msgstr "``init``: 如果为真值（默认），将生成一个 :meth:`__init__` 方法。"

#: ../../library/dataclasses.rst:91

msgid ""

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

msgstr "如果类已定义 :meth:`__init__` ，则忽略此参数。"

#: ../../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`` ：如果为真值（默认），将生成一个 :meth:`__repr__` 方法。 生成的 repr 字符串将具有类名以及每个字段的名称和 "

"repr ，按照它们在类中定义的顺序。不包括标记为从 repr 中排除的字段。 例如：``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 "如果类已定义 :meth:`__repr__` ，则忽略此参数。"

#: ../../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`` ：如果为true（默认值），将生成 :meth:`__eq__` "

"方法。此方法将类作为其字段的元组按顺序比较。比较中的两个实例必须是相同的类型。"

#: ../../library/dataclasses.rst:109

msgid ""

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

msgstr "如果类已定义 :meth:`__eq__` ，则忽略此参数。"

#: ../../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`` ：如果为真值（默认为 ``False`` ），则 :meth:`__lt__` 、 :meth:`__le__` 、 "

":meth:`__gt__` 和 :meth:`__ge__` 方法将生成。 这将类作为其字段的元组按顺序比较。比较中的两个实例必须是相同的类型。如果 "

"``order`` 为真值并且 ``eq`` 为假值 ，则引发 :exc:`ValueError` 。"

#: ../../library/dataclasses.rst:119

msgid ""

"If the class already defines any of :meth:`__lt__`, :meth:`__le__`, "

":meth:`__gt__`, or :meth:`__ge__`, then :exc:`TypeError` is raised."

msgstr ""

"如果类已经定义了 :meth:`__lt__` 、 :meth:`__le__` 、 :meth:`__gt__` 或者 :meth:`__ge__` "

"中的任意一个，将引发 :exc:`TypeError` 。"

#: ../../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`` ：如果为 ``False`` （默认值），则根据 ``eq`` 和 ``frozen`` 的设置方式生成 "

":meth:`__hash__` 方法。"

#: ../../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__` 由内置的 :meth:`hash()` 使用，当对象被添加到散列集合（如字典和集合）时。有一个 "

":meth:`__hash__` 意味着类的实例是不可变的。可变性是一个复杂的属性，取决于程序员的意图， :meth:`__eq__` "

"的存在性和行为，以及 :func:`dataclass` 装饰器中 ``eq`` 和 ``frozen`` 标志的值。"

#: ../../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 ""

"默认情况下， :func:`dataclass` 不会隐式添加 :meth:`__hash__` 方法，除非这样做是安全的。 "

"它也不会添加或更改现有的明确定义的 :meth:`__hash__` 方法。 设置类属性 ``__hash__ = None`` 对 Python "

"具有特定含义，如 :meth:`__hash__` 文档中所述。"

#: ../../library/dataclasses.rst:139

msgid ""

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

"then :func:`dataclass` *may* add an implicit :meth:`__hash__` method. "

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

"如果 :meth:`__hash__` 没有显式定义，或者它被设为 ``None``，则 :func:`dataclass` *可能* 会添加一个隐式 "

":meth:`__hash__` 方法。 虽然并不推荐，但你可以用 ``unsafe_hash=True`` 来强制 :func:`dataclass`"

" 创建一个 :meth:`__hash__` 方法。 如果你的类在逻辑上不可变但却仍然可被修改那么可能就是这种情况。 "

"这是一个特殊用例并且应当被仔细地考虑。"

#: ../../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 ""

"以下是隐式创建 :meth:`__hash__` 方法的规则。请注意，你不能在数据类中都使用显式的 :meth:`__hash__` 方法并设置 "

"``unsafe_hash=True`` ；这将导致 :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 ""

"如果 ``eq`` 和 ``frozen`` 都是 true，默认情况下 :func:`dataclass` 将为你生成一个 "

":meth:`__hash__` 方法。如果 ``eq`` 为 true 且 ``frozen`` 为 false ，则 "

":meth:`__hash__` 将被设置为 ``None`` ，标记它不可用（因为它是可变的）。如果 ``eq`` 为 false ，则 "

":meth:`__hash__` 将保持不变，这意味着将使用超类的 :meth:`__hash__` 方法（如果超类是 :class:`object` "

"，这意味着它将回到基于id的hash）。"

#: ../../library/dataclasses.rst:159

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``: 如为真值 (默认值为 ``False``)，则对字段赋值将会产生异常。 这模拟了只读的冻结实例。 如果在类中定义了 "

":meth:`__setattr__` 或 :meth:`__delattr__` 则将会引发 :exc:`TypeError`。 参见下文的讨论。"

#: ../../library/dataclasses.rst:164

msgid ""

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

"syntax::"

msgstr "可以用普通的 Python 语法为各个 ``field`` 指定默认值："

#: ../../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 "在这个例子中， ``a`` 和 ``b`` 都将包含在添加的 :meth:`__init__` 方法中，它们将被定义为::"

#: ../../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 whether this occurs in a single "

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

msgstr ""

"如果在具有默认值的字段之后存在没有默认值的字段，将会引发 :exc:`TypeError`。无论此情况是发生在单个类中还是作为类继承的结果，都是如此。"

#: ../../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 ""

"大多数时候，对于简单常见的用途，前述的功能已经足够了。而有些功能需要字段提供额外的信息来启用。为了满足这种对附加信息的需求，你可以通过调用提供的 "

":func:`field` 函数来替换字段默认值。例如："

#: ../../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 ":func:`field` 的形参有："

#: ../../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 ""

"``default``：如果提供，这将是该字段的默认值。设计这个形参是因为 :meth:`field` 调用将会占据原来用来提供默认值的位置。"

#: ../../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 ""

"``default_factory``：如果提供，它必须是一个需要零个参数的可调用对象，当该字段需要一个默认值时，它将被调用。这能解决当默认值是可变对象时会带来的问题，如下所述。同时指定"

" ``default`` 和 ``default_factory`` 将产生错误。"

#: ../../library/dataclasses.rst:214

msgid ""

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

"the generated :meth:`__init__` method."

msgstr "``init`` ：如果为true（默认值），则该字段作为参数包含在生成的 :meth:`__init__` 方法中。"

#: ../../library/dataclasses.rst:217

msgid ""

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

"returned by the generated :meth:`__repr__` method."

msgstr "``repr`` ：如果为true（默认值），则该字段包含在生成的 :meth:`__repr__` 方法返回的字符串中。"

#: ../../library/dataclasses.rst:220

msgid ""

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

"equality and comparison methods (:meth:`__eq__`, :meth:`__gt__`, et al.)."

msgstr ""

"``compare`` ：如果为true（默认值），则该字段包含在生成的相等性和比较方法中（ :meth:`__eq__` ， "

":meth:`__gt__` 等等）。"

#: ../../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 ""

"``hash`` ：这可以是布尔值或 ``None`` 。如果为true，则此字段包含在生成的 :meth:`__hash__` 方法中。如果为 "

"``None`` （默认值），请使用 ``compare`` 的值，这通常是预期的行为。如果字段用于比较，则应在 hash "

"中考虑该字段。不鼓励将此值设置为 ``None`` 以外的任何值。"

#: ../../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 ""

"设置 ``hash=False`` 但 ``compare=True`` "

"的一个合理情况是，一个计算哈希值的代价很高的字段是检验等价性需要的，且还有其他字段可以用于计算类型的哈希值。可以从哈希值中排除该字段，但仍令它用于比较。"

#: ../../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 ""

"``metadata``：可以是映射或 None。None 被视为一个空的字典。这个值将被包装在 "

":func:`~types.MappingProxyType` 中，使其只读，并暴露在 :class:`Field` "

"对象上。数据类不使用它——它是作为第三方扩展机制提供的。多个第三方可以各自拥有自己的键，以用作元数据中的命名空间。"

#: ../../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 ""

"如果通过调用 :func:`field()` 指定字段的默认值，则该字段对应的类属性的值将最终被替换为指定的 ``default`` 值。如果没有提供 "

"``default``，那么将删除该字段对应的类属性。目的是在 :func:`dataclass` "

"装饰器运行之后，类属性将包含字段的默认值，和直接指定了默认值一样。例如，在运行如下代码之后："

#: ../../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 ""

"类属性 ``C.z`` 将是 ``10``，类属性 ``C.t`` 将是 ``20``，类属性 ``C.x`` 和 ``C.y`` 将不设置。"

#: ../../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 ""

":class:`Field` 对象描述每个已定义的字段。这些对象在内部被创建，并由 :func:`fields` "

"模块级方法返回（见下）。用户永远不应该直接实例化 :class:`Field` 对象。它的下列属性的含义是由文档规定的："

#: ../../library/dataclasses.rst:272

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

msgstr "``name``：字段的名称。"

#: ../../library/dataclasses.rst:274

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

msgstr "``type``：字段的类型。"

#: ../../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 ""

"返回一个能描述此数据类所包含的字段的元组，元组的每一项都是 :class:`Field` "

"对象。接受数据类或数据类的实例。如果没有传递一个数据类或实例将引发 :exc:`TypeError`。不返回 ``ClassVar`` 或 "

"``InitVar`` 等伪字段。"

#: ../../library/dataclasses.rst:292

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

"将数据类 ``obj`` 转换为一个字典（使用工厂函数 ``dict_factory``）。每个数据类被转换为以 ``name: value`` "

"键值对来储存其字段的字典。数据类、字典、列表和元组的内容会被递归地访问。其它对象用 :func:`copy.deepcopy` 来复制。"

#: ../../library/dataclasses.rst:298

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

msgstr "在嵌套的数据类上使用 :func:`asdict` 的例子："

#: ../../library/dataclasses.rst:315 ../../library/dataclasses.rst:335

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

msgstr "要创建一个浅拷贝，可以使用以下的变通方法："

#: ../../library/dataclasses.rst:319

msgid ""

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

"instance."

msgstr "如果 ``obj`` 不是一个数据类实例，:func:`asdict` 引发 :exc:`TypeError`。"

#: ../../library/dataclasses.rst:324

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

"将数据类 ``obj`` 转换为一个元组（使用工厂函数 "

"``tuple_factory``）。每个数据类被转换为其字段的值的元组。数据类、字典、列表和元组的内容会被递归地访问。其它对象用 "

":func:`copy.deepcopy` 来复制。"

#: ../../library/dataclasses.rst:330

msgid "Continuing from the previous example::"

msgstr "继续前一个例子："

#: ../../library/dataclasses.rst:339

msgid ""

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

"instance."

msgstr "如果 ``obj`` 不是一个数据类实例，:func:`astuple` 引发 :exc:`TypeError`。"

#: ../../library/dataclasses.rst:344

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

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

"此函数不是必需的，因为任何用于创建带有 ``__annotations__`` 的新类的 Python 机制都可以进一步用 "

":func:`dataclass` 函数将创建的类转换为数据类。提供此函数是为了方便。例如："

#: ../../library/dataclasses.rst:365

msgid "Is equivalent to::"

msgstr "等价于："

#: ../../library/dataclasses.rst:378

msgid ""

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

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

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

":exc:`TypeError`."

msgstr ""

"创建一个与 ``obj`` 类型相同的新对象，将字段替换为 ``changes`` 里的值。如果 ``obj`` 不是数据类，则抛出 "

":exc:`TypeError` 。如果 ``changes`` 里的值没有指定要替换的字段名，则抛出 :exc:`TypeError`。"

#: ../../library/dataclasses.rst:383

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

"新返回的对象通过调用数据类的 :meth:`__init__` 方法创建。这确保了如果存在 :meth:`__post_init__` ，其也被调用。"

#: ../../library/dataclasses.rst:387

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

"如果存在没有默认值的仅初始化变量，必须在调用 :func:`replace` 时指定，以便它们可以传递给 :meth:`__init__` 和 "

":meth:`__post_init__` 。"

#: ../../library/dataclasses.rst:391

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

"``changes`` 包含任何定义为 ``init=False`` 的字段是错误的。在这种情况下会引发 :exc:`ValueError` 。"

#: ../../library/dataclasses.rst:395

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

"提前提醒， 字段在 :func:`replace` 被调用时的行为是，当它们被初始化时，不是从源对象直接复制，而是在 "

":meth:`__post_init__` 中初始化。除非保持审慎，否则 ``init=False`` 字段大概很少能被正确地使用。如果有使用 "

"``init=False`` 的字段，那么使用另外的类构造器，或自定义 ``replace()`` 方法（或类似名称的方法）来复制实例，可能会更好。"

#: ../../library/dataclasses.rst:406

msgid ""

"Return ``True`` if its parameter is a dataclass or an instance of one, "

"otherwise return ``False``."

msgstr "如果其形参为数据类，或其实例，返回 ``True``，否则返回 ``False``。"

#: ../../library/dataclasses.rst:409

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)`` 检查："

#: ../../library/dataclasses.rst:417

msgid "Post-init processing"

msgstr "初始化后处理"

#: ../../library/dataclasses.rst:419

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

"生成的 :meth:`__init__` 代码将调用一个名为 :meth:`__post_init__` 的方法，如果在类上已经定义了 "

":meth:`__post_init__` 。它通常被称为 ``self.__post_init__()`` 。但是，如果定义了任何 "

"``InitVar`` 字段，它们也将按照它们在类中定义的顺序传递给 :meth:`__post_init__` 。 如果没有 "

":meth:`__init__` 方法生成，那么 :meth:`__post_init__` 将不会被自动调用。"

#: ../../library/dataclasses.rst:427

msgid ""

"Among other uses, this allows for initializing field values that depend on "

"one or more other fields. For example::"

msgstr "在其他用途中，这允许初始化依赖于一个或多个其他字段的字段值。例如::"

#: ../../library/dataclasses.rst:439

msgid ""

"The :meth:`__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 ""

"由 :func:`dataclass` 所生成的 :meth:`__init__` 方法不会调用基类的 :meth:`__init__` 方法。 "

"如果基类有需要被调用的 :meth:`__init__` 方法，通常是在 :meth:`__post_init__` 方法中调用此方法::"

#: ../../library/dataclasses.rst:456

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

"但是请注意，一般来说 dataclass 生成的 :meth:`__init__` 方法不需要被调用，因为派生的 dataclass "

"将负责初始化任何自身为 dataclass 的基类的所有字段。"

#: ../../library/dataclasses.rst:460

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

"有关将参数传递给 :meth:`__post_init__` 的方法，请参阅下面有关仅初始化变量的段落。另请参阅关于 :func:`replace` "

"处理 ``init=False`` 字段的警告。"

#: ../../library/dataclasses.rst:465

msgid "Class variables"

msgstr "类变量"

#: ../../library/dataclasses.rst:467

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

msgid "Init-only variables"

msgstr "仅初始化变量"

#: ../../library/dataclasses.rst:478

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

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

msgid ""

"In this case, :func:`fields` will return :class:`Field` objects for ``i`` "

"and ``j``, but not for ``database``."

msgstr ""

"在这种情况下， :func:`fields` 将返回 ``i`` 和 ``j`` 的 :class:`Field` 对象，但不包括 "

"``database`` 。"

#: ../../library/dataclasses.rst:507

msgid "Frozen instances"

msgstr "冻结的实例"

#: ../../library/dataclasses.rst:509

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

"无法创建真正不可变的 Python 对象。但是，通过将 ``frozen=True`` 传递给 :meth:`dataclass` "

"装饰器，你可以模拟不变性。在这种情况下，数据类将向类添加 :meth:`__setattr__` 和 :meth:`__delattr__` 方法。 "

"些方法在调用时会引发 :exc:`FrozenInstanceError` 。"

#: ../../library/dataclasses.rst:515

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

"使用 ``frozen=True`` 时会有很小的性能损失： :meth:`__ init__` 不能使用简单的赋值来初始化字段，并必须使用 "

":meth:`object.__setattr__`。"

#: ../../library/dataclasses.rst:520

msgid "Inheritance"

msgstr "继承"

#: ../../library/dataclasses.rst:522

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

"当数据类由 :meth:`dataclass` 装饰器创建时，它会按反向 MRO 顺序（即，从 :class:`object` "

"开始）查看它的所有基类，并且将找到的每个数据类的字段添加到一个有序映射中。添加完所有基类字段后，它会将自己的字段添加到这个有序映射中。所有生成的方法都将使用这个有序映射。字段会遵守它们被插入的顺序，因此派生类会重写基类。一个例子："

#: ../../library/dataclasses.rst:542

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

"最后的字段列表依次是 ``x`` 、 ``y`` 、 ``z`` 。 ``x`` 的最终类型是 ``int`` ，如类 ``C`` 中所指定的那样。"

#: ../../library/dataclasses.rst:545

msgid "The generated :meth:`__init__` method for ``C`` will look like::"

msgstr "为 ``C`` 生成的 :meth:`__init__` 方法看起来像::"

#: ../../library/dataclasses.rst:550

msgid "Default factory functions"

msgstr "默认工厂函数"

#: ../../library/dataclasses.rst:552

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

"如果一个 :func:`field` 指定了一个 ``default_factory`` "

"，当需要该字段的默认值时，将使用零参数调用它。例如，要创建列表的新实例，请使用::"

#: ../../library/dataclasses.rst:558

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

"如果一个字段被排除在 :meth:`__init__` 之外（使用 ``init=False`` ）并且字段也指定 "

"``default_factory`` ，则默认的工厂函数将始终从生成的 :meth:`__init__` "

"函数调用。发生这种情况是因为没有其他方法可以为字段提供初始值。"

#: ../../library/dataclasses.rst:565

msgid "Mutable default values"

msgstr "可变的默认值"

#: ../../library/dataclasses.rst:567

msgid ""

"Python stores default member variable values in class attributes. Consider "

"this example, not using dataclasses::"

msgstr "Python 在类属性中存储默认成员变量值。思考这个例子，不使用数据类::"

#: ../../library/dataclasses.rst:582

msgid ""

"Note that the two instances of class ``C`` share the same class variable "

"``x``, as expected."

msgstr "请注意，类 ``C`` 的两个实例共享相同的类变量 ``x`` ，如预期的那样。"

#: ../../library/dataclasses.rst:585

msgid "Using dataclasses, *if* this code was valid::"

msgstr "使用数据类，*如果* 此代码有效："

#: ../../library/dataclasses.rst:593

msgid "it would generate code similar to::"

msgstr "它生成的代码类似于::"

#: ../../library/dataclasses.rst:604

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

msgid ""

"Using default factory functions is a way to create new instances of mutable "

"types as default values for fields::"

msgstr "使用默认工厂函数是一种创建可变类型新实例的方法，并将其作为字段的默认值::"

#: ../../library/dataclasses.rst:624

msgid "Exceptions"

msgstr "异常"

#: ../../library/dataclasses.rst:628

msgid ""

"Raised when an implicitly defined :meth:`__setattr__` or :meth:`__delattr__`"

" is called on a dataclass which was defined with ``frozen=True``. It is a "

"subclass of :exc:`AttributeError`."

msgstr ""

"在使用 ``frozen=True`` 定义的数据类上调用隐式定义的 :meth:`__setattr__` 或 :meth:`__delattr__`"

" 时引发。 这是 :exc:`AttributeError` 的一个子类。"