dataclasses.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2022
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-12-30 14:59+0000\n"
"PO-Revision-Date: 2022-11-05 17:21+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2022\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\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 ""
"このモジュールは、:meth:`__init__` や :meth:`__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: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 contents"
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:`special method` を生成し、クラスに追加する :term:"
"`decorator` です。"

#: ../../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` デコレータは、``フィールド`` を探すためにクラスを検査しま"
"す。\n"
"``フィールド`` は :term:`型アノテーション <variable annotation>` を持つクラス"
"変数として定義されます。\n"
"後述する２つの例外を除き、 :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はdouble underscoreの略で、メソッド名の前後にアンダースコアが2つ付いて"
"いるメソッド) をクラスに追加します。クラスに既にこれらのメソッドが存在する場"
"合の動作は、後述する引数によって異なります。デコレータは呼び出した際に指定し"
"たクラスと同じクラスを返します。新しいクラスは生成されません。"

#: ../../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:87
msgid "The parameters to :func:`dataclass` are:"
msgstr ":func:`dataclass` の引数は以下の通りです::"

#: ../../library/dataclasses.rst:89
msgid ""
"``init``: If true (the default), a :meth:`__init__` method will be generated."
msgstr ""
"``init``: (デフォルトの)真の場合、 :meth:`__init__` メソッドが生成されます。"

#: ../../library/dataclasses.rst:92
msgid ""
"If the class already defines :meth:`__init__`, this parameter is ignored."
msgstr ""
"もしクラスに :meth:`__init__` が既に定義されていた場合は、この引数は無視され"
"ます。"

#: ../../library/dataclasses.rst:95
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__` メソッドが生成されま"
"す。\n"
"生成された repr 文字列には、クラス名、各フィールドの名前および repr 文字列"
"が、クラス上での定義された順序で並びます。\n"
"repr から除外するように印が付けられたフィールドは、 repr 文字列には含まれませ"
"ん。\n"
"例えば、このようになります: ``InventoryItem(name='widget', unit_price=3.0, "
"quantity_on_hand=10)`` 。"

#: ../../library/dataclasses.rst:102
msgid ""
"If the class already defines :meth:`__repr__`, this parameter is ignored."
msgstr ""
"もしクラスに :meth:`__repr__` が既に定義されていた場合は、この引数は無視され"
"ます。"

#: ../../library/dataclasses.rst:105
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``: (デフォルトの)真の場合、 :meth:`__eq__` メソッドが生成されます。この"
"メソッドはクラスの比較を、そのクラスのフィールドからなるタプルを比較するよう"
"に行います。比較する2つのインスタンスのクラスは同一でなければなりません。"

#: ../../library/dataclasses.rst:110
msgid "If the class already defines :meth:`__eq__`, this parameter is ignored."
msgstr ""
"もしクラスに :meth:`__eq__` が既に定義されていた場合は、この引数は無視されま"
"す。"

#: ../../library/dataclasses.rst:113
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__` メソッドが生成されます。これらの比較"
"は、クラスをそのフィールドからなるタプルであるかのように取り扱います。比較さ"
"れる2つのインスタンスは、同一の型でなければなりません。もし ``order`` が "
"true で、 ``eq`` に falseを指定すすると、:exc:`ValueError` が送出されます。"

#: ../../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 ""
"もし、クラスで既に :meth:`__lt__`, :meth:`__le__`, :meth:`__gt__`, :meth:"
"`__ge__` のうちいずれかが定義されていると :exc:`TypeError` が送出されます。"

#: ../../library/dataclasses.rst:124
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:127
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()` から使われたり、 dict や set "
"のようなハッシュ化されたコレクションにオブジェクトを追加するときに使われま"
"す。\n"
":meth:`__hash__` があるということはそのクラスのインスタンスが不変 (イミュータ"
"ブル) であることを意味します。\n"
"可変性というのは複雑な性質で、プログラマの意図、 :meth:`__eq__` が存在してい"
"るかどうかとその振る舞い、 :func:`dataclass` デコレータの ``eq`` フラグと "
"``frozen`` フラグの値に依存します。"

#: ../../library/dataclasses.rst:134
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__` メソッドを暗黙的には追加しません。\n"
"また、明示的に定義され存在している :meth:`__hash__` メソッドに追加したり変更"
"したりはしません。\n"
"クラスの属性の ``__hash__ = None`` という設定は、 Python にとって :meth:"
"`__hash__` のドキュメントにあるような特別な意味があります。"

#: ../../library/dataclasses.rst:140
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__` メソッドを追加する *か"
"もしれません* 。\n"
"推奨はできませんが、 ``unsafe_hash=True`` とすることで :func:`dataclass` に :"
"meth:`__hash__` メソッドを作成させられます。\n"
"こうしてしまうと、クラスが論理的には不変だがそれにもかかわらず変更できてしま"
"う場合、問題になり得ます。\n"
"こうするのは特別なユースケースで、慎重に検討するべきです。"

#: ../../library/dataclasses.rst:147
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__` メソッドが暗黙的に作られるかどうかを決定する規則は次の通りで"
"す。\n"
"データクラスに明示的な :meth:`__hash__` メソッドを持たせた上で、 "
"``unsafe_hash=True`` と設定することはできません; こうすると :exc:`TypeError` "
"になります。"

#: ../../library/dataclasses.rst:152
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`` が両方とも真だった場合、デフォルトでは :func:"
"`dataclass` は :meth:`__hash__` メソッドを生成します。\n"
"``eq`` が真で ``frozen`` が偽の場合、:meth:`__hash__` は ``None`` に設定さ"
"れ、(可変なので) ハッシュ化不可能とされます。\n"
"``eq`` が偽の場合は、 :meth:`__hash__` は手を付けないまま、つまりスーパークラ"
"スの :meth:`__hash__` メソッドが使われることになります (スーパークラスが :"
"class:`object` だった場合は、 id に基づいたハッシュ化にフォールバックするとい"
"うことになります)。"

#: ../../library/dataclasses.rst:160
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``) の場合、フィールドへの代入は例外を"
"生成します。\n"
"これにより読み出し専用の凍結されたインスタンスを模倣します。\n"
":meth:`__setattr__` あるいは :meth:`__delattr__` がクラスに定義されていた場合"
"は、 :exc:`TypeError` が送出されます。\n"
"後にある議論を参照してください。"

#: ../../library/dataclasses.rst:165
msgid ""
"``match_args``: If true (the default is ``True``), the ``__match_args__`` "
"tuple will be created from the list of parameters to the generated :meth:"
"`__init__` method (even if :meth:`__init__` is not generated, see above).  "
"If false, or if ``__match_args__`` is already defined in the class, then "
"``__match_args__`` will not be generated."
msgstr ""
"``match_args``: 真なら（デフォルトは ``True`` ） ``__match_args__`` タプルは"
"生成された :meth:`__init__` メソッドに渡されたパラメータのリストから作成され"
"ます（もし :meth:`__init__` が生成されない場合は上記参照）。もし偽だったり、"
"すでに ``__match_args__`` がクラスに定義されていた場合には "
"``__match_args__`` は生成されません。"

#: ../../library/dataclasses.rst:174
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 affect is that the :meth:`__init__` parameter generated from a keyword-"
"only field must be specified with a keyword when :meth:`__init__` is "
"called.  There is no effect on any other aspect of dataclasses.  See the :"
"term:`parameter` glossary entry for details.  Also see the :const:`KW_ONLY` "
"section."
msgstr ""
"``kw_only``: もし真（デフォルトは ``False`` ）なら、すべてのフィールドはキー"
"ワード専用となります。もしフィールドにキーワード専用の指定がされると、 :meth:"
"`__init__` の引数はキーワード専用フィールドから作られ、 :meth:`__init__` 呼び"
"出し時にキーワードを指定しなければならなくなります。このオプションはデータク"
"ラスの他の機能には影響はありません。詳細は用語集の :term:`parameter` を参照し"
"てください。もしくは :const:`KW_ONLY` セクションを参照してください。"

#: ../../library/dataclasses.rst:185
msgid ""
"``slots``: If true (the default is ``False``), :attr:`__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 ""
"``slots``: もし真なら（デフォルトは ``False`` ）、 :attr:`__slots__` 属性が作"
"られ、オリジナルのクラスの代わりに新しいクラスが返されます。もし :attr:"
"`__slots__` がすでにクラスに定義されていた場合、 :exc:`TypeError` が送出され"
"ます。"

#: ../../library/dataclasses.rst:192
msgid ""
"``field``\\s may optionally specify a default value, using normal Python "
"syntax::"
msgstr ""
"``フィールド`` には、通常の Python の文法でデフォルト値を指定できます。"

#: ../../library/dataclasses.rst:200
msgid ""
"In this example, both ``a`` and ``b`` will be included in the added :meth:"
"`__init__` method, which will be defined as::"
msgstr ""
"この例では、生成された :meth:`__init__` メソッドには ``a`` と ``b`` の両方が"
"含まれ、以下のように定義されます::"

#: ../../library/dataclasses.rst:205
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:211
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 ""
"通常の単純なユースケースでは、この他の機能は必要ありません。\n"
"しかし、データクラスには、フィールドごとの情報を必要とする機能もあります。\n"
"追加の情報の必要性に応えるために、デフォルトのフィールドの値をモジュールから"
"提供されている :func:`field` 関数の呼び出しに置き換えられます。\n"
"例えば次のようになります::"

#: ../../library/dataclasses.rst:224
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:229
msgid "The parameters to :func:`field` are:"
msgstr ":func:`field` の引数は次の通りです:"

#: ../../library/dataclasses.rst:231
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``: 与えられた場合、このフィールドのデフォルト値になります。\n"
"これが必要なのは、 :meth:`field` の呼び出しそのものが通常ではデフォルト値がい"
"る位置を横取りしているからです。"

#: ../../library/dataclasses.rst:235
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``: 提供されていた場合、0 引数の呼び出し可能オブジェクトでな"
"ければならず、このフィールドの初期値が必要になったときに呼び出されます。\n"
"他の目的も含めて、下で議論されているように、フィールドに可変なデフォルト値を"
"指定するのに使えます。\n"
"``default`` と ``default_factory`` の両方を指定するとエラーになります。"

#: ../../library/dataclasses.rst:241
msgid ""
"``init``: If true (the default), this field is included as a parameter to "
"the generated :meth:`__init__` method."
msgstr ""
"``init``: (デフォルトの)真の場合、 生成される :meth:`__init__` メソッドの引数"
"にこのフィールドを含めます。"

#: ../../library/dataclasses.rst:244
msgid ""
"``repr``: If true (the default), this field is included in the string "
"returned by the generated :meth:`__repr__` method."
msgstr ""
"``repr``: (デフォルトの)真の場合、生成される :meth:`__repr__` メソッドによっ"
"て返される文字列に、このフィールドを含めます。"

#: ../../library/dataclasses.rst:247
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`` に設定できます。\n"
"真の場合、このフィールドは、生成された :meth:`__hash__` メソッドに含まれま"
"す。\n"
"(デフォルトの) ``None`` の場合、 ``compare`` の値を使います: こうすることは普"
"通は期待通りの振る舞いになります。\n"
"比較で使われるフィールドはハッシュに含まれるものと考えるべきです。\n"
"この値を ``None`` 以外に設定することは推奨されません。"

#: ../../library/dataclasses.rst:254
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:260
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``: (デフォルトの) 真の場合、生成される等価関数と比較関数( :meth:"
"`__eq__` 、:meth:`__gt__` など)にこのフィールドを含めます。"

#: ../../library/dataclasses.rst:264
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`` に設定できます。\n"
"``None`` は空の辞書として扱われます。\n"
"この値は :func:`~types.MappingProxyType` でラップされ、読み出し専用になり、 :"
"class:`Field` オブジェクトに公開されます。\n"
"これはデータクラスから使われることはなく、サードパーティーの拡張機構として提"
"供されます。\n"
"複数のサードパーティーが各々のキーを持て、メタデータの名前空間として使えま"
"す。"

#: ../../library/dataclasses.rst:272
msgid ""
"``kw_only``: If true, this field will be marked as keyword-only. This is "
"used when the generated :meth:`__init__` method's parameters are computed."
msgstr ""
"``kw_only``: もし真なら、このフィールドはキーワード専用となります。これは生成"
"された :meth:`__init__` メソッドがパラメータを評価する時に利用されます。"

#: ../../library/dataclasses.rst:278
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`` 値で置き換えられま"
"す。\n"
"``default`` が提供されていない場合は、そのクラス属性は削除されます。\n"
"こうする意図は、 :func:`dataclass` デコレータが実行された後には、ちょうどデ"
"フォルト値そのものが指定されたかのように、クラス属性がデフォルト値を全て持っ"
"ているようにすることです。\n"
"例えば、次のような場合::"

#: ../../library/dataclasses.rst:294
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:300
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` オブジェクトはそれぞれの定義されたフィールドを記述します。\n"
"このオブジェクトは内部で作られ、モジュールレベル関数の :func:`fields` によっ"
"て返されます (下の解説を見てください)。\n"
"ユーザーは絶対に :class:`Field` オブジェクトを直接インスタンス化すべきではあ"
"りません。\n"
"ドキュメント化されている属性は次の通りです:"

#: ../../library/dataclasses.rst:305
msgid "``name``: The name of the field."
msgstr "``name``: フィールド名"

#: ../../library/dataclasses.rst:307
msgid "``type``: The type of the field."
msgstr "``type``: フィールドの型"

#: ../../library/dataclasses.rst:309
msgid ""
"``default``, ``default_factory``, ``init``, ``repr``, ``hash``, ``compare``, "
"``metadata``, and ``kw_only`` have the identical meaning and values as they "
"do in the :func:`field` function."
msgstr ""
"``default``, ``default_factory``, ``init``, ``repr``, ``hash``, ``compare``, "
"``metadata``, ``kw_only`` は :func:`field` の宣言と同じ意味と値を持ちます。"

#: ../../library/dataclasses.rst:313
msgid ""
"Other attributes may exist, but they are private and must not be inspected "
"or relied on."
msgstr ""
"他の属性があることもありますが、それらはプライベートであり、調べたり、依存し"
"たりしてはなりません。"

#: ../../library/dataclasses.rst:318
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:325
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`` を使い) 辞書に変換し"
"ます。\n"
"それぞれのデータクラスは、 ``name: value`` という組になっている、フィールドの"
"辞書に変換されます。\n"
"データクラス、辞書、リスト、タプルは再帰的に処理されます。\n"
"その他のオブジェクトは :func:`copy.deepcopy` でコピーされます。"

#: ../../library/dataclasses.rst:331
msgid "Example of using :func:`asdict` on nested dataclasses::"
msgstr ""

#: ../../library/dataclasses.rst:348 ../../library/dataclasses.rst:368
msgid "To create a shallow copy, the following workaround may be used::"
msgstr ""

#: ../../library/dataclasses.rst:352
msgid ""
":func:`asdict` raises :exc:`TypeError` if ``obj`` is not a dataclass "
"instance."
msgstr ""
"``obj`` がデータクラスのインスタンスでなかった場合、 :func:`asdict` は :exc:"
"`TypeError` を送出します。"

#: ../../library/dataclasses.rst:357
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`` を使い) タプルに変"
"換します。\n"
"それぞれのデータクラスは、フィールド値のタプルに変換されます。\n"
"データクラス、辞書、リスト、タプルは再帰的に処理されます。\n"
"その他のオブジェクトは :func:`copy.deepcopy` でコピーされます。"

#: ../../library/dataclasses.rst:363
msgid "Continuing from the previous example::"
msgstr "1つ前の例の続きです::"

#: ../../library/dataclasses.rst:372
msgid ""
":func:`astuple` raises :exc:`TypeError` if ``obj`` is not a dataclass "
"instance."
msgstr ""
"``obj`` がデータクラスのインスタンスでなかった場合、 :func:`astuple` は :exc:"
"`TypeError` を送出します。"

#: ../../library/dataclasses.rst:377
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``, ``frozen``, ``match_args``, ``kw_only``, and  ``slots`` "
"have the same meaning as they do in :func:`dataclass`."
msgstr ""
"``cls_name`` という名前、 ``fields`` で定義されるフィールド、 ``bases`` で与"
"えられた基底クラス、 ``namespace`` で与えられた名前空間付きで初期化されたデー"
"タクラスを作成します。\n"
"``fields`` はイテラブルで、要素が ``name``, ``(name, type)``, ``(name, type, "
"Field)`` のうちのどれかです。\n"
"単に ``name`` だけが与えられた場合は、 ``typing.Any`` が ``type`` として使わ"
"れます。\n"
"``init``, ``repr``, ``eq``, ``order``, ``unsafe_hash``, ``frozen``, "
"``match_args``, ``kw_only`` の値は、 :func:`dataclass` のときと同じ意味を持ち"
"ます。"

#: ../../library/dataclasses.rst:387
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` 関数を適用し"
"てそのクラスをデータクラスに変換できるからです。\n"
"この関数は便利さのために提供されています。\n"
"例えば次のように使います::"

#: ../../library/dataclasses.rst:399
msgid "Is equivalent to::"
msgstr "は、次のコードと等しいです::"

#: ../../library/dataclasses.rst:412
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`` にある"
"値で置き換えます。\n"
"``obj`` がデータクラスではなかった場合、 :exc:`TypeError` を送出します。\n"
"``changes`` にある値がフィールドを指定していなかった場合も、 :exc:"
"`TypeError` を送出します。"

#: ../../library/dataclasses.rst:417
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__` メソッドを呼び"
"出して作成されます。\n"
"これにより、もしあれば :meth:`__post_init__` も呼び出されることが保証されま"
"す。"

#: ../../library/dataclasses.rst:421
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:425
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`` と定義されたフィールドが含まれているとエラー"
"になります。\n"
"この場合 :exc:`ValueError` が送出されます。"

#: ../../library/dataclasses.rst:429
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` を呼び出しているときに ``init=False`` であるフィールドがどの"
"ように働くかに気を付けてください。\n"
"そのフィールドは元のオブジェクトからコピーされるのではなく、仮に初期化された"
"としても結局は :meth:`__post_init__` で初期化されます。\n"
"``init=False`` であるフィールドは滅多に使いませんし、使うとしたら注意深く使用"
"します。\n"
"そのようなフィールドが使われている場合は、代わりのクラスコンストラクタ、ある"
"いは、インスタンスのコピー処理をする独自実装の ``replace()`` (もしくは似た名"
"前の) メソッドを持たせるのが賢明でしょう。"

#: ../../library/dataclasses.rst:440
msgid ""
"Return ``True`` if its parameter is a dataclass or an instance of one, "
"otherwise return ``False``."
msgstr ""
"引数がデータクラスかデータクラスのインスタンスだった場合に ``True`` を返しま"
"す。それ以外の場合は ``False`` を返します。"

#: ../../library/dataclasses.rst:443
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:452
msgid "A sentinel value signifying a missing default or default_factory."
msgstr ""
"デフォルト値やdefault_factoryが設定されてない場合の番兵の値を設定します。"

#: ../../library/dataclasses.rst:456
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:`__init__` parameters that must be specified as keywords when the class "
"is instantiated."
msgstr ""
"番兵値は型アノテーションとして使用されます。 :const:`KW_ONLY` の型の擬似"
"フィールドのあとのすべてのフィールドはキーワード専用フィールドとなります。 :"
"const:`KW_ONLY` の型の擬似フィールド自体は無視されることに注意してください。"
"これにはそのようなフィールドの名前も含まれます。 :const:`KW_ONLY` フィールド"
"の名前としては ``_`` が慣習的に使用されます。キーワード専用フィールドは クラ"
"スの初期化時にキーワードとして指定されなければならない :meth:`__init__`  のパ"
"ラメータを意味します。"

#: ../../library/dataclasses.rst:465
msgid ""
"In this example, the fields ``y`` and ``z`` will be marked as keyword-only "
"fields::"
msgstr "このサンプルでは ``y`` と ``z`` がキーワード専用フィールドとなります::"

#: ../../library/dataclasses.rst:476
msgid ""
"In a single dataclass, it is an error to specify more than one field whose "
"type is :const:`KW_ONLY`."
msgstr ""
"1つのデータクラスの中に、2つ以上の :const:`KW_ONLY` の型のフィールドがあると"
"エラーになります。"

#: ../../library/dataclasses.rst:483
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` のサブクラスです。"

#: ../../library/dataclasses.rst:488
msgid "Post-init processing"
msgstr "初期化後の処理"

#: ../../library/dataclasses.rst:490
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__` という名前のメ"
"ソッドがクラスに定義されていたら、それを呼び出します。\n"
"通常は ``self.__post_init__()`` のように呼び出されます。\n"
"しかし ``InitVar`` フィールドが定義されていた場合、それらもクラスに定義された"
"順序で :meth:`__post_init__` に渡されます。\n"
":meth:`__init__` メソッドが生成されなかった場合は、 :meth:`__post_init__` は"
"自動的には呼び出されません。"

#: ../../library/dataclasses.rst:498
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:510
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:527
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 ""
"派生データクラスが、データクラス自体である基本クラスのすべてのフィールドの初"
"期化を処理するため、データクラスで生成された :meth:`__init__` メソッドを呼び"
"出す必要はありません。"

#: ../../library/dataclasses.rst:531
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:536
msgid "Class variables"
msgstr "クラス変数"

#: ../../library/dataclasses.rst:538
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 ""
":func:`dataclass` が実際にフィールドの型の検査を行う 2 箇所のうち 1 つは、"
"フィールドが :pep:`526` で定義されたクラス変数かどうかの判定です。\n"
"その判定はフィールドの型が ``typing.ClassVar`` かどうかで行います。\n"
"フィールドが ``ClassVar`` の場合、フィールドとは見なされなくなり、データクラ"
"スの機構からは無視されます。\n"
"そのような ``ClassVar`` 疑似フィールドは、モジュールレベル関数 :func:"
"`fields` の返り値には含まれません。"

#: ../../library/dataclasses.rst:547
msgid "Init-only variables"
msgstr "初期化限定変数"

#: ../../library/dataclasses.rst:549
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 ""
":func:`dataclass` が型アノテーションの検査を行うもう 1 つの箇所は、フィールド"
"が初期化限定変数かどうかの判定です。\n"
"その判定はフィールドの型が ``dataclasses.InitVar`` 型であるかどうかで行いま"
"す。\n"
"フィールドが ``InitVar`` の場合、初期化限定フィールドと呼ばれる疑似フィールド"
"と見なされます。\n"
"これは本物のフィールドではないので、モジュールレベル関数 :func:`fields` の返"
"り値には含まれません。\n"
"初期化限定フィールドは生成された :meth:`__init__` メソッドに引数として追加さ"
"れ、オプションの :meth:`__post_init__` メソッドにも渡されます。\n"
"初期化限定フィールドは、データクラスからはそれ以外では使われません。"

#: ../../library/dataclasses.rst:559
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:574
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`` の :class:`Field` オブジェクトは返しません。"

#: ../../library/dataclasses.rst:578
msgid "Frozen instances"
msgstr "凍結されたインスタンス"

#: ../../library/dataclasses.rst:580
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 のオブジェクトを作成するのは不可能です。\n"
"しかし、 ``frozen=True`` を :meth:`dataclass` デコレータに渡すことで、不変性"
"の模倣はできます。\n"
"このケースでは、データクラスは :meth:`__setattr__` メソッドと :meth:"
"`__delattr__` メソッドをクラスに追加します。\n"
"これらのメソッドは起動すると :exc:`FrozenInstanceError` を送出します。"

#: ../../library/dataclasses.rst:586
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:591
msgid "Inheritance"
msgstr "継承"

#: ../../library/dataclasses.rst:593
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` を出発点として) 全ての基底クラスを調べていき、見"
"付かったデータクラスそれぞれについて、その基底クラスが持っているフィールドを"
"順序付きマッピングオブジェクトに追加します。\n"
"全ての基底クラスのフィールドが追加し終わったら、自分自身のフィールドを順序付"
"きマッピングオブジェクトに追加します。\n"
"生成された全てのメソッドは、このフィールドが集められ整列された順序付きのマッ"
"ピングオブジェクトを利用します。\n"
"フィールドは挿入順序で並んでいるので、派生クラスは基底クラスをオーバーライド"
"します。\n"
"例えば次のようになります::"

#: ../../library/dataclasses.rst:613
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`` の順番になりま"
"す。\n"
"最終的な ``x`` の型は、 クラス ``C`` で指定されている通り ``int`` です。"

#: ../../library/dataclasses.rst:616
msgid "The generated :meth:`__init__` method for ``C`` will look like::"
msgstr "``C`` の生成された :meth:`__init__` メソッドは次のようになります::"

#: ../../library/dataclasses.rst:621
msgid "Re-ordering of keyword-only parameters in :meth:`__init__`"
msgstr "キーワード専用パラメータの :meth:`__init__` 内の順序の再整理"

#: ../../library/dataclasses.rst:623
msgid ""
"After the parameters needed for :meth:`__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 ""
":meth:`__init__` で必要なパラメータが算出されると、キーワード専用引数は他の一"
"般的な（非キーワード専用）パラメータの後に移動します。これは、すべてのキー"
"ワード専用引数は、非キーワード専用パラメータの末尾にこなければならないとい"
"う、キーワード専用パラメータのPythonの実装の都合で必要なことです。"

#: ../../library/dataclasses.rst:629
msgid ""
"In this example, ``Base.y``, ``Base.w``, and ``D.t`` are keyword-only "
"fields, and ``Base.x`` and ``D.z`` are regular fields::"
msgstr ""
"このサンプルでは、 ``Base.y`` と ``Base.w`` 、 ``D.t`` がキーワード専用フィー"
"ルドで、 ``Base.x`` と ``D.z`` が通常のフィールドです:"

#: ../../library/dataclasses.rst:644
msgid "The generated :meth:`__init__` method for ``D`` will look like::"
msgstr "``D`` の生成された :meth:`__init__` メソッドは次のようになります::"

#: ../../library/dataclasses.rst:648
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 ""
"パラメータは、フィールドのリストの表示方法によって並べ替えられます。通常の"
"フィールドから派生したパラメータの後に、キーワードのみのフィールドから派生し"
"たパラメータが続きます。"

#: ../../library/dataclasses.rst:652
msgid ""
"The relative ordering of keyword-only parameters is maintained in the re-"
"ordered :meth:`__init__` parameter list."
msgstr ""
"キーワード専用パラメータの相対的な順序は :meth:`__init__` パラメータリストの"
"順序の再整理の前後で維持されます。"

#: ../../library/dataclasses.rst:657
msgid "Default factory functions"
msgstr "デフォルトファクトリ関数"

#: ../../library/dataclasses.rst:659
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`` を指定した場合、そのフィールドのデフォル"
"ト値が必要とされたときに、引数無しで呼び出されます。\n"
"これは例えば、リストの新しいインスタンスを作成するために使います::"

#: ../../library/dataclasses.rst:665
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 ""
"あるフィールドが (``init=False`` を使って) :meth:`__init__` から除外され、か"
"つ、 ``default_factory`` が指定されていた場合、デフォルトファクトリ関数は生成"
"された :meth:`__init__` 関数から常に呼び出されます。\n"
"フィールドに初期値を与える方法が他に無いので、このような動きになります。"

#: ../../library/dataclasses.rst:672
msgid "Mutable default values"
msgstr "可変なデフォルト値"

#: ../../library/dataclasses.rst:674
msgid ""
"Python stores default member variable values in class attributes. Consider "
"this example, not using dataclasses::"
msgstr ""
"Python はメンバ変数のデフォルト値をクラス属性に保持します。\n"
"データクラスを使っていない、この例を考えてみましょう::"

#: ../../library/dataclasses.rst:689
msgid ""
"Note that the two instances of class ``C`` share the same class variable "
"``x``, as expected."
msgstr ""
"クラス ``C`` の 2 つのインスタンスが、予想通り同じクラス変数 ``x`` を共有して"
"いることに注意してください。"

#: ../../library/dataclasses.rst:692
msgid "Using dataclasses, *if* this code was valid::"
msgstr "データクラスを使っているこのコードが *もし仮に* 有効なものだとしたら::"

#: ../../library/dataclasses.rst:700
msgid "it would generate code similar to::"
msgstr "データクラスは次のようなコードを生成するでしょう::"

#: ../../library/dataclasses.rst:711
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, the :func:`dataclass` decorator 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 ""
"これには、クラス ``C`` を使ったさっきの例と同じ問題があります。\n"
"すなわち、クラス ``D`` の 2 つのインスタンスは、クラスインスタンスを作成する"
"ときに ``x`` の具体的な値を指定しておらず、同じ ``x`` のコピーを共有しま"
"す。\n"
"データクラスは Python の通常のクラス作成の仕組みを使っているだけなので、この"
"同じ問題を抱えています。\n"
"データクラスがこの問題を検出する一般的な方法を持たない代わりに、 :func:"
"`dataclass` デコレータは型が ``list`` や ``dict`` や ``set`` のデフォルトパラ"
"メーターを検出した場合、 :exc:`TypeError` を送出します。\n"
"これは完全ではない解決法ですが、よくあるエラーの多くを防げます。"

#: ../../library/dataclasses.rst:722
msgid ""
"Using default factory functions is a way to create new instances of mutable "
"types as default values for fields::"
msgstr ""
"デフォルトファクトリ関数を使うのが、フィールドのデフォルト値として可変な型の"
"新しいインスタンスを作成する手段です::"

#: ../../library/dataclasses.rst:732
msgid "Descriptor-typed fields"
msgstr ""

#: ../../library/dataclasses.rst:734
msgid ""
"Fields that are assigned :ref:`descriptor objects <descriptors>` as their "
"default value have the following special behaviors:"
msgstr ""

#: ../../library/dataclasses.rst:737
msgid ""
"The value for the field passed to the dataclass's ``__init__`` method is "
"passed to the descriptor's ``__set__`` method rather than overwriting the "
"descriptor object."
msgstr ""

#: ../../library/dataclasses.rst:740
msgid ""
"Similarly, when getting or setting the field, the descriptor's ``__get__`` "
"or ``__set__`` method is called rather than returning or overwriting the "
"descriptor object."
msgstr ""

#: ../../library/dataclasses.rst:743
msgid ""
"To determine whether a field contains a default value, ``dataclasses`` will "
"call the descriptor's ``__get__`` method using its class access form (i.e. "
"``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 ""

#: ../../library/dataclasses.rst:778
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 ""