enum.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2018, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-06-30 05:56+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Naoki INADA <songofacandy@gmail.com>, 2017\n"
"Language-Team: Japanese (https://www.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/enum.rst:2
msgid ":mod:`enum` --- Support for enumerations"
msgstr ":mod:`enum` --- 列挙型のサポート"

#: ../../library/enum.rst:14
msgid "**Source code:** :source:`Lib/enum.py`"
msgstr "**ソースコード:** :source:`Lib/enum.py`"

#: ../../library/enum.rst:18
msgid ""
"An enumeration is a set of symbolic names (members) bound to unique, "
"constant values.  Within an enumeration, the members can be compared by "
"identity, and the enumeration itself can be iterated over."
msgstr ""
"列挙型は、一意の定数値に束縛された識別名 (メンバー) の集合です。列挙型の中でメンバーの同一性を比較でき、列挙型自身でイテレートが可能です。"

#: ../../library/enum.rst:24
msgid "Module Contents"
msgstr "モジュールコンテンツ"

#: ../../library/enum.rst:26
msgid ""
"This module defines four enumeration classes that can be used to define "
"unique sets of names and values: :class:`Enum`, :class:`IntEnum`, "
":class:`Flag`, and :class:`IntFlag`.  It also defines one decorator, "
":func:`unique`, and one helper, :class:`auto`."
msgstr ""
"このモジュールでは一意の名前と値の集合を定義するのに使用できる 4 つの列挙型クラス :class:`Enum`, :class:`IntEnum`, :class:`Flag`, :class:`IntFlag` を定義しています。\n"
"このモジュールはデコレータの :func:`unique` とヘルパークラスの :class:`auto` も定義しています。"

#: ../../library/enum.rst:33
msgid ""
"Base class for creating enumerated constants.  See section `Functional API`_"
" for an alternate construction syntax."
msgstr "列挙型定数を作成する基底クラスです。もうひとつの構築構文については `機能 API`_ を参照してください。"

#: ../../library/enum.rst:38
msgid ""
"Base class for creating enumerated constants that are also subclasses of "
":class:`int`."
msgstr ":class:`int` のサブクラスでもある列挙型定数を作成する基底クラスです。"

#: ../../library/enum.rst:43
msgid ""
"Base class for creating enumerated constants that can be combined using the "
"bitwise operators without losing their :class:`IntFlag` membership. "
":class:`IntFlag` members are also subclasses of :class:`int`."
msgstr ""
"列挙型定数を作成する基底クラスで、ビット演算子を使って組み合わせられ、その結果も :class:`IntFlag` メンバーになります。\n"
":class:`IntFlag` は :class:`int` のサブクラスでもあります。"

#: ../../library/enum.rst:49
msgid ""
"Base class for creating enumerated constants that can be combined using the "
"bitwise operations without losing their :class:`Flag` membership."
msgstr "列挙型定数を作成する基底クラスで、ビット演算を使って組み合わせられ、その結果も :class:`IntFlag` メンバーになります。"

#: ../../library/enum.rst:54
msgid ""
"Enum class decorator that ensures only one name is bound to any one value."
msgstr "一つの名前だけがひとつの値に束縛されていることを保証する Enum クラスのデコレーターです。"

#: ../../library/enum.rst:58
msgid "Instances are replaced with an appropriate value for Enum members."
msgstr "このインスタンスは列挙型のメンバーのための適切な値に置き換えられます。"

#: ../../library/enum.rst:60
msgid "``Flag``, ``IntFlag``, ``auto``"
msgstr "``Flag``, ``IntFlag``, ``auto``"

#: ../../library/enum.rst:64
msgid "Creating an Enum"
msgstr "Enum の作成"

#: ../../library/enum.rst:66
msgid ""
"Enumerations are created using the :keyword:`class` syntax, which makes them"
" easy to read and write.  An alternative creation method is described in "
"`Functional API`_.  To define an enumeration, subclass :class:`Enum` as "
"follows::"
msgstr ""
"列挙型は読み書きが容易になるよう :keyword:`class` 文を使って作成します。もうひとつの作成方法は `機能 API`_ "
"で説明しています。列挙型は以下のように :class:`Enum` のサブクラスとして定義します::"

#: ../../library/enum.rst:78
msgid "Enum member values"
msgstr "列挙型のメンバー値"

#: ../../library/enum.rst:80
msgid ""
"Member values can be anything: :class:`int`, :class:`str`, etc..  If the "
"exact value is unimportant you may use :class:`auto` instances and an "
"appropriate value will be chosen for you.  Care must be taken if you mix "
":class:`auto` with other values."
msgstr ""
"メンバー値は何であっても構いません: :class:`int`, :class:`str` などなど。\n"
"正確な値が重要でない場合は、 :class:`auto` インスタンスを使っておくと、適切な値が選ばれます。\n"
":class:`auto` とそれ以外の値を混ぜて使う場合は注意する必要があります。"

#: ../../library/enum.rst:85
msgid "Nomenclature"
msgstr "用語"

#: ../../library/enum.rst:87
msgid "The class :class:`Color` is an *enumeration* (or *enum*)"
msgstr "クラス :class:`Color` は *列挙型* (または *Enum*) です"

#: ../../library/enum.rst:88
msgid ""
"The attributes :attr:`Color.RED`, :attr:`Color.GREEN`, etc., are "
"*enumeration members* (or *enum members*) and are functionally constants."
msgstr ""
"属性 :attr:`Color.RED`, :attr:`Color.GREEN` などは *列挙型のメンバー* (または *Enum メンバー*) "
"で、機能的には定数です。"

#: ../../library/enum.rst:90
msgid ""
"The enum members have *names* and *values* (the name of :attr:`Color.RED` is"
" ``RED``, the value of :attr:`Color.BLUE` is ``3``, etc.)"
msgstr ""
"列挙型のメンバーは *名前* と *値* を持ちます (:attr:`Color.RED` の名前は ``RED`` 、 "
":attr:`Color.BLUE` の値は ``3`` など。)"

#: ../../library/enum.rst:96
msgid ""
"Even though we use the :keyword:`class` syntax to create Enums, Enums are "
"not normal Python classes.  See `How are Enums different?`_ for more "
"details."
msgstr ""
"Enum の作成に :keyword:`class` 文を使用するものの、Enum は通常の Python クラスではありません。詳細は `Enum "
"はどう違うのか?`_ を参照してください。"

#: ../../library/enum.rst:100
msgid "Enumeration members have human readable string representations::"
msgstr "列挙型のメンバーは人が読める文字列表現を持ちます::"

#: ../../library/enum.rst:105
msgid "...while their ``repr`` has more information::"
msgstr "...その一方でそれらの ``repr`` はより多くの情報を持っています::"

#: ../../library/enum.rst:110
msgid "The *type* of an enumeration member is the enumeration it belongs to::"
msgstr "列挙型メンバーの *データ型* はそれが所属する列挙型になります::"

#: ../../library/enum.rst:118
msgid "Enum members also have a property that contains just their item name::"
msgstr "Enum メンバーは自身の名前を持つだけのプロパティも持っています::"

#: ../../library/enum.rst:123
msgid "Enumerations support iteration, in definition order::"
msgstr "列挙型は定義順でのイテレーションをサポートしています::"

#: ../../library/enum.rst:139
msgid ""
"Enumeration members are hashable, so they can be used in dictionaries and "
"sets::"
msgstr "列挙型のメンバーはハッシュ化可能なため、辞書や集合で使用できます::"

#: ../../library/enum.rst:149
msgid "Programmatic access to enumeration members and their attributes"
msgstr "列挙型メンバーおよびそれらの属性へのプログラム的アクセス"

#: ../../library/enum.rst:151
msgid ""
"Sometimes it's useful to access members in enumerations programmatically "
"(i.e. situations where ``Color.RED`` won't do because the exact color is not"
" known at program-writing time).  ``Enum`` allows such access::"
msgstr ""
"プログラム的にメンバーに番号でアクセスしたほうが便利な場合があります "
"(すなわち、プログラムを書いている時点で正確な色がまだわからなく、``Color.RED`` と書くのが無理な場合など)。 ``Enum`` "
"ではそのようなアクセスも可能です::"

#: ../../library/enum.rst:160
msgid "If you want to access enum members by *name*, use item access::"
msgstr "列挙型メンバーに *名前* でアクセスしたい場合はアイテムとしてアクセスできます::"

#: ../../library/enum.rst:167
msgid ""
"If you have an enum member and need its :attr:`name` or :attr:`value`::"
msgstr "列挙型メンバーの :attr:`name` か :attr:`value` が必要な場合::"

#: ../../library/enum.rst:177
msgid "Duplicating enum members and values"
msgstr "列挙型メンバーと値の重複"

#: ../../library/enum.rst:179
msgid "Having two enum members with the same name is invalid::"
msgstr "同じ名前の列挙型メンバーを複数持つことはできません::"

#: ../../library/enum.rst:189
msgid ""
"However, two enum members are allowed to have the same value.  Given two "
"members A and B with the same value (and A defined first), B is an alias to "
"A.  By-value lookup of the value of A and B will return A.  By-name lookup "
"of B will also return A::"
msgstr ""
"ただし、複数の列挙型メンバーが同じ値を持つことはできます。同じ値を持つ 2 つのメンバー A および B (先に定義したのは A) が与えられたとき、B"
" は A の別名になります。A および B を値で調べたとき、A が返されます。B を名前で調べたとき、A が返されます::"

#: ../../library/enum.rst:209
msgid ""
"Attempting to create a member with the same name as an already defined "
"attribute (another member, a method, etc.) or attempting to create an "
"attribute with the same name as a member is not allowed."
msgstr ""
"すでに定義されている属性と同じ名前のメンバー (一方がメンバーでもう一方がメソッド、など) の作成、あるいはメンバーと同じ名前の属性の作成はできません。"

#: ../../library/enum.rst:215
msgid "Ensuring unique enumeration values"
msgstr "番号付けの値が同一であることの確認"

#: ../../library/enum.rst:217
msgid ""
"By default, enumerations allow multiple names as aliases for the same value."
" When this behavior isn't desired, the following decorator can be used to "
"ensure each value is used only once in the enumeration:"
msgstr ""
"デフォルトでは、前述のように複数の名前への同じ値の定義は別名とすることで許されています。この挙動を望まない場合、以下のデコレーターを使用することで各値が列挙型内で一意かどうか確認できます:"

#: ../../library/enum.rst:223
msgid ""
"A :keyword:`class` decorator specifically for enumerations.  It searches an "
"enumeration's :attr:`__members__` gathering any aliases it finds; if any are"
" found :exc:`ValueError` is raised with the details::"
msgstr ""
"列挙型専用の :keyword:`class` デコレーターです。列挙型の :attr:`__members__` に別名がないかどうか検索します; "
"見つかった場合、:exc:`ValueError` が詳細情報とともに送出されます::"

#: ../../library/enum.rst:241
msgid "Using automatic values"
msgstr "値の自動設定を使う"

#: ../../library/enum.rst:243
msgid "If the exact value is unimportant you can use :class:`auto`::"
msgstr "正確な値が重要でない場合、 :class:`auto` が使えます::"

#: ../../library/enum.rst:254
msgid ""
"The values are chosen by :func:`_generate_next_value_`, which can be "
"overridden::"
msgstr "その値は :func:`_generate_next_value_` によって選ばれ、この関数はオーバーライドできます::"

#: ../../library/enum.rst:272
msgid ""
"The goal of the default :meth:`_generate_next_value_` methods is to provide "
"the next :class:`int` in sequence with the last :class:`int` provided, but "
"the way it does this is an implementation detail and may change."
msgstr ""
"デフォルトの :meth:`_generate_next_value_` メソッドの目的は、最後に提供した :class:`int` の次から順々に "
":class:`int` を提供することですが、この動作は実装詳細であり変更される可能性があります。"

#: ../../library/enum.rst:277
msgid "Iteration"
msgstr "イテレーション"

#: ../../library/enum.rst:279
msgid "Iterating over the members of an enum does not provide the aliases::"
msgstr "列挙型のメンバーのイテレートは別名をサポートしていません::"

#: ../../library/enum.rst:284
msgid ""
"The special attribute ``__members__`` is an ordered dictionary mapping names"
" to members.  It includes all names defined in the enumeration, including "
"the aliases::"
msgstr ""
"特殊属性 ``__members__`` "
"は名前をメンバーにマッピングする順序を記憶する辞書です。列挙型内で定義されたすべての名前を別名も含めて格納しています::"

#: ../../library/enum.rst:296
msgid ""
"The ``__members__`` attribute can be used for detailed programmatic access "
"to the enumeration members.  For example, finding all the aliases::"
msgstr "属性 ``__members__`` は列挙型メンバーへの詳細なアクセスに使用できます。以下はすべての別名を探す例です::"

#: ../../library/enum.rst:304
msgid "Comparisons"
msgstr "比較"

#: ../../library/enum.rst:306
msgid "Enumeration members are compared by identity::"
msgstr "列挙型メンバーは同一性を比較できます::"

#: ../../library/enum.rst:315
msgid ""
"Ordered comparisons between enumeration values are *not* supported.  Enum "
"members are not integers (but see `IntEnum`_ below)::"
msgstr ""
"列挙型の値の順序の比較はサポートされて *いません*。Enum メンバーは整数ではありません (`IntEnum`_ を参照してください)::"

#: ../../library/enum.rst:323
msgid "Equality comparisons are defined though::"
msgstr "ただし等価の比較は定義されています::"

#: ../../library/enum.rst:332
msgid ""
"Comparisons against non-enumeration values will always compare not equal "
"(again, :class:`IntEnum` was explicitly designed to behave differently, see "
"below)::"
msgstr ""
"非列挙型の値との比較は常に不等となります (繰り返しになりますが、:class:`IntEnum` はこれと異なる挙動になるよう設計されています)::"

#: ../../library/enum.rst:341
msgid "Allowed members and attributes of enumerations"
msgstr "列挙型で許されるメンバーと属性"

#: ../../library/enum.rst:343
msgid ""
"The examples above use integers for enumeration values.  Using integers is "
"short and handy (and provided by default by the `Functional API`_), but not "
"strictly enforced.  In the vast majority of use-cases, one doesn't care what"
" the actual value of an enumeration is.  But if the value *is* important, "
"enumerations can have arbitrary values."
msgstr ""
"上述の例では列挙型の値に整数を使用しています。整数の使用は短くて使いやすい (そして `機能 API`_ でデフォルトで提供されています) "
"のですが、厳密には強制ではありません。ほとんどの事例では列挙型の実際の値が何かを気にしていません。しかし、値が重要で *ある* "
"場合、列挙型は任意の値を持つことができます。"

#: ../../library/enum.rst:349
msgid ""
"Enumerations are Python classes, and can have methods and special methods as"
" usual.  If we have this enumeration::"
msgstr "列挙型は Python のクラスであり、通常どおりメソッドや特殊メソッドを持つことができます::"

#: ../../library/enum.rst:369
msgid "Then::"
msgstr "上記の結果が以下のようになります::"

#: ../../library/enum.rst:378
msgid ""
"The rules for what is allowed are as follows: names that start and end with "
"a single underscore are reserved by enum and cannot be used; all other "
"attributes defined within an enumeration will become members of this "
"enumeration, with the exception of special methods (:meth:`__str__`, "
":meth:`__add__`, etc.), descriptors (methods are also descriptors), and "
"variable names listed in :attr:`_ignore_`."
msgstr ""

#: ../../library/enum.rst:385
msgid ""
"Note:  if your enumeration defines :meth:`__new__` and/or :meth:`__init__` "
"then whatever value(s) were given to the enum member will be passed into "
"those methods.  See `Planet`_ for an example."
msgstr ""
"注意: 列挙型で :meth:`__new__` および/または :meth:`__init__` "
"を定義した場合、列挙型メンバーに与えられた値はすべてこれらのメソッドに渡されます。例 `Planet`_ を参照してください。"

#: ../../library/enum.rst:391
msgid "Restricted subclassing of enumerations"
msgstr "列挙型のサブクラス化の制限事項"

#: ../../library/enum.rst:393
msgid ""
"Subclassing an enumeration is allowed only if the enumeration does not "
"define any members.  So this is forbidden::"
msgstr "列挙型のサブクラスの作成はその列挙型にメンバーが一つも定義されていない場合のみ行なえます。従って以下は許されません::"

#: ../../library/enum.rst:403
msgid "But this is allowed::"
msgstr "以下のような場合は許されます::"

#: ../../library/enum.rst:414
msgid ""
"Allowing subclassing of enums that define members would lead to a violation "
"of some important invariants of types and instances.  On the other hand, it "
"makes sense to allow sharing some common behavior between a group of "
"enumerations. (See `OrderedEnum`_ for an example.)"
msgstr ""
"メンバーが定義された列挙型のサブクラス化を許可すると、いくつかのデータ型およびインスタンスの重要な不変条件の違反を引き起こします。とはいえ、それが許可されると、列挙型のグループ間での共通の挙動を共有するという利点もあります。"
" (`OrderedEnum`_ の例を参照してください。)"

#: ../../library/enum.rst:421
msgid "Pickling"
msgstr "Pickle 化"

#: ../../library/enum.rst:423
msgid "Enumerations can be pickled and unpickled::"
msgstr "列挙型は pickle 化と unpickle 化が行えます::"

#: ../../library/enum.rst:430
msgid ""
"The usual restrictions for pickling apply: picklable enums must be defined "
"in the top level of a module, since unpickling requires them to be "
"importable from that module."
msgstr ""
"通常の pickle 化の制限事項が適用されます: pickle 可能な列挙型はモジュールのトップレベルで定義されていなくてはならず、unpickle "
"化はモジュールからインポート可能でなければなりません。"

#: ../../library/enum.rst:436
msgid ""
"With pickle protocol version 4 it is possible to easily pickle enums nested "
"in other classes."
msgstr "pickle プロトコルバージョン 4 では他のクラスで入れ子になった列挙型の pickle 化も容易です。"

#: ../../library/enum.rst:439
msgid ""
"It is possible to modify how Enum members are pickled/unpickled by defining "
":meth:`__reduce_ex__` in the enumeration class."
msgstr ""
"Enum メンバーをどう pickle 化/unpickle 化するかは、列挙型クラス内の :meth:`__reduce_ex__` "
"で定義することで変更できます。"

#: ../../library/enum.rst:444
msgid "Functional API"
msgstr "機能 API"

#: ../../library/enum.rst:446
msgid ""
"The :class:`Enum` class is callable, providing the following functional "
"API::"
msgstr ":class:`Enum` クラスは呼び出し可能で、以下の機能 API を提供しています::"

#: ../../library/enum.rst:458
msgid ""
"The semantics of this API resemble :class:`~collections.namedtuple`. The "
"first argument of the call to :class:`Enum` is the name of the enumeration."
msgstr ""
"この API の動作は :class:`~collections.namedtuple` と似ています。:class:`Enum` 呼び出しの第 1 "
"引数は列挙型の名前です。"

#: ../../library/enum.rst:461
msgid ""
"The second argument is the *source* of enumeration member names.  It can be "
"a whitespace-separated string of names, a sequence of names, a sequence of "
"2-tuples with key/value pairs, or a mapping (e.g. dictionary) of names to "
"values.  The last two options enable assigning arbitrary values to "
"enumerations; the others auto-assign increasing integers starting with 1 "
"(use the ``start`` parameter to specify a different starting value).  A new "
"class derived from :class:`Enum` is returned.  In other words, the above "
"assignment to :class:`Animal` is equivalent to::"
msgstr ""
"第 2 引数は列挙型メンバー名の *ソース* です。空白で区切った名前の文字列、名前のシーケンス、キー/値のペアの 2 "
"要素タプルのシーケンス、あるいは名前と値のマッピング (例: 辞書) を指定できます。最後の 2 "
"個のオプションでは、列挙型へ任意の値を割り当てることができます。前の 2 つのオプションでは、1 から始まり増加していく整数を自動的に割り当てます "
"(別の開始値を指定するには、``start`` 引数を使用します)。:class:`Enum` "
"から派生した新しいクラスが返されます。言い換えれば、上記の :class:`Animal` への割り当ては以下と等価です::"

#: ../../library/enum.rst:477
msgid ""
"The reason for defaulting to ``1`` as the starting number and not ``0`` is "
"that ``0`` is ``False`` in a boolean sense, but enum members all evaluate to"
" ``True``."
msgstr ""
"デフォルトの開始番号が ``0`` ではなく ``1`` である理由は、``0`` がブール演算子では ``False`` "
"になりますが、すべての列挙型メンバーの評価は ``True`` でなければならないためです。"

#: ../../library/enum.rst:481
msgid ""
"Pickling enums created with the functional API can be tricky as frame stack "
"implementation details are used to try and figure out which module the "
"enumeration is being created in (e.g. it will fail if you use a utility "
"function in separate module, and also may not work on IronPython or Jython)."
" The solution is to specify the module name explicitly as follows::"
msgstr ""
"機能 API による Enum の pickle "
"化は、その列挙型がどのモジュールで作成されたかを見つけ出すためにフレームスタックの実装の詳細が使われるので、トリッキーになることがあります "
"(例えば別のモジュールのユーティリティ関数を使うと失敗しますし、IronPython や Jython "
"ではうまくいきません)。解決策は、以下のようにモジュール名を明示的に指定することです::"

#: ../../library/enum.rst:491
msgid ""
"If ``module`` is not supplied, and Enum cannot determine what it is, the new"
" Enum members will not be unpicklable; to keep errors closer to the source, "
"pickling will be disabled."
msgstr ""
"``module`` が与えられない場合、Enum はそれがなにか決定できないため、新しい Enum メンバーは unpickle 化できなくなります;"
" エラーをソースの近いところで発生させるため、pickle 化は無効になります。"

#: ../../library/enum.rst:495
msgid ""
"The new pickle protocol 4 also, in some circumstances, relies on "
":attr:`~definition.__qualname__` being set to the location where pickle will"
" be able to find the class.  For example, if the class was made available in"
" class SomeData in the global scope::"
msgstr ""
"新しい pickle プロトコルバージョン 4 では、一部の状況において、pickle がクラスを発見するための場所の設定に "
":attr:`~definition.__qualname__` を参照します。例えば、そのクラスがグローバルスコープ内のクラス SomeData "
"内で利用可能とするには以下のように指定します::"

#: ../../library/enum.rst:502
msgid "The complete signature is::"
msgstr "完全な構文は以下のようになります::"

#: ../../library/enum.rst:0
msgid "value"
msgstr "value"

#: ../../library/enum.rst:506
msgid "What the new Enum class will record as its name."
msgstr "新しい Enum クラスに記録されるそれ自身の名前です。"

#: ../../library/enum.rst:0
msgid "names"
msgstr "名前"

#: ../../library/enum.rst:508
msgid ""
"The Enum members.  This can be a whitespace or comma separated string "
"(values will start at 1 unless otherwise specified)::"
msgstr ""
"Enum のメンバーです。\n"
"空白またはカンマで区切った文字列でも構いません (特に指定がない限り、値は 1 から始まります)::"

#: ../../library/enum.rst:513
msgid "or an iterator of names::"
msgstr "または名前のイテレータで指定もできます::"

#: ../../library/enum.rst:517
msgid "or an iterator of (name, value) pairs::"
msgstr "または (名前, 値) のペアのイテレータでも指定できます::"

#: ../../library/enum.rst:521
msgid "or a mapping::"
msgstr "またはマッピングでも指定できます::"

#: ../../library/enum.rst:0
msgid "module"
msgstr "module"

#: ../../library/enum.rst:525
msgid "name of module where new Enum class can be found."
msgstr "新しい Enum クラスが属するモジュールの名前です。"

#: ../../library/enum.rst:0
msgid "qualname"
msgstr ""

#: ../../library/enum.rst:527
msgid "where in module new Enum class can be found."
msgstr "新しい Enum クラスが属するモジュールの場所です。"

#: ../../library/enum.rst:0
msgid "type"
msgstr "type"

#: ../../library/enum.rst:529
msgid "type to mix in to new Enum class."
msgstr "新しい Enum クラスに複合されるデータ型です。"

#: ../../library/enum.rst:0
msgid "start"
msgstr ""

#: ../../library/enum.rst:531
msgid "number to start counting at if only names are passed in."
msgstr "names のみが渡されたときにカウントを開始する数です。"

#: ../../library/enum.rst:533
msgid "The *start* parameter was added."
msgstr "*start* 引数が追加されました。"

#: ../../library/enum.rst:538
msgid "Derived Enumerations"
msgstr "派生列挙型"

#: ../../library/enum.rst:541
msgid "IntEnum"
msgstr "IntEnum"

#: ../../library/enum.rst:543
msgid ""
"The first variation of :class:`Enum` that is provided is also a subclass of "
":class:`int`.  Members of an :class:`IntEnum` can be compared to integers; "
"by extension, integer enumerations of different types can also be compared "
"to each other::"
msgstr ""
"提供されている 1 つ目の :class:`Enum` の派生型であり、 :class:`int` のサブクラスでもあります。\n"
":class:`IntEnum` のメンバーは整数と比較できます;\n"
"さらに言うと、異なる整数列挙型どうしでも比較できます::"

#: ../../library/enum.rst:564
msgid ""
"However, they still can't be compared to standard :class:`Enum` "
"enumerations::"
msgstr "ただし、これらも標準の :class:`Enum` 列挙型とは比較できません::"

#: ../../library/enum.rst:577
msgid ""
":class:`IntEnum` values behave like integers in other ways you'd expect::"
msgstr ":class:`IntEnum` の値は他の用途では整数のように振る舞います::"

#: ../../library/enum.rst:588
msgid "IntFlag"
msgstr "IntFlag"

#: ../../library/enum.rst:590
msgid ""
"The next variation of :class:`Enum` provided, :class:`IntFlag`, is also "
"based on :class:`int`.  The difference being :class:`IntFlag` members can be"
" combined using the bitwise operators (&, \\|, ^, ~) and the result is still"
" an :class:`IntFlag` member.  However, as the name implies, :class:`IntFlag`"
" members also subclass :class:`int` and can be used wherever an :class:`int`"
" is used.  Any operation on an :class:`IntFlag` member besides the bit-wise "
"operations will lose the :class:`IntFlag` membership."
msgstr ""
"提供されている 2 つ目の :class:`Enum` の派生型 :class:`IntFlag` も :class:`int` を基底クラスとしています。\n"
":class:`IntFlag` メンバーが  :class:`Enum` メンバーと異なるのは、ビット演算子 (&, \\|, ^, ~) を使って組み合わせられ、その結果も :class:`IntFlag` メンバーになることです。\n"
"しかし、名前が示すように、 :class:`IntFlag` は :class:`int` のサブクラスでもあり、 :class:`int` が使われるところでもどこでも使えます。\n"
":class:`IntFlag` メンバーに対してビット演算以外のどんな演算をしても、その結果は :class:`IntFlag` メンバーではなくなります。"

#: ../../library/enum.rst:600
msgid "Sample :class:`IntFlag` class::"
msgstr ":class:`IntFlag` クラスの例::"

#: ../../library/enum.rst:616
msgid "It is also possible to name the combinations::"
msgstr "組み合わせにも名前を付けられます::"

#: ../../library/enum.rst:628
msgid ""
"Another important difference between :class:`IntFlag` and :class:`Enum` is "
"that if no flags are set (the value is 0), its boolean evaluation is "
":data:`False`::"
msgstr ""
":class:`IntFlag` と :class:`Enum` のもう 1 つの重要な違いは、フラグが設定されていない (値が0である) "
"場合、その真偽値としての評価は :data:`False` になることです::"

#: ../../library/enum.rst:636
msgid ""
"Because :class:`IntFlag` members are also subclasses of :class:`int` they "
"can be combined with them::"
msgstr ":class:`IntFlag` は :class:`int` のサブクラスでもあるので、その両者を組み合わせられます::"

#: ../../library/enum.rst:644
msgid "Flag"
msgstr "Flag"

#: ../../library/enum.rst:646
msgid ""
"The last variation is :class:`Flag`.  Like :class:`IntFlag`, :class:`Flag` "
"members can be combined using the bitwise operators (&, \\|, ^, ~).  Unlike "
":class:`IntFlag`, they cannot be combined with, nor compared against, any "
"other :class:`Flag` enumeration, nor :class:`int`.  While it is possible to "
"specify the values directly it is recommended to use :class:`auto` as the "
"value and let :class:`Flag` select an appropriate value."
msgstr ""
"最後の派生型は :class:`Flag` です。\n"
":class:`IntFlag` と同様に、 :class:`Flag` メンバーもビット演算子 (&, \\|, ^, ~) を使って組み合わせられます。\n"
"しかし :class:`IntFlag` とは違い、他のどの :class:`Flag` 列挙型とも :class:`int` とも組み合わせたり、比較したりできません。\n"
"値を直接指定することも可能ですが、値として :class:`auto` を使い、 :class:`Flag` に適切な値を選ばせることが推奨されています。"

#: ../../library/enum.rst:655
msgid ""
"Like :class:`IntFlag`, if a combination of :class:`Flag` members results in "
"no flags being set, the boolean evaluation is :data:`False`::"
msgstr ""
":class:`IntFlag` と同様に、 :class:`Flag` "
"メンバーの組み合わせがどのフラグも設定されていない状態になった場合、その真偽値としての評価は :data:`False` となります::"

#: ../../library/enum.rst:669
msgid ""
"Individual flags should have values that are powers of two (1, 2, 4, 8, "
"...), while combinations of flags won't::"
msgstr "個別のフラグは 2 のべき乗 (1, 2, 4, 8, ...) の値を持つべきですが、フラグの組み合わせはそうはなりません::"

#: ../../library/enum.rst:681
msgid ""
"Giving a name to the \"no flags set\" condition does not change its boolean "
"value::"
msgstr "\"フラグが設定されていない\" 状態に名前を付けても、その真偽値は変わりません::"

#: ../../library/enum.rst:697
msgid ""
"For the majority of new code, :class:`Enum` and :class:`Flag` are strongly "
"recommended, since :class:`IntEnum` and :class:`IntFlag` break some semantic"
" promises of an enumeration (by being comparable to integers, and thus by "
"transitivity to other unrelated enumerations).  :class:`IntEnum` and "
":class:`IntFlag` should be used only in cases where :class:`Enum` and "
":class:`Flag` will not do; for example, when integer constants are replaced "
"with enumerations, or for interoperability with other systems."
msgstr ""
"ほとんどの新しいコードでは、 :class:`Enum` と :class:`Flag` が強く推奨されます。\n"
"というのは、 :class:`IntEnum` と :class:`IntFlag` は (整数と比較でき、従って推移的に他の無関係な列挙型と比較できてしまうことにより) 列挙型の意味論的な約束に反するからです。\n"
":class:`IntEnum` と :class:`IntFlag` は、 :class:`Enum` や :class:`Flag` では上手くいかない場合のみに使うべきです;\n"
"例えば、整数定数を列挙型で置き換えるときや、他のシステムとの相互運用性を持たせたいときです。"

#: ../../library/enum.rst:707
msgid "Others"
msgstr "その他"

#: ../../library/enum.rst:709
msgid ""
"While :class:`IntEnum` is part of the :mod:`enum` module, it would be very "
"simple to implement independently::"
msgstr ":class:`IntEnum` は :mod:`enum` モジュールの一部ですが、単独での実装もとても簡単に行なえます::"

#: ../../library/enum.rst:715
msgid ""
"This demonstrates how similar derived enumerations can be defined; for "
"example a :class:`StrEnum` that mixes in :class:`str` instead of "
":class:`int`."
msgstr ""
"ここでは似たような列挙型の派生を定義する方法を紹介します; 例えば、:class:`StrEnum` は :class:`int` ではなく "
":class:`str` で複合させたものです。"

#: ../../library/enum.rst:718
msgid "Some rules:"
msgstr "いくつかのルール:"

#: ../../library/enum.rst:720
msgid ""
"When subclassing :class:`Enum`, mix-in types must appear before "
":class:`Enum` itself in the sequence of bases, as in the :class:`IntEnum` "
"example above."
msgstr ""
":class:`Enum` のサブクラスを作成するとき、複合させるデータ型は、基底クラスの並びで :class:`Enum` "
"自身より先に記述しなければなりません (上記 :class:`IntEnum` の例を参照)。"

#: ../../library/enum.rst:723
msgid ""
"While :class:`Enum` can have members of any type, once you mix in an "
"additional type, all the members must have values of that type, e.g. "
":class:`int` above.  This restriction does not apply to mix-ins which only "
"add methods and don't specify another data type such as :class:`int` or "
":class:`str`."
msgstr ""
":class:`Enum` のメンバーはどんなデータ型でも構いませんが、追加のデータ型 (例えば、上の例の :class:`int`) と複合させてしまうと、すべてのメンバーの値はそのデータ型でなければならなくなります。\n"
"この制限は、メソッドの追加するだけの、 :class:`int` や :class:`str` のような他のデータ型を指定しない複合には適用されません。"

#: ../../library/enum.rst:728
msgid ""
"When another data type is mixed in, the :attr:`value` attribute is *not the "
"same* as the enum member itself, although it is equivalent and will compare "
"equal."
msgstr ""
"他のデータ型と複合された場合、 :attr:`value` 属性は、たとえ等価であり等価であると比較が行えても、列挙型メンバー自身としては "
"*同じではありません* 。"

#: ../../library/enum.rst:731
msgid ""
"%-style formatting:  `%s` and `%r` call the :class:`Enum` class's "
":meth:`__str__` and :meth:`__repr__` respectively; other codes (such as `%i`"
" or `%h` for IntEnum) treat the enum member as its mixed-in type."
msgstr ""
"%-方式の書式:  `%s` および `%r` はそれぞれ :class:`Enum` クラスの :meth:`__str__` および :meth:`__repr__` を呼び出します;\n"
"その他のコード (IntEnum の `%i` や `%h` など) は列挙型のメンバーを複合されたデータ型として扱います。"

#: ../../library/enum.rst:734
msgid ""
":ref:`Formatted string literals <f-strings>`, :meth:`str.format`, and "
":func:`format` will use the mixed-in type's :meth:`__format__`.  If the "
":class:`Enum` class's :func:`str` or :func:`repr` is desired, use the `!s` "
"or `!r` format codes."
msgstr ""
":ref:`フォーマット済み文字列リテラル <f-strings>` 、 :meth:`str.format` 、 :func:`format` では、複合されたデータ型の :meth:`__format__` が使われます。\n"
":class:`Enum` クラスの :func:`str` や :func:`repr` を使って欲しいときは、フォーマットのコードで `!s` および `!r` を使ってください。"

#: ../../library/enum.rst:741
msgid "Interesting examples"
msgstr "興味深い例"

#: ../../library/enum.rst:743
msgid ""
"While :class:`Enum`, :class:`IntEnum`, :class:`IntFlag`, and :class:`Flag` "
"are expected to cover the majority of use-cases, they cannot cover them all."
"  Here are recipes for some different types of enumerations that can be used"
" directly, or as examples for creating one's own."
msgstr ""
":class:`Enum`, :class:`IntEnum`, :class:`IntFlag`, :class:`Flag` は用途の大部分をカバーすると予想されますが、そのすべてをカバーできているわけではありません。\n"
"ここでは、そのまま、あるいは独自の列挙型を作る例として使える、様々なタイプの列挙型を紹介します。"

#: ../../library/enum.rst:750
msgid "Omitting values"
msgstr "値の省略"

#: ../../library/enum.rst:752
msgid ""
"In many use-cases one doesn't care what the actual value of an enumeration "
"is. There are several ways to define this type of simple enumeration:"
msgstr ""
"多くの用途では、列挙型の実際の値が何かは気にされません。\n"
"このタイプの単純な列挙型を定義する方法はいくつかあります:"

#: ../../library/enum.rst:755
msgid "use instances of :class:`auto` for the value"
msgstr "値に :class:`auto` インスタンスを使用する"

#: ../../library/enum.rst:756
msgid "use instances of :class:`object` as the value"
msgstr "値として :class:`object` インスタンスを使用する"

#: ../../library/enum.rst:757
msgid "use a descriptive string as the value"
msgstr "値として解説文字列を使用する"

#: ../../library/enum.rst:758
msgid ""
"use a tuple as the value and a custom :meth:`__new__` to replace the tuple "
"with an :class:`int` value"
msgstr "値としてタプルを使用し、独自の :meth:`__new__` を使用してタプルを :class:`int` 値で置き換える"

#: ../../library/enum.rst:761
msgid ""
"Using any of these methods signifies to the user that these values are not "
"important, and also enables one to add, remove, or reorder members without "
"having to renumber the remaining members."
msgstr ""
"これらのどの方法を使ってもユーザーに対して、値は重要ではなく、他のメンバーの番号の振り直しをする必要無しに、メンバーの追加、削除、並べ替えが行えるということを示せます。"

#: ../../library/enum.rst:765
msgid ""
"Whichever method you choose, you should provide a :meth:`repr` that also "
"hides the (unimportant) value::"
msgstr "どの方法を選んでも、(重要でない) 値を隠す :meth:`repr` を提供すべきです::"

#: ../../library/enum.rst:775
msgid "Using :class:`auto`"
msgstr ":class:`auto` を使う"

#: ../../library/enum.rst:777
msgid "Using :class:`auto` would look like::"
msgstr ":class:`auto` を使うと次のようになります::"

#: ../../library/enum.rst:789
msgid "Using :class:`object`"
msgstr ":class:`object` を使う"

#: ../../library/enum.rst:791
msgid "Using :class:`object` would look like::"
msgstr ":class:`object` を使うと次のようになります::"

#: ../../library/enum.rst:803
msgid "Using a descriptive string"
msgstr "解説文字列を使う"

#: ../../library/enum.rst:805
msgid "Using a string as the value would look like::"
msgstr "値として文字列を使うと次のようになります::"

#: ../../library/enum.rst:819
msgid "Using a custom :meth:`__new__`"
msgstr "独自の :meth:`__new__` を使う"

#: ../../library/enum.rst:821
msgid "Using an auto-numbering :meth:`__new__` would look like::"
msgstr "自動で番号を振る :meth:`__new__` を使うと次のようになります::"

#: ../../library/enum.rst:843
msgid ""
"The :meth:`__new__` method, if defined, is used during creation of the Enum "
"members; it is then replaced by Enum's :meth:`__new__` which is used after "
"class creation for lookup of existing members."
msgstr ""
":meth:`__new__` メソッドが定義されていれば、Enum 番号の作成時に使用されます; これは Enum の :meth:`__new__`"
" と置き換えられ、クラスが作成された後の既存の番号を取得に使用されます。"

#: ../../library/enum.rst:849
msgid "OrderedEnum"
msgstr "OrderedEnum"

#: ../../library/enum.rst:851
msgid ""
"An ordered enumeration that is not based on :class:`IntEnum` and so "
"maintains the normal :class:`Enum` invariants (such as not being comparable "
"to other enumerations)::"
msgstr ""
":class:`IntEnum` をベースとしないため、通常の :class:`Enum` の不変条件 (他の列挙型と比較できないなど) "
"のままで、メンバーを順序付けできる列挙型です::"

#: ../../library/enum.rst:885
msgid "DuplicateFreeEnum"
msgstr "DuplicateFreeEnum"

#: ../../library/enum.rst:887
msgid ""
"Raises an error if a duplicate member name is found instead of creating an "
"alias::"
msgstr "値が同じメンバーが見つかった場合、別名を作るのではなく、エラーを送出します::"

#: ../../library/enum.rst:912
msgid ""
"This is a useful example for subclassing Enum to add or change other "
"behaviors as well as disallowing aliases.  If the only desired change is "
"disallowing aliases, the :func:`unique` decorator can be used instead."
msgstr ""
"これは Enum に別名を無効にするのと同様な振る舞いの追加や変更をおこなうためのサブクラス化に役立つ例です。単に別名を無効にしたいだけなら、 "
":func:`unique` デコレーターを使用して行えます。"

#: ../../library/enum.rst:918
msgid "Planet"
msgstr "Planet"

#: ../../library/enum.rst:920
msgid ""
"If :meth:`__new__` or :meth:`__init__` is defined the value of the enum "
"member will be passed to those methods::"
msgstr ""
":meth:`__new__` や :meth:`__init__` が定義されている場合、列挙型メンバーの値はこれらのメソッドに渡されます::"

#: ../../library/enum.rst:948
msgid "TimePeriod"
msgstr ""

#: ../../library/enum.rst:950
msgid "An example to show the :attr:`_ignore_` attribute in use::"
msgstr ""

#: ../../library/enum.rst:967
msgid "How are Enums different?"
msgstr "Enum はどう違うのか?"

#: ../../library/enum.rst:969
msgid ""
"Enums have a custom metaclass that affects many aspects of both derived Enum"
" classes and their instances (members)."
msgstr "Enum は Enum 派生クラスやそれらのインスタンス (メンバー) 双方の多くの側面に影響を及ぼすカスタムメタクラスを持っています。"

#: ../../library/enum.rst:974
msgid "Enum Classes"
msgstr "Enum クラス"

#: ../../library/enum.rst:976
msgid ""
"The :class:`EnumMeta` metaclass is responsible for providing the "
":meth:`__contains__`, :meth:`__dir__`, :meth:`__iter__` and other methods "
"that allow one to do things with an :class:`Enum` class that fail on a "
"typical class, such as `list(Color)` or `some_enum_var in Color`.  "
":class:`EnumMeta` is responsible for ensuring that various other methods on "
"the final :class:`Enum` class are correct (such as :meth:`__new__`, "
":meth:`__getnewargs__`, :meth:`__str__` and :meth:`__repr__`)."
msgstr ""

#: ../../library/enum.rst:986
msgid "Enum Members (aka instances)"
msgstr "Enum メンバー (インスタンス)"

#: ../../library/enum.rst:988
msgid ""
"The most interesting thing about Enum members is that they are singletons. "
":class:`EnumMeta` creates them all while it is creating the :class:`Enum` "
"class itself, and then puts a custom :meth:`__new__` in place to ensure that"
" no new ones are ever instantiated by returning only the existing member "
"instances."
msgstr ""
"Enum メンバーについて最も興味深いのは、それらがシングルトンであるということです。:class:`EnumMeta` は :class:`Enum`"
" 自身を作成し、メンバーを作成し、新しいインスタンスが作成されていないかどうかを確認するために既存のメンバーインスタンスだけを返すカスタム "
":meth:`__new__` を追加します。"

#: ../../library/enum.rst:996
msgid "Finer Points"
msgstr "細かい点"

#: ../../library/enum.rst:999
msgid "Supported ``__dunder__`` names"
msgstr "``__dunder__`` 名のサポート"

#: ../../library/enum.rst:1001
msgid ""
":attr:`__members__` is an :class:`OrderedDict` of ``member_name``:``member``"
" items.  It is only available on the class."
msgstr ""
":attr:`__members__` は ``member_name``:``member`` を要素とする :class:`OrderedDict` です。\n"
"これはクラスでのみ利用可能です。"

#: ../../library/enum.rst:1004
msgid ""
":meth:`__new__`, if specified, must create and return the enum members; it "
"is also a very good idea to set the member's :attr:`_value_` appropriately."
"  Once all the members are created it is no longer used."
msgstr ""
":meth:`__new__` が、もし指定されていた場合、列挙型のメンバーを作成し、返します;\n"
"そのメンバー の :attr:`_value_` を適切に設定するのも非常によい考えです。\n"
"いったん全てのメンバーが作成されると、それ以降 :meth:`__new__` は使われません。"

#: ../../library/enum.rst:1010
msgid "Supported ``_sunder_`` names"
msgstr "``_sunder_`` 名のサポート"

#: ../../library/enum.rst:1012
msgid "``_name_`` -- name of the member"
msgstr "``_name_`` -- メンバー名"

#: ../../library/enum.rst:1013
msgid ""
"``_value_`` -- value of the member; can be set / modified in ``__new__``"
msgstr "``_value_`` -- メンバーの値; ``__new__`` で設定したり、変更したりできます"

#: ../../library/enum.rst:1015
msgid ""
"``_missing_`` -- a lookup function used when a value is not found; may be "
"overridden"
msgstr "``_missing_`` -- 値が見付からなかったときに使われる検索関数; オーバーライドされていることがあります"

#: ../../library/enum.rst:1017
msgid ""
"``_ignore_`` -- a list of names, either as a :func:`list` or a :func:`str`, "
"that will not be transformed into members, and will be removed from the "
"final class"
msgstr ""

#: ../../library/enum.rst:1020
msgid ""
"``_order_`` -- used in Python 2/3 code to ensure member order is consistent "
"(class attribute, removed during class creation)"
msgstr ""

#: ../../library/enum.rst:1022
msgid ""
"``_generate_next_value_`` -- used by the `Functional API`_ and by "
":class:`auto` to get an appropriate value for an enum member; may be "
"overridden"
msgstr ""

#: ../../library/enum.rst:1026
msgid "``_missing_``, ``_order_``, ``_generate_next_value_``"
msgstr "``_missing_``, ``_order_``, ``_generate_next_value_``"

#: ../../library/enum.rst:1027
msgid "``_ignore_``"
msgstr ""

#: ../../library/enum.rst:1029
msgid ""
"To help keep Python 2 / Python 3 code in sync an :attr:`_order_` attribute "
"can be provided.  It will be checked against the actual order of the "
"enumeration and raise an error if the two do not match::"
msgstr ""

#: ../../library/enum.rst:1045
msgid ""
"In Python 2 code the :attr:`_order_` attribute is necessary as definition "
"order is lost before it can be recorded."
msgstr ""

#: ../../library/enum.rst:1049
msgid "``Enum`` member type"
msgstr "``Enum`` メンバー型"

#: ../../library/enum.rst:1051
msgid ""
":class:`Enum` members are instances of their :class:`Enum` class, and are "
"normally accessed as ``EnumClass.member``.  Under certain circumstances they"
" can also be accessed as ``EnumClass.member.member``, but you should never "
"do this as that lookup may fail or, worse, return something besides the "
":class:`Enum` member you are looking for (this is another good reason to use"
" all-uppercase names for members)::"
msgstr ""
":class:`Enum` メンバーは、それらの :class:`Enum` クラスのインスタンスで、通常は ``EnumClass.member`` のようにアクセスします。\n"
"ある状況下では、 ``EnumClass.member.member`` としてもアクセスできますが、この方法は絶対に使うべきではありません。\n"
"というのは、この検索は失敗するか、さらに悪い場合には、探している :class:`Enum` メンバー以外のものを返す場合もあるからです (これがメンバーの名前に大文字のみを使うのが良い理由の 1 つでもあります)::"

#: ../../library/enum.rst:1072
msgid "Boolean value of ``Enum`` classes and members"
msgstr "``Enum`` クラスとメンバーの真偽値"

#: ../../library/enum.rst:1074
msgid ""
":class:`Enum` members that are mixed with non-:class:`Enum` types (such as "
":class:`int`, :class:`str`, etc.) are evaluated according to the mixed-in "
"type's rules; otherwise, all members evaluate as :data:`True`.  To make your"
" own Enum's boolean evaluation depend on the member's value add the "
"following to your class::"
msgstr ""
"(:class:`int`, :class:`str` などのような) 非 :class:`Enum` 型と複合させた :class:`Enum` のメンバーは、その複合された型の規則に従って評価されます;\n"
"そうでない場合は、全てのメンバーは :data:`True` と評価されます。\n"
"メンバーの値に依存する独自の Enum の真偽値評価を行うには、クラスに次のコードを追加してください::"

#: ../../library/enum.rst:1083
msgid ":class:`Enum` classes always evaluate as :data:`True`."
msgstr ":class:`Enum` クラスは常に :data:`True` と評価されます。"

#: ../../library/enum.rst:1087
msgid "``Enum`` classes with methods"
msgstr "メソッド付きの ``Enum`` クラス"

#: ../../library/enum.rst:1089
msgid ""
"If you give your :class:`Enum` subclass extra methods, like the `Planet`_ "
"class above, those methods will show up in a :func:`dir` of the member, but "
"not of the class::"
msgstr ""
":class:`Enum` サブクラスに追加のメソッドを与えた場合、上述の `Planet`_ クラスのように、そのメソッドはメンバーの "
":func:`dir` に表示されますが、クラスの :func:`dir` には表示されません::"

#: ../../library/enum.rst:1100
msgid "Combining members of ``Flag``"
msgstr "``Flag`` のメンバーの組み合わせ"

#: ../../library/enum.rst:1102
msgid ""
"If a combination of Flag members is not named, the :func:`repr` will include"
" all named flags and all named combinations of flags that are in the value::"
msgstr ""
"Flag メンバーの組み合わせに名前が無い場合、 :func:`repr` "
"の出力には、その値にある全ての名前を持つフラグと全ての名前を持つ組み合わせが含まれます::"