# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 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.14\n"

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

"POT-Creation-Date: 2026-04-09 15:16+0000\n"

"PO-Revision-Date: 2025-09-16 00:01+0000\n"

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

"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"

"ja/)\n"

"MIME-Version: 1.0\n"

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

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

"Language: ja\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 methods <special method>` such as :meth:`~object."

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

"originally described in :pep:`557`."

msgstr ""

"このモジュールは、:meth:`~object.__init__` や :meth:`~object.__repr__` のよう"

"な :term:`特殊メソッド <special method>` を生成し、ユーザー定義のクラスに自動"

"的に追加するデコレーターや関数を提供します。このモジュールは元々、 :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:22

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

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

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

msgstr "とりわけ、以下のような :meth:`!__init__` が追加されます::"

#: ../../library/dataclasses.rst:36

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

#: ../../library/dataclasses.rst:41

msgid ""

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

"directly specified in the :class:`!InventoryItem` definition shown above."

msgstr ""

"このメソッドは自動的にクラスに追加される点に留意して下さい。上記の :class:`!"

"InventoryItem` クラスの定義中にこのメソッドが直接明記されるわけではありませ"

"ん。"

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

msgid "Module contents"

msgstr "モジュールの内容"

#: ../../library/dataclasses.rst:51

msgid ""

"This function is a :term:`decorator` that is used to add generated :term:"

"`special methods <special method>` to classes, as described below."

msgstr ""

"この関数は、後述する :term:`特殊メソッド <special method>` を生成し、クラスに"

"追加する :term:`decorator` です。"

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

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 "

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

"``@dataclass`` examines the type specified in the variable annotation."

msgstr ""

"``@dataclass`` デコレータは、``field`` を探すためにクラスを検査します。"

"``field`` は :term:`型アノテーション <variable annotation>` を持つクラス変数"

"として定義されます。後述する２つの例外を除き、 ``@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 ``@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 ""

"``@dataclass`` デコレータは、後述する様々な \"ダンダー\" メソッド (訳注："

"dunderはdouble underscoreの略で、メソッド名の前後にアンダースコアが2つ付いて"

"いるメソッド) をクラスに追加します。クラスに既にこれらのメソッドが存在する場"

"合の動作は、後述する引数によって異なります。デコレータは呼び出した際に指定し"

"たクラスと同じクラスを返します。新しいクラスは生成されません。"

#: ../../library/dataclasses.rst:69

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

#: ../../library/dataclasses.rst:74

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

#: ../../library/dataclasses.rst:87

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

msgstr ""

#: ../../library/dataclasses.rst:89

msgid ""

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

"generated."

msgstr ""

#: ../../library/dataclasses.rst:92

msgid ""

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

msgstr ""

#: ../../library/dataclasses.rst:95

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

#: ../../library/dataclasses.rst:102

msgid ""

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

msgstr ""

#: ../../library/dataclasses.rst:105

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

#: ../../library/dataclasses.rst:110

msgid ""

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

msgstr ""

#: ../../library/dataclasses.rst:113

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

#: ../../library/dataclasses.rst:120

msgid ""

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

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

msgstr ""

#: ../../library/dataclasses.rst:124

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

#: ../../library/dataclasses.rst:130

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

#: ../../library/dataclasses.rst:137

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

#: ../../library/dataclasses.rst:143

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

#: ../../library/dataclasses.rst:150

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

#: ../../library/dataclasses.rst:155

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

#: ../../library/dataclasses.rst:163

msgid ""

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

"generate an exception. This emulates read-only frozen instances. See the :"

"ref:`discussion <dataclasses-frozen>` below."

msgstr ""

#: ../../library/dataclasses.rst:167

msgid ""

"If :meth:`~object.__setattr__` or :meth:`~object.__delattr__` is defined in "

"the class and *frozen* is true, then :exc:`TypeError` is raised."

msgstr ""

#: ../../library/dataclasses.rst:170

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

#: ../../library/dataclasses.rst:179

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

#: ../../library/dataclasses.rst:187

msgid "Keyword-only fields are not included in :attr:`!__match_args__`."

msgstr ""

#: ../../library/dataclasses.rst:191

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

#: ../../library/dataclasses.rst:197

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

#: ../../library/dataclasses.rst:205

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 <datamodel-note-slots>`. 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 ""

#: ../../library/dataclasses.rst:215

msgid ""

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

"\"__weakref__\", which is required to make an instance :func:`weakref-able "

"<weakref.ref>`. It is an error to specify ``weakref_slot=True`` without also "

"specifying ``slots=True``."

msgstr ""

#: ../../library/dataclasses.rst:223

msgid ""

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

"syntax::"

msgstr ""

"``フィールド`` には、通常の Python の文法でデフォルト値を指定できます。"

#: ../../library/dataclasses.rst:226

msgid ""

"@dataclass\n"

"class C:\n"

" a: int # 'a' has no default value\n"

" b: int = 0 # assign a default value for 'b'"

msgstr ""

#: ../../library/dataclasses.rst:231

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

#: ../../library/dataclasses.rst:234

msgid "def __init__(self, a: int, b: int = 0):"

msgstr ""

#: ../../library/dataclasses.rst:236

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

msgid ""

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

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

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

"replace the default field value with a call to the provided :func:`!field` "

"function. For example::"

msgstr ""

#: ../../library/dataclasses.rst:248

msgid ""

"@dataclass\n"

"class C:\n"

" mylist: list[int] = field(default_factory=list)\n"

"\n"

"c = C()\n"

"c.mylist += [1, 2, 3]"

msgstr ""

#: ../../library/dataclasses.rst:255

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

#: ../../library/dataclasses.rst:260

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

msgstr ""

#: ../../library/dataclasses.rst:262

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

#: ../../library/dataclasses.rst:266

msgid ""

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

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

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

"discussed below. It is an error to specify both *default* and "

"*default_factory*."

msgstr ""

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

msgid ""

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

"generated :meth:`~object.__init__` method."

msgstr ""

#: ../../library/dataclasses.rst:275

msgid ""

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

"by the generated :meth:`~object.__repr__` method."

msgstr ""

#: ../../library/dataclasses.rst:278

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

#: ../../library/dataclasses.rst:286

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`` と設定する理由が 1 つあるとすれば、フィールドが等価検査に必"

"要かつ、その型のハッシュ値を計算するのに他のフィールドも使われることです。\n"

"フィールドがハッシュから除外されていたとしても、比較には使えます。"

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

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

#: ../../library/dataclasses.rst:296

msgid ""

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

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

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

"at all by Data Classes, and is provided as a third-party extension "

"mechanism. Multiple third-parties can each have their own key, to use as a "

"namespace in the metadata."

msgstr ""

#: ../../library/dataclasses.rst:304

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

#: ../../library/dataclasses.rst:308

msgid "Keyword-only fields are also not included in :attr:`!__match_args__`."

msgstr ""

#: ../../library/dataclasses.rst:312

msgid "*doc*: optional docstring for this field."

msgstr ""

#: ../../library/dataclasses.rst:316

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 :deco:`dataclass` decorator "

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

"fields, just as if the default value itself were specified. For example, "

"after::"

msgstr ""

#: ../../library/dataclasses.rst:325

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

#: ../../library/dataclasses.rst:332

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

#: ../../library/dataclasses.rst:338

msgid ""

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

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

"method (see below). Users should never instantiate a :class:`!Field` object "

"directly. Its documented attributes are:"

msgstr ""

#: ../../library/dataclasses.rst:343

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

msgstr ""

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

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

msgstr ""

#: ../../library/dataclasses.rst:345

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

#: ../../library/dataclasses.rst:349

msgid ""

"Other attributes may exist, but they are private and must not be inspected "

"or relied on."

msgstr ""

"他の属性があることもありますが、それらはプライベートであり、調べたり、依存し"

"たりしてはなりません。"

#: ../../library/dataclasses.rst:354

msgid ""

"``InitVar[T]`` type annotations describe variables that are :ref:`init-only "

"<dataclasses-init-only-variables>`. 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 ""

#: ../../library/dataclasses.rst:363

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` オブジェクトをタプルで"

"返します。\n"

"データクラスあるいはデータクラスのインスタンスを受け付けます。\n"

"データクラスやデータクラスのインスタンスが渡されなかった場合は、 :exc:"

"`TypeError` を送出します。\n"

"``ClassVar`` や ``InitVar`` といった疑似フィールドは返しません。"

#: ../../library/dataclasses.rst:370

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

#: ../../library/dataclasses.rst:376

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

msgstr ""

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

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

#: ../../library/dataclasses.rst:393 ../../library/dataclasses.rst:413

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

msgstr ""

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

msgid "{field.name: getattr(obj, field.name) for field in fields(obj)}"

msgstr ""

#: ../../library/dataclasses.rst:397

msgid ""

":func:`!asdict` raises :exc:`TypeError` if *obj* is not a dataclass instance."

msgstr ""

#: ../../library/dataclasses.rst:402

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

#: ../../library/dataclasses.rst:408

msgid "Continuing from the previous example::"

msgstr "1つ前の例の続きです::"

#: ../../library/dataclasses.rst:410

msgid ""

"assert astuple(p) == (10, 20)\n"

"assert astuple(c) == ([(0, 0), (10, 4)],)"

msgstr ""

#: ../../library/dataclasses.rst:415

msgid "tuple(getattr(obj, field.name) for field in dataclasses.fields(obj))"

msgstr ""

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

msgid ""

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

"instance."

msgstr ""

#: ../../library/dataclasses.rst:422

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

"`dataclass`."

msgstr ""

#: ../../library/dataclasses.rst:432

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

#: ../../library/dataclasses.rst:436

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 :deco:`dataclass`. By default, the :deco:`dataclass` "

"function is used."

msgstr ""

#: ../../library/dataclasses.rst:441

msgid ""

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

"creating a new class with :attr:`~object.__annotations__` can then apply "

"the :deco:`dataclass` function to convert that class to a dataclass. This "

"function is provided as a convenience. For example::"

msgstr ""

#: ../../library/dataclasses.rst:447

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

#: ../../library/dataclasses.rst:453

msgid "Is equivalent to::"

msgstr "は、次のコードと等しいです::"

#: ../../library/dataclasses.rst:455

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

#: ../../library/dataclasses.rst:464

msgid "Added the *decorator* parameter."

msgstr ""

#: ../../library/dataclasses.rst:469

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

#: ../../library/dataclasses.rst:474

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

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

msgid ""

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

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

"__init__` and :meth:`__post_init__`."

msgstr ""

#: ../../library/dataclasses.rst:482

msgid ""

"It is an error for *changes* to contain any fields that are defined as "

"having ``init=False``. A :exc:`ValueError` will be raised in this case."

msgstr ""

#: ../../library/dataclasses.rst:486

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

#: ../../library/dataclasses.rst:495

msgid ""

"Dataclass instances are also supported by generic function :func:`copy."

"replace`."

msgstr ""

#: ../../library/dataclasses.rst:499

msgid ""

"Return ``True`` if its parameter is a dataclass (including subclasses of a "

"dataclass) or an instance of one, otherwise return ``False``."

msgstr ""

#: ../../library/dataclasses.rst:502

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

msgid ""

"def is_dataclass_instance(obj):\n"

" return is_dataclass(obj) and not isinstance(obj, type)"

msgstr ""

#: ../../library/dataclasses.rst:511

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

msgstr ""

"デフォルト値やdefault_factoryが設定されてない場合の番兵の値を設定します。"

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

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

#: ../../library/dataclasses.rst:524

msgid ""

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

"fields::"

msgstr "このサンプルでは ``y`` と ``z`` がキーワード専用フィールドとなります::"

#: ../../library/dataclasses.rst:526

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

#: ../../library/dataclasses.rst:535

msgid ""

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

"type is :const:`!KW_ONLY`."

msgstr ""

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

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

"``frozen=True`` 付きで定義されたデータクラスで、暗黙的に定義された :meth:"

"`~object.__setattr__` または :meth:`~object.__delattr__` が呼び出されたときに"

"送出されます。これは :exc:`AttributeError` のサブクラスです。"

#: ../../library/dataclasses.rst:549

msgid "Post-init processing"

msgstr "初期化後の処理"

#: ../../library/dataclasses.rst:553

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

#: ../../library/dataclasses.rst:560

msgid ""

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

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

msgstr ""

"他の機能と組み合わせることで、他の 1 つ以上のフィールドに依存しているフィール"

"ドが初期化できます。\n"

"例えば次のようにできます::"

#: ../../library/dataclasses.rst:563

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

#: ../../library/dataclasses.rst:572

msgid ""

"The :meth:`~object.__init__` method generated by :deco:`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 ""

#: ../../library/dataclasses.rst:577

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

#: ../../library/dataclasses.rst:589

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

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

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__` にパラメータを"

"渡す方法を参照してください。\n"

":func:`replace` が ``init=False`` であるフィールドをどう取り扱うかについての"

"警告も参照してください。"

#: ../../library/dataclasses.rst:600

msgid "Class variables"

msgstr "クラス変数"

#: ../../library/dataclasses.rst:602

msgid ""

"One of the few places where :deco:`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 ""

#: ../../library/dataclasses.rst:613

msgid "Init-only variables"

msgstr "初期化限定変数"

#: ../../library/dataclasses.rst:615

msgid ""

"Another place where :deco:`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 ""

#: ../../library/dataclasses.rst:625

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

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

#: ../../library/dataclasses.rst:640

msgid ""

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

"i` and :attr:`!j`, but not for :attr:`!database`."

msgstr ""

#: ../../library/dataclasses.rst:646

msgid "Frozen instances"

msgstr "凍結されたインスタンス"

#: ../../library/dataclasses.rst:648

msgid ""

"It is not possible to create truly immutable Python objects. However, by "

"passing ``frozen=True`` to the :deco:`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 ""

#: ../../library/dataclasses.rst:654

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

#: ../../library/dataclasses.rst:663

msgid "Inheritance"

msgstr "継承"

#: ../../library/dataclasses.rst:665

msgid ""

"When the dataclass is being created by the :deco:`dataclass` decorator, it "

"looks through all of the class's base classes in reverse MRO (that is, "

"starting at :class:`object`) and, for each dataclass that it finds, adds the "

"fields from that base class to an ordered mapping of fields. After all of "

"the base class fields are added, it adds its own fields to the ordered "

"mapping. All of the generated methods will use this combined, calculated "

"ordered mapping of fields. Because the fields are in insertion order, "

"derived classes override base classes. An example::"

msgstr ""

#: ../../library/dataclasses.rst:675

msgid ""

"@dataclass\n"