enum.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-12-29 11:18+0000\n"
"PO-Revision-Date: 2024-12-21 13:50+0800\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\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/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 ""
"This page contains the API reference information. For tutorial information "
"and discussion of more advanced topics, see"
msgstr "本頁包含 API 的參考資訊。關於教學資訊及更多進階主題的討論請參考"

#: ../../library/enum.rst:21
msgid ":ref:`Basic Tutorial <enum-basic-tutorial>`"
msgstr ":ref:`基本教學 <enum-basic-tutorial>`"

#: ../../library/enum.rst:22
msgid ":ref:`Advanced Tutorial <enum-advanced-tutorial>`"
msgstr ":ref:`進階教學 <enum-advanced-tutorial>`"

#: ../../library/enum.rst:23
msgid ":ref:`Enum Cookbook <enum-cookbook>`"
msgstr ":ref:`列舉指南 <enum-cookbook>`"

#: ../../library/enum.rst:27
msgid "An enumeration:"
msgstr "列舉："

#: ../../library/enum.rst:29
msgid "is a set of symbolic names (members) bound to unique values"
msgstr "是一組綁定唯一值的代表名稱（成員）"

#: ../../library/enum.rst:30
msgid ""
"can be iterated over to return its canonical (i.e. non-alias) members in "
"definition order"
msgstr "可以用疊代的方式以定義的順序回傳其正式 (canonical)（即非別名）成員"

#: ../../library/enum.rst:32
msgid "uses *call* syntax to return members by value"
msgstr "使用 *call* 語法來透過值回傳成員"

#: ../../library/enum.rst:33
msgid "uses *index* syntax to return members by name"
msgstr "使用 *index* 語法來透過名稱回傳成員"

#: ../../library/enum.rst:35
msgid ""
"Enumerations are created either by using :keyword:`class` syntax, or by "
"using function-call syntax::"
msgstr "列舉透過 :keyword:`class` 語法或函式呼叫的語法來建立： ::"

#: ../../library/enum.rst:38
msgid ""
">>> from enum import Enum\n"
"\n"
">>> # class syntax\n"
">>> class Color(Enum):\n"
"...     RED = 1\n"
"...     GREEN = 2\n"
"...     BLUE = 3\n"
"\n"
">>> # functional syntax\n"
">>> Color = Enum('Color', [('RED', 1), ('GREEN', 2), ('BLUE', 3)])"
msgstr ""
">>> from enum import Enum\n"
"\n"
">>> # class 語法\n"
">>> class Color(Enum):\n"
"...     RED = 1\n"
"...     GREEN = 2\n"
"...     BLUE = 3\n"
"\n"
">>> # 函式語法\n"
">>> Color = Enum('Color', [('RED', 1), ('GREEN', 2), ('BLUE', 3)])"

#: ../../library/enum.rst:49
msgid ""
"Even though we can use :keyword:`class` syntax to create Enums, Enums are "
"not normal Python classes.  See :ref:`How are Enums different? <enum-class-"
"differences>` for more details."
msgstr ""
"雖然我們可以用 :keyword:`class` 語法來建立列舉，列舉並不是標準的 Python 類"
"別。參考\\ :ref:`列舉有何差異 <enum-class-differences>`\\ 以取得更多細節。"

#: ../../library/enum.rst:53
msgid "Nomenclature"
msgstr "命名方式"

#: ../../library/enum.rst:55
msgid "The class :class:`!Color` is an *enumeration* (or *enum*)"
msgstr ":class:`!Color` 類別是一個\\ *列舉*\\ （或 *enum*）"

#: ../../library/enum.rst:56
msgid ""
"The attributes :attr:`!Color.RED`, :attr:`!Color.GREEN`, etc., are "
"*enumeration members* (or *members*) and are functionally constants."
msgstr ""
":attr:`!Color.RED`、:attr:`!Color.GREEN` 等屬性是\\ *列舉成員*\\ （或\\ *成員"
"*），並且使用上可以看作常數。"

#: ../../library/enum.rst:58
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:65
msgid "Module Contents"
msgstr "模組內容"

#: ../../library/enum.rst:67
msgid ":class:`EnumType`"
msgstr ":class:`EnumType`"

#: ../../library/enum.rst:69
msgid "The ``type`` for Enum and its subclasses."
msgstr "Enum 及其子類別的 ``type``。"

#: ../../library/enum.rst:71
msgid ":class:`Enum`"
msgstr ":class:`Enum`"

#: ../../library/enum.rst:73
msgid "Base class for creating enumerated constants."
msgstr "用來建立列舉常數的基礎類別。"

#: ../../library/enum.rst:75
msgid ":class:`IntEnum`"
msgstr ":class:`IntEnum`"

#: ../../library/enum.rst:77
msgid ""
"Base class for creating enumerated constants that are also subclasses of :"
"class:`int`. (`Notes`_)"
msgstr ""
"用來建立列舉常數的基礎類別，同時也是 :class:`int` 的子類別。（`備註 "
"<Notes_>`_）"

#: ../../library/enum.rst:80
msgid ":class:`StrEnum`"
msgstr ":class:`StrEnum`"

#: ../../library/enum.rst:82
msgid ""
"Base class for creating enumerated constants that are also subclasses of :"
"class:`str`. (`Notes`_)"
msgstr ""
"用來建立列舉常數的基礎類別，同時也是 :class:`str` 的子類別。（`備註 "
"<Notes_>`_）"

#: ../../library/enum.rst:85
msgid ":class:`Flag`"
msgstr ":class:`Flag`"

#: ../../library/enum.rst:87
msgid ""
"Base class for creating enumerated constants that can be combined using the "
"bitwise operations without losing their :class:`Flag` membership."
msgstr ""
"用來建立列舉常數的基礎類別，可以使用位元操作來結合成員且其結果不失去 :class:"
"`Flag` 的成員資格。"

#: ../../library/enum.rst:90
msgid ":class:`IntFlag`"
msgstr ":class:`IntFlag`"

#: ../../library/enum.rst:92
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`. (`Notes`_)"
msgstr ""
"用來建立列舉常數的基礎類別，可以使用位元操作來結合成員且其結果不失去 :class:"
"`IntFlag` 的成員資格。:class:`IntFlag` 的成員也是 :class:`int` 的子類別。（`"
"備註 <Notes_>`_）"

#: ../../library/enum.rst:96
msgid ":class:`ReprEnum`"
msgstr ":class:`ReprEnum`"

#: ../../library/enum.rst:98
msgid ""
"Used by :class:`IntEnum`, :class:`StrEnum`, and :class:`IntFlag` to keep "
"the :class:`str() <str>` of the mixed-in type."
msgstr ""
"由 :class:`IntEnum`、:class:`StrEnum` 及 :class:`IntFlag` 所使用來保留這些混"
"合型別的 :class:`str() <str>`。"

#: ../../library/enum.rst:101
msgid ":class:`EnumCheck`"
msgstr ":class:`EnumCheck`"

#: ../../library/enum.rst:103
msgid ""
"An enumeration with the values ``CONTINUOUS``, ``NAMED_FLAGS``, and "
"``UNIQUE``, for use with :func:`verify` to ensure various constraints are "
"met by a given enumeration."
msgstr ""
"一個有 ``CONTINUOUS``、``NAMED_FLAGS`` 及 ``UNIQUE`` 這些值的列舉，和 :func:"
"`verify` 一起使用來確保給定的列舉符合多種限制。"

#: ../../library/enum.rst:107
msgid ":class:`FlagBoundary`"
msgstr ":class:`FlagBoundary`"

#: ../../library/enum.rst:109
msgid ""
"An enumeration with the values ``STRICT``, ``CONFORM``, ``EJECT``, and "
"``KEEP`` which allows for more fine-grained control over how invalid values "
"are dealt with in an enumeration."
msgstr ""
"一個有 ``STRICT``、``CONFORM``、``EJECT`` 及 ``KEEP`` 這些值的列舉，允許列舉"
"對如何處理非法值做更細微的控制。"

#: ../../library/enum.rst:113
msgid ":class:`EnumDict`"
msgstr ":class:`EnumDict`"

#: ../../library/enum.rst:115
msgid "A subclass of :class:`dict` for use when subclassing :class:`EnumType`."
msgstr ":class:`dict` 的子類別，用於當作 :class:`EnumType` 的子類別時使用。"

#: ../../library/enum.rst:117
msgid ":class:`auto`"
msgstr ":class:`auto`"

#: ../../library/enum.rst:119
msgid ""
"Instances are replaced with an appropriate value for Enum members. :class:"
"`StrEnum` defaults to the lower-cased version of the member name, while "
"other Enums default to 1 and increase from there."
msgstr ""
"列舉成員的實例會被取代成合適的值。:class:`StrEnum` 預設是小寫版本的成員名稱，"
"其它列舉則預設是 1 且往後遞增。"

#: ../../library/enum.rst:123
msgid ":func:`~enum.property`"
msgstr ":func:`~enum.property`"

#: ../../library/enum.rst:125
msgid ""
"Allows :class:`Enum` members to have attributes without conflicting with "
"member names.  The ``value`` and ``name`` attributes are implemented this "
"way."
msgstr ""
"允許 :class:`Enum` 成員擁有屬性且不會與成員名稱有衝突。``value`` 及 ``name`` "
"屬性是用這個方式來實作。"

#: ../../library/enum.rst:129
msgid ":func:`unique`"
msgstr ":func:`unique`"

#: ../../library/enum.rst:131
msgid ""
"Enum class decorator that ensures only one name is bound to any one value."
msgstr "Enum 類別的裝飾器，用來確保任何值只有綁定到一個名稱上。"

#: ../../library/enum.rst:133
msgid ":func:`verify`"
msgstr ":func:`verify`"

#: ../../library/enum.rst:135
msgid ""
"Enum class decorator that checks user-selectable constraints on an "
"enumeration."
msgstr "Enum 類別的裝飾器，用來檢查列舉上使用者所選的限制。"

#: ../../library/enum.rst:138
msgid ":func:`member`"
msgstr ":func:`member`"

#: ../../library/enum.rst:140
msgid "Make ``obj`` a member.  Can be used as a decorator."
msgstr "讓 ``obj`` 變成成員。可以當作裝飾器使用。"

#: ../../library/enum.rst:142
msgid ":func:`nonmember`"
msgstr ":func:`nonmember`"

#: ../../library/enum.rst:144
msgid "Do not make ``obj`` a member.  Can be used as a decorator."
msgstr "不讓 ``obj`` 變成成員。可以當作裝飾器使用。"

#: ../../library/enum.rst:146
msgid ":func:`global_enum`"
msgstr ":func:`global_enum`"

#: ../../library/enum.rst:148
msgid ""
"Modify the :class:`str() <str>` and :func:`repr` of an enum to show its "
"members as belonging to the module instead of its class, and export the enum "
"members to the global namespace."
msgstr ""
"修改列舉上的 :class:`str() <str>` 及 :func:`repr` ，讓成員顯示為屬於模組而不"
"是類別，並將該列舉成員匯出到全域命名空間。"

#: ../../library/enum.rst:152
msgid ":func:`show_flag_values`"
msgstr ":func:`show_flag_values`"

#: ../../library/enum.rst:154
msgid "Return a list of all power-of-two integers contained in a flag."
msgstr "回傳旗標 (flag) 裡包含的所有 2 的次方的整數串列。"

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

#: ../../library/enum.rst:158
msgid ""
"``StrEnum``, ``EnumCheck``, ``ReprEnum``, ``FlagBoundary``, ``property``, "
"``member``, ``nonmember``, ``global_enum``, ``show_flag_values``"
msgstr ""
"``StrEnum``, ``EnumCheck``, ``ReprEnum``, ``FlagBoundary``, ``property``, "
"``member``, ``nonmember``, ``global_enum``, ``show_flag_values``"

#: ../../library/enum.rst:159
msgid "``EnumDict``"
msgstr "``EnumDict``"

#: ../../library/enum.rst:164
msgid "Data Types"
msgstr "資料型別"

#: ../../library/enum.rst:169
msgid ""
"*EnumType* is the :term:`metaclass` for *enum* enumerations.  It is possible "
"to subclass *EnumType* -- see :ref:`Subclassing EnumType <enumtype-"
"examples>` for details."
msgstr ""
"*EnumType* 是 *enum* 列舉的 :term:`metaclass`。*EnumType* 可以有子類別 -- 細"
"節請參考 :ref:`建立 EnumType 的子類別 <enumtype-examples>`。"

#: ../../library/enum.rst:173
msgid ""
"``EnumType`` is responsible for setting the correct :meth:`!__repr__`, :meth:"
"`!__str__`, :meth:`!__format__`, and :meth:`!__reduce__` methods on the "
"final *enum*, as well as creating the enum members, properly handling "
"duplicates, providing iteration over the enum class, etc."
msgstr ""
"``EnumType`` 負責在最後的\\ *列舉*\\ 上面設定正確的 :meth:`!__repr__`、:meth:"
"`!__str__`、:meth:`!__format__` 及 :meth:`!__reduce__` 方法，以及建立列舉成"
"員、正確處理重複、提供列舉類別的疊代等等。"

#: ../../library/enum.rst:180
msgid "This method is called in two different ways:"
msgstr "這個方法可以用兩種不同的方式呼叫："

#: ../../library/enum.rst:182
msgid "to look up an existing member:"
msgstr "查詢已存在的成員："

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

#: ../../library/enum.rst:184 ../../library/enum.rst:190
msgid "The enum class being called."
msgstr "所呼叫的列舉類別。"

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

#: ../../library/enum.rst:185
msgid "The value to lookup."
msgstr "要查詢的值。"

#: ../../library/enum.rst:187
msgid ""
"to use the ``cls`` enum to create a new enum (only if the existing enum does "
"not have any members):"
msgstr "使用 ``cls`` 列舉來建立新列舉（只有在現有列舉沒有任何成員時）"

#: ../../library/enum.rst:191
msgid "The name of the new Enum to create."
msgstr "要建立的新列舉的名稱。"

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

#: ../../library/enum.rst:192
msgid "The names/values of the members for the new Enum."
msgstr "新列舉的成員的名稱/值。"

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

#: ../../library/enum.rst:193
msgid "The name of the module the new Enum is created in."
msgstr "新列舉要建立在哪個模組名稱下。"

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

#: ../../library/enum.rst:194
msgid "The actual location in the module where this Enum can be found."
msgstr "這個列舉在模組裡實際上的位置。"

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

#: ../../library/enum.rst:195
msgid "A mix-in type for the new Enum."
msgstr "新列舉的混合型別。"

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

#: ../../library/enum.rst:196
msgid "The first integer value for the Enum (used by :class:`auto`)."
msgstr "列舉的第一個整數值（由 :class:`auto` 所使用）"

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

#: ../../library/enum.rst:197
msgid ""
"How to handle out-of-range values from bit operations (:class:`Flag` only)."
msgstr "在位元操作時怎麼處理範圍外的值（只有 :class:`Flag` 會用到）"

#: ../../library/enum.rst:201
msgid "Returns ``True`` if member belongs to the ``cls``::"
msgstr "如果 member 屬於 ``cls`` 則回傳 ``True``： ::"

#: ../../library/enum.rst:203
msgid ""
">>> some_var = Color.RED\n"
">>> some_var in Color\n"
"True\n"
">>> Color.RED.value in Color\n"
"True"
msgstr ""
">>> some_var = Color.RED\n"
">>> some_var in Color\n"
"True\n"
">>> Color.RED.value in Color\n"
"True"

#: ../../library/enum.rst:211
msgid ""
"Before Python 3.12, a ``TypeError`` is raised if a non-Enum-member is used "
"in a containment check."
msgstr ""
"在 Python 3.12 之前，如果用非列舉成員做屬於檢查 (containment check) 會引發 "
"``TypeError``。"

#: ../../library/enum.rst:216
msgid ""
"Returns ``['__class__', '__doc__', '__members__', '__module__']`` and the "
"names of the members in *cls*::"
msgstr ""
"回傳 ``['__class__', '__doc__', '__members__', '__module__']`` 及 *cls* 的成"
"員名稱： ::"

#: ../../library/enum.rst:219
msgid ""
">>> dir(Color)\n"
"['BLUE', 'GREEN', 'RED', '__class__', '__contains__', '__doc__', "
"'__getitem__', '__init_subclass__', '__iter__', '__len__', '__members__', "
"'__module__', '__name__', '__qualname__']"
msgstr ""
">>> dir(Color)\n"
"['BLUE', 'GREEN', 'RED', '__class__', '__contains__', '__doc__', "
"'__getitem__', '__init_subclass__', '__iter__', '__len__', '__members__', "
"'__module__', '__name__', '__qualname__']"

#: ../../library/enum.rst:224
msgid ""
"Returns the Enum member in *cls* matching *name*, or raises a :exc:"
"`KeyError`::"
msgstr "回傳 *cls* 中符合 *name* 的列舉成員，或引發 :exc:`KeyError`： ::"

#: ../../library/enum.rst:226
msgid ""
">>> Color['BLUE']\n"
"<Color.BLUE: 3>"
msgstr ""
">>> Color['BLUE']\n"
"<Color.BLUE: 3>"

#: ../../library/enum.rst:231
msgid "Returns each member in *cls* in definition order::"
msgstr "以定義的順序回傳在 *cls* 中的每個成員： ::"

#: ../../library/enum.rst:233
msgid ""
">>> list(Color)\n"
"[<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>]"
msgstr ""
">>> list(Color)\n"
"[<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>]"

#: ../../library/enum.rst:238
msgid "Returns the number of member in *cls*::"
msgstr "回傳 *cls* 的成員數量： ::"

#: ../../library/enum.rst:240
msgid ""
">>> len(Color)\n"
"3"
msgstr ""
">>> len(Color)\n"
"3"

#: ../../library/enum.rst:245
msgid "Returns a mapping of every enum name to its member, including aliases"
msgstr "回傳每個列舉名稱到其成員的對映，包括別名"

#: ../../library/enum.rst:249
msgid "Returns each member in *cls* in reverse definition order::"
msgstr "以跟定義相反的順序回傳 *cls* 的每個成員： ::"

#: ../../library/enum.rst:251
msgid ""
">>> list(reversed(Color))\n"
"[<Color.BLUE: 3>, <Color.GREEN: 2>, <Color.RED: 1>]"
msgstr ""
">>> list(reversed(Color))\n"
"[<Color.BLUE: 3>, <Color.GREEN: 2>, <Color.RED: 1>]"

#: ../../library/enum.rst:256
msgid ""
"Adds a new name as an alias to an existing member.  Raises a :exc:"
"`NameError` if the name is already assigned to a different member."
msgstr ""
"新增一個名稱作為現有成員的別名。如果該名稱已被指派給不同的成員，則會引發 :"
"exc:`NameError`。"

#: ../../library/enum.rst:261
msgid ""
"Adds a new value as an alias to an existing member.  Raises a :exc:"
"`ValueError` if the value is already linked with a different member."
msgstr ""
"新增一個值作為現有成員的別名。如果該值已與不同成員連結，則會引發 :exc:"
"`ValueError`。"

#: ../../library/enum.rst:266
msgid ""
"Before 3.11 ``EnumType`` was called ``EnumMeta``, which is still available "
"as an alias."
msgstr "在 3.11 之前，``EnumType`` 稱作 ``EnumMeta``，其目前仍可作為別名使用。"

#: ../../library/enum.rst:271
msgid "*Enum* is the base class for all *enum* enumerations."
msgstr "*Enum* 是所有 *enum* 列舉的基礎類別。"

#: ../../library/enum.rst:275
msgid "The name used to define the ``Enum`` member::"
msgstr "用來定義 ``Enum`` 成員的名稱： ::"

#: ../../library/enum.rst:277
msgid ""
">>> Color.BLUE.name\n"
"'BLUE'"
msgstr ""
">>> Color.BLUE.name\n"
"'BLUE'"

#: ../../library/enum.rst:282
msgid "The value given to the ``Enum`` member::"
msgstr "``Enum`` 成員給定的值： ::"

#: ../../library/enum.rst:284
msgid ""
">>> Color.RED.value\n"
"1"
msgstr ""
">>> Color.RED.value\n"
"1"

#: ../../library/enum.rst:287 ../../library/enum.rst:307
msgid "Value of the member, can be set in :meth:`~Enum.__new__`."
msgstr "成員的值，可以在 :meth:`~Enum.__new__` 設定。"

#: ../../library/enum.rst:289
msgid "Enum member values"
msgstr "列舉成員的值"

#: ../../library/enum.rst:291
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.  See :class:`auto` for the details."
msgstr ""
"成員的值可以是任何值：:class:`int`、:class:`str` 等等。如果實際使用什麼值並不"
"重要，你可以使用 :class:`auto` 實例，它會為你選擇合適的值。更多細節請參考 :"
"class:`auto`。"

#: ../../library/enum.rst:296
msgid ""
"While mutable/unhashable values, such as :class:`dict`, :class:`list` or a "
"mutable :class:`~dataclasses.dataclass`, can be used, they will have a "
"quadratic performance impact during creation relative to the total number of "
"mutable/unhashable values in the enum."
msgstr ""
"雖然可以使用可變的 (mutable) / 不可雜湊的 (unhashable) 值，例如 :class:"
"`dict`、:class:`list` 或可變的 :class:`~dataclasses.dataclass`，它們在建立期"
"間會對效能產生相對於列舉中可變的 / 不可雜湊的值總數量的二次方影響。"

#: ../../library/enum.rst:303
msgid "Name of the member."
msgstr "成員名稱。"

#: ../../library/enum.rst:311
msgid ""
"No longer used, kept for backward compatibility. (class attribute, removed "
"during class creation)."
msgstr "已不再使用，只為了向後相容而保留（類別屬性，在類別建立時移除）"

#: ../../library/enum.rst:316
msgid ""
"``_ignore_`` is only used during creation and is removed from the "
"enumeration once creation is complete."
msgstr "``_ignore_`` 只有在建立的時候用到，在列舉建立完成後會被移除。"

#: ../../library/enum.rst:319
msgid ""
"``_ignore_`` is a list of names that will not become members, and whose "
"names will also be removed from the completed enumeration.  See :ref:"
"`TimePeriod <enum-time-period>` for an example."
msgstr ""
"``_ignore_`` 是一個不會變成成員的名稱串列，在列舉建立完成後其名稱會被移除。範"
"例請參考 :ref:`TimePeriod <enum-time-period>`。"

#: ../../library/enum.rst:325
msgid ""
"Returns ``['__class__', '__doc__', '__module__', 'name', 'value']`` and any "
"public methods defined on *self.__class__*::"
msgstr ""
"回傳 ``['__class__', '__doc__', '__module__', 'name', 'value']`` 及任何 "
"*self.__class__* 上定義的公開方法： ::"

#: ../../library/enum.rst:328
msgid ""
">>> from datetime import date\n"
">>> class Weekday(Enum):\n"
"...     MONDAY = 1\n"
"...     TUESDAY = 2\n"
"...     WEDNESDAY = 3\n"
"...     THURSDAY = 4\n"
"...     FRIDAY = 5\n"
"...     SATURDAY = 6\n"
"...     SUNDAY = 7\n"
"...     @classmethod\n"
"...     def today(cls):\n"
"...         print('today is %s' % cls(date.today().isoweekday()).name)\n"
"...\n"
">>> dir(Weekday.SATURDAY)\n"
"['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', "
"'today', 'value']"
msgstr ""
">>> from datetime import date\n"
">>> class Weekday(Enum):\n"
"...     MONDAY = 1\n"
"...     TUESDAY = 2\n"
"...     WEDNESDAY = 3\n"
"...     THURSDAY = 4\n"
"...     FRIDAY = 5\n"
"...     SATURDAY = 6\n"
"...     SUNDAY = 7\n"
"...     @classmethod\n"
"...     def today(cls):\n"
"...         print('today is %s' % cls(date.today().isoweekday()).name)\n"
"...\n"
">>> dir(Weekday.SATURDAY)\n"
"['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', "
"'today', 'value']"

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

#: ../../library/enum.rst:346
msgid "The name of the member being defined (e.g. 'RED')."
msgstr "定義的成員名稱（例如 'RED'）。"

#: ../../library/enum.rst:347
msgid "The start value for the Enum; the default is 1."
msgstr "列舉的開始值，預設為 1。"

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

#: ../../library/enum.rst:348
msgid "The number of members currently defined, not including this one."
msgstr "已定義的成員數量，不包含目前這一個。"

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

#: ../../library/enum.rst:349
msgid "A list of the previous values."
msgstr "一個之前值的串列。"

#: ../../library/enum.rst:351
msgid ""
"A *staticmethod* that is used to determine the next value returned by :class:"
"`auto`::"
msgstr "一個 *staticmethod*，用來決定 :class:`auto` 下一個要回傳的值的： ::"

#: ../../library/enum.rst:354
msgid ""
">>> from enum import auto\n"
">>> class PowersOfThree(Enum):\n"
"...     @staticmethod\n"
"...     def _generate_next_value_(name, start, count, last_values):\n"
"...         return 3 ** (count + 1)\n"
"...     FIRST = auto()\n"
"...     SECOND = auto()\n"
"...\n"
">>> PowersOfThree.SECOND.value\n"
"9"
msgstr ""
">>> from enum import auto\n"
">>> class PowersOfThree(Enum):\n"
"...     @staticmethod\n"
"...     def _generate_next_value_(name, start, count, last_values):\n"
"...         return 3 ** (count + 1)\n"
"...     FIRST = auto()\n"
"...     SECOND = auto()\n"
"...\n"
">>> PowersOfThree.SECOND.value\n"
"9"

#: ../../library/enum.rst:367
msgid ""
"By default, does nothing.  If multiple values are given in the member "
"assignment, those values become separate arguments to ``__init__``; e.g."
msgstr ""
"預設情況下，不執行任何操作。如果在成員賦值中給出多個值，這些值將成為與 "
"``__init__`` 分別的引數；例如"

#: ../../library/enum.rst:374
msgid ""
"``Weekday.__init__()`` would be called as ``Weekday.__init__(self, 1, "
"'Mon')``"
msgstr "``Weekday.__init__()`` 將被稱為 ``Weekday.__init__(self, 1, 'Mon')``"

#: ../../library/enum.rst:378
msgid ""
"A *classmethod* that is used to further configure subsequent subclasses. By "
"default, does nothing."
msgstr "一個 *classmethod*，用來進一步設定後續的子類別，預設不做任何事。"

#: ../../library/enum.rst:383
msgid ""
"A *classmethod* for looking up values not found in *cls*.  By default it "
"does nothing, but can be overridden to implement custom search behavior::"
msgstr ""
"一個 *classmethod*，用來查詢在 *cls* 裡找不到的值。預設不做任何事，但可以被覆"
"寫以實作客製化的搜尋行為： ::"

#: ../../library/enum.rst:386
msgid ""
">>> from enum import StrEnum\n"
">>> class Build(StrEnum):\n"
"...     DEBUG = auto()\n"
"...     OPTIMIZED = auto()\n"
"...     @classmethod\n"
"...     def _missing_(cls, value):\n"
"...         value = value.lower()\n"
"...         for member in cls:\n"
"...             if member.value == value:\n"
"...                 return member\n"
"...         return None\n"
"...\n"
">>> Build.DEBUG.value\n"
"'debug'\n"
">>> Build('deBUG')\n"
"<Build.DEBUG: 'debug'>"
msgstr ""
">>> from enum import StrEnum\n"
">>> class Build(StrEnum):\n"
"...     DEBUG = auto()\n"
"...     OPTIMIZED = auto()\n"
"...     @classmethod\n"
"...     def _missing_(cls, value):\n"
"...         value = value.lower()\n"
"...         for member in cls:\n"
"...             if member.value == value:\n"
"...                 return member\n"
"...         return None\n"
"...\n"
">>> Build.DEBUG.value\n"
"'debug'\n"
">>> Build('deBUG')\n"
"<Build.DEBUG: 'debug'>"

#: ../../library/enum.rst:405
msgid ""
"By default, doesn't exist.  If specified, either in the enum class "
"definition or in a mixin class (such as ``int``), all values given in the "
"member assignment will be passed; e.g."
msgstr ""
"預設情況下不存在。如果有指定，無論是在列舉類別定義中還是在 mixin 類別中（例"
"如 ``int``\\ ），都將傳遞成員賦值中給出的所有值；例如"

#: ../../library/enum.rst:413
msgid ""
"results in the call ``int('1a', 16)`` and a value of ``26`` for the member."
msgstr "會產生呼叫 ``int('1a', 16)`` 而該成員的值為 ``26``。"

#: ../../library/enum.rst:417
msgid ""
"When writing a custom ``__new__``, do not use ``super().__new__`` -- call "
"the appropriate ``__new__`` instead."
msgstr ""
"當寫自訂的 ``__new__`` 時，不要使用 ``super().__new__``，而是要呼叫適當的 "
"``__new__``。"

#: ../../library/enum.rst:422
msgid ""
"Returns the string used for *repr()* calls.  By default, returns the *Enum* "
"name, member name, and value, but can be overridden::"
msgstr ""
"回傳呼叫 *repr()* 時使用的字串。預設回傳 *Enum* 名稱、成員名稱及值，但可以被"
"覆寫： ::"

#: ../../library/enum.rst:425
msgid ""
">>> class OtherStyle(Enum):\n"
"...     ALTERNATE = auto()\n"
"...     OTHER = auto()\n"
"...     SOMETHING_ELSE = auto()\n"
"...     def __repr__(self):\n"
"...         cls_name = self.__class__.__name__\n"
"...         return f'{cls_name}.{self.name}'\n"
"...\n"
">>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f\"{OtherStyle."
"ALTERNATE}\"\n"
"(OtherStyle.ALTERNATE, 'OtherStyle.ALTERNATE', 'OtherStyle.ALTERNATE')"
msgstr ""
">>> class OtherStyle(Enum):\n"
"...     ALTERNATE = auto()\n"
"...     OTHER = auto()\n"
"...     SOMETHING_ELSE = auto()\n"
"...     def __repr__(self):\n"
"...         cls_name = self.__class__.__name__\n"
"...         return f'{cls_name}.{self.name}'\n"
"...\n"
">>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f\"{OtherStyle."
"ALTERNATE}\"\n"
"(OtherStyle.ALTERNATE, 'OtherStyle.ALTERNATE', 'OtherStyle.ALTERNATE')"

#: ../../library/enum.rst:438
msgid ""
"Returns the string used for *str()* calls.  By default, returns the *Enum* "
"name and member name, but can be overridden::"
msgstr ""
"回傳呼叫 *str()* 時使用的字串。預設回傳 *Enum* 名稱及成員名稱，但可以被覆"
"寫： ::"

#: ../../library/enum.rst:441
msgid ""
">>> class OtherStyle(Enum):\n"
"...     ALTERNATE = auto()\n"
"...     OTHER = auto()\n"
"...     SOMETHING_ELSE = auto()\n"
"...     def __str__(self):\n"
"...         return f'{self.name}'\n"
"...\n"
">>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f\"{OtherStyle."
"ALTERNATE}\"\n"
"(<OtherStyle.ALTERNATE: 1>, 'ALTERNATE', 'ALTERNATE')"
msgstr ""
">>> class OtherStyle(Enum):\n"
"...     ALTERNATE = auto()\n"
"...     OTHER = auto()\n"
"...     SOMETHING_ELSE = auto()\n"
"...     def __str__(self):\n"
"...         return f'{self.name}'\n"
"...\n"
">>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f\"{OtherStyle."
"ALTERNATE}\"\n"
"(<OtherStyle.ALTERNATE: 1>, 'ALTERNATE', 'ALTERNATE')"

#: ../../library/enum.rst:453
msgid ""
"Returns the string used for *format()* and *f-string* calls.  By default, "
"returns :meth:`__str__` return value, but can be overridden::"
msgstr ""
"回傳呼叫 *format()* 及 *f-string* 時使用的字串。預設回傳 :meth:`__str__` 的回"
"傳值，但可以被覆寫： ::"

#: ../../library/enum.rst:456
msgid ""
">>> class OtherStyle(Enum):\n"
"...     ALTERNATE = auto()\n"
"...     OTHER = auto()\n"
"...     SOMETHING_ELSE = auto()\n"
"...     def __format__(self, spec):\n"
"...         return f'{self.name}'\n"
"...\n"
">>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f\"{OtherStyle."
"ALTERNATE}\"\n"
"(<OtherStyle.ALTERNATE: 1>, 'OtherStyle.ALTERNATE', 'ALTERNATE')"
msgstr ""
">>> class OtherStyle(Enum):\n"
"...     ALTERNATE = auto()\n"
"...     OTHER = auto()\n"
"...     SOMETHING_ELSE = auto()\n"
"...     def __format__(self, spec):\n"
"...         return f'{self.name}'\n"
"...\n"
">>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f\"{OtherStyle."
"ALTERNATE}\"\n"
"(<OtherStyle.ALTERNATE: 1>, 'OtherStyle.ALTERNATE', 'ALTERNATE')"

#: ../../library/enum.rst:468
msgid ""
"Using :class:`auto` with :class:`Enum` results in integers of increasing "
"value, starting with ``1``."
msgstr ":class:`Enum` 使用 :class:`auto` 會產生從 ``1`` 開始遞增的整數。"

#: ../../library/enum.rst:471
msgid "Added :ref:`enum-dataclass-support`"
msgstr "新增 :ref:`enum-dataclass-support`"

#: ../../library/enum.rst:476
msgid ""
"*IntEnum* is the same as :class:`Enum`, but its members are also integers "
"and can be used anywhere that an integer can be used.  If any integer "
"operation is performed with an *IntEnum* member, the resulting value loses "
"its enumeration status."
msgstr ""
"*IntEnum* 和 :class:`Enum` 一樣，但其成員同時也是整數而可以被用在任何使用整數"
"的地方。如果 *IntEnum* 成員經過任何整數運算，結果值會失去其列舉狀態。"

#: ../../library/enum.rst:497
msgid ""
"Using :class:`auto` with :class:`IntEnum` results in integers of increasing "
"value, starting with ``1``."
msgstr ":class:`IntEnum` 使用 :class:`auto` 會產生從 ``1`` 開始遞增的整數。"

#: ../../library/enum.rst:500
msgid ""
":meth:`~object.__str__` is now :meth:`!int.__str__` to better support the "
"*replacement of existing constants* use-case. :meth:`~object.__format__` was "
"already :meth:`!int.__format__` for that same reason."
msgstr ""
"為了更好地支援\\ *現存常數取代 (replacement of existing constants)* 的使用情"
"境，:meth:`~object.__str__` 現在會是 :meth:`!int.__str__`。為了同樣的理由，:"
"meth:`~object.__format__` 已經是 :meth:`!int.__format__`。"

#: ../../library/enum.rst:507
msgid ""
"``StrEnum`` is the same as :class:`Enum`, but its members are also strings "
"and can be used in most of the same places that a string can be used.  The "
"result of any string operation performed on or with a *StrEnum* member is "
"not part of the enumeration."
msgstr ""
"``StrEnum`` 和 :class:`Enum` 一樣，但其成員同時也是字串而可以被用在幾乎所有使"
"用字串的地方。*StrEnum* 成員經過任何字串操作的結果會不再是列舉的一部份。"

#: ../../library/enum.rst:513
msgid ""
"There are places in the stdlib that check for an exact :class:`str` instead "
"of a :class:`str` subclass (i.e. ``type(unknown) == str`` instead of "
"``isinstance(unknown, str)``), and in those locations you will need to use "
"``str(StrEnum.member)``."
msgstr ""
"stdlib 裡有些地方會檢查只能是 :class:`str` 而不是 :class:`str` 的子類別（也就"
"是 ``type(unknown) == str`` 而不是 ``isinstance(unknown, str)``），在這些地方"
"你需要使用 ``str(StrEnum.member)``。"

#: ../../library/enum.rst:520
msgid ""
"Using :class:`auto` with :class:`StrEnum` results in the lower-cased member "
"name as the value."
msgstr ":class:`StrEnum` 使用 :class:`auto` 會產生小寫的成員名稱當作值。"

#: ../../library/enum.rst:525
msgid ""
":meth:`~object.__str__` is :meth:`!str.__str__` to better support the "
"*replacement of existing constants* use-case.  :meth:`~object.__format__` is "
"likewise :meth:`!str.__format__` for that same reason."
msgstr ""
"為了更好地支援\\ *現存常數取代 (replacement of existing constants)* 的使用情"
"境，:meth:`~object.__str__` 現在會是 :meth:`!str.__str__`。為了同樣的理由，:"
"meth:`~object.__format__` 也會是 :meth:`!str.__format__`。"

#: ../../library/enum.rst:533
msgid ""
"``Flag`` is the same as :class:`Enum`, but its members support the bitwise "
"operators ``&`` (*AND*), ``|`` (*OR*), ``^`` (*XOR*), and ``~`` (*INVERT*); "
"the results of those operations are (aliases of) members of the enumeration."
msgstr ""
"``Flag`` 與 :class:`Enum` 相同，但其成員支援位元運算子 ``&`` (*AND*)、``|`` "
"(*OR*)、``^`` (*XOR*) 和 ``~`` (*INVERT*)；這些操作的結果是列舉的成員（的別"
"名）。"

#: ../../library/enum.rst:539
msgid "Returns *True* if value is in self::"
msgstr "如果 value 在 self 裡則回傳 *True*： ::"

#: ../../library/enum.rst:541
msgid ""
">>> from enum import Flag, auto\n"
">>> class Color(Flag):\n"
"...     RED = auto()\n"
"...     GREEN = auto()\n"
"...     BLUE = auto()\n"
"...\n"
">>> purple = Color.RED | Color.BLUE\n"
">>> white = Color.RED | Color.GREEN | Color.BLUE\n"
">>> Color.GREEN in purple\n"
"False\n"
">>> Color.GREEN in white\n"
"True\n"
">>> purple in white\n"
"True\n"
">>> white in purple\n"
"False"
msgstr ""
">>> from enum import Flag, auto\n"
">>> class Color(Flag):\n"
"...     RED = auto()\n"
"...     GREEN = auto()\n"
"...     BLUE = auto()\n"
"...\n"
">>> purple = Color.RED | Color.BLUE\n"
">>> white = Color.RED | Color.GREEN | Color.BLUE\n"
">>> Color.GREEN in purple\n"
"False\n"
">>> Color.GREEN in white\n"
"True\n"
">>> purple in white\n"
"True\n"
">>> white in purple\n"
"False"

#: ../../library/enum.rst:560
msgid "Returns all contained non-alias members::"
msgstr "回傳所有包含的非別名成員： ::"

#: ../../library/enum.rst:562
msgid ""
">>> list(Color.RED)\n"
"[<Color.RED: 1>]\n"
">>> list(purple)\n"
"[<Color.RED: 1>, <Color.BLUE: 4>]"
msgstr ""
">>> list(Color.RED)\n"
"[<Color.RED: 1>]\n"
">>> list(purple)\n"
"[<Color.RED: 1>, <Color.BLUE: 4>]"

#: ../../library/enum.rst:571
msgid "Returns number of members in flag::"
msgstr "回傳旗標裡的成員數量： ::"

#: ../../library/enum.rst:573
msgid ""
">>> len(Color.GREEN)\n"
"1\n"
">>> len(white)\n"
"3"
msgstr ""
">>> len(Color.GREEN)\n"
"1\n"
">>> len(white)\n"
"3"

#: ../../library/enum.rst:582
msgid "Returns *True* if any members in flag, *False* otherwise::"
msgstr "如果成員在旗標裡則回傳 *True*，否則回傳 *False*： ::"

#: ../../library/enum.rst:584
msgid ""
">>> bool(Color.GREEN)\n"
"True\n"
">>> bool(white)\n"
"True\n"
">>> black = Color(0)\n"
">>> bool(black)\n"
"False"
msgstr ""
">>> bool(Color.GREEN)\n"
"True\n"
">>> bool(white)\n"
"True\n"
">>> black = Color(0)\n"
">>> bool(black)\n"
"False"

#: ../../library/enum.rst:594
msgid "Returns current flag binary or'ed with other::"
msgstr "回傳和 other 做 OR 過後的二進位旗標： ::"

#: ../../library/enum.rst:596
msgid ""
">>> Color.RED | Color.GREEN\n"
"<Color.RED|GREEN: 3>"
msgstr ""
">>> Color.RED | Color.GREEN\n"
"<Color.RED|GREEN: 3>"

#: ../../library/enum.rst:601
msgid "Returns current flag binary and'ed with other::"
msgstr "回傳和 other 做 AND 過後的二進位旗標： ::"

#: ../../library/enum.rst:603
msgid ""
">>> purple & white\n"
"<Color.RED|BLUE: 5>\n"
">>> purple & Color.GREEN\n"
"<Color: 0>"
msgstr ""
">>> purple & white\n"
"<Color.RED|BLUE: 5>\n"
">>> purple & Color.GREEN\n"
"<Color: 0>"

#: ../../library/enum.rst:610
msgid "Returns current flag binary xor'ed with other::"
msgstr "回傳和 other 做 XOR 過後的二進位旗標： ::"

#: ../../library/enum.rst:612
msgid ""
">>> purple ^ white\n"
"<Color.GREEN: 2>\n"
">>> purple ^ Color.GREEN\n"
"<Color.RED|GREEN|BLUE: 7>"
msgstr ""
">>> purple ^ white\n"
"<Color.GREEN: 2>\n"
">>> purple ^ Color.GREEN\n"
"<Color.RED|GREEN|BLUE: 7>"

#: ../../library/enum.rst:619
msgid "Returns all the flags in *type(self)* that are not in *self*::"
msgstr "回傳所有在 *type(self)* 但不在 *self* 裡的旗標： ::"

#: ../../library/enum.rst:621
msgid ""
">>> ~white\n"
"<Color: 0>\n"
">>> ~purple\n"
"<Color.GREEN: 2>\n"
">>> ~Color.RED\n"
"<Color.GREEN|BLUE: 6>"
msgstr ""
">>> ~white\n"
"<Color: 0>\n"
">>> ~purple\n"
"<Color.GREEN: 2>\n"
">>> ~Color.RED\n"
"<Color.GREEN|BLUE: 6>"

#: ../../library/enum.rst:630
msgid ""
"Function used to format any remaining unnamed numeric values.  Default is "
"the value's repr; common choices are :func:`hex` and :func:`oct`."
msgstr ""
"用來格式化任何剩下未命名數值的函式。預設是值的 repr，常見選擇是 :func:`hex` "
"和 :func:`oct`。"

#: ../../library/enum.rst:635
msgid ""
"Using :class:`auto` with :class:`Flag` results in integers that are powers "
"of two, starting with ``1``."
msgstr ":class:`Flag` 使用 :class:`auto` 會產生從 ``1`` 開始 2 的次方的整數。"

#: ../../library/enum.rst:638
msgid "The *repr()* of zero-valued flags has changed.  It is now::"
msgstr "值為 0 的旗標的 *repr()* 已改變。現在是： ::"

#: ../../library/enum.rst:646
msgid ""
"``IntFlag`` is the same as :class:`Flag`, but its members are also integers "
"and can be used anywhere that an integer can be used."
msgstr ""
"``IntFlag`` 和 :class:`Flag` 一樣，但其成員同時也是整數而可以被用在任何使用整"
"數的地方。"

#: ../../library/enum.rst:660
msgid ""
"If any integer operation is performed with an *IntFlag* member, the result "
"is not an *IntFlag*::"
msgstr "如果 *IntFlag* 成員經過任何整數運算，其結果不是 *IntFlag*： ::"

#: ../../library/enum.rst:663
msgid ""
">>> Color.RED + 2\n"
"3"
msgstr ""
">>> Color.RED + 2\n"
"3"

#: ../../library/enum.rst:666
msgid "If a :class:`Flag` operation is performed with an *IntFlag* member and:"
msgstr "如果 *IntFlag* 成員經過 :class:`Flag` 操作且："

#: ../../library/enum.rst:668
msgid "the result is a valid *IntFlag*: an *IntFlag* is returned"
msgstr "結果是合法的 *IntFlag*：回傳 *IntFlag*"

#: ../../library/enum.rst:669
msgid ""
"the result is not a valid *IntFlag*: the result depends on the :class:"
"`FlagBoundary` setting"
msgstr "結果不是合法的 *IntFlag*：結果會根據 :class:`FlagBoundary` 的設定"

#: ../../library/enum.rst:671
msgid "The :func:`repr` of unnamed zero-valued flags has changed.  It is now:"
msgstr "未命名且值為 0 的旗標的 :func:`repr` 已改變。現在是："

#: ../../library/enum.rst:678
msgid ""
"Using :class:`auto` with :class:`IntFlag` results in integers that are "
"powers of two, starting with ``1``."
msgstr ""
":class:`IntFlag` 使用 :class:`auto` 會產生從 ``1`` 開始 2 的次方的整數。"

#: ../../library/enum.rst:683
msgid ""
":meth:`~object.__str__` is now :meth:`!int.__str__` to better support the "
"*replacement of existing constants* use-case.  :meth:`~object.__format__` "
"was already :meth:`!int.__format__` for that same reason."
msgstr ""
"為了更好地支援\\ *現存常數取代 (replacement of existing constants)* 的使用情"
"境，:meth:`~object.__str__` 現在會是 :meth:`!int.__str__`。為了同樣的理由，:"
"meth:`~object.__format__` 已經是 :meth:`!int.__format__`。"

#: ../../library/enum.rst:687
msgid ""
"Inversion of an :class:`!IntFlag` now returns a positive value that is the "
"union of all flags not in the given flag, rather than a negative value. This "
"matches the existing :class:`Flag` behavior."
msgstr ""
":class:`!IntFlag` 的反轉 (inversion) 現在會回傳正值，該值是不在給定旗標的所有"
"旗標聯集，而不是一個負值。這符合現有 :class:`Flag` 的行為。"

#: ../../library/enum.rst:693
msgid ""
":class:`!ReprEnum` uses the :meth:`repr() <Enum.__repr__>` of :class:`Enum`, "
"but the :class:`str() <str>` of the mixed-in data type:"
msgstr ""
":class:`!ReprEnum` 使用 :class:`Enum` 的 :meth:`repr() <Enum.__repr__>`，但使"
"用混合資料型別的 :class:`str() <str>`："

#: ../../library/enum.rst:696
msgid ":meth:`!int.__str__` for :class:`IntEnum` and :class:`IntFlag`"
msgstr "對 :class:`IntEnum` 和 :class:`IntFlag` 是 :meth:`!int.__str__`"

#: ../../library/enum.rst:697
msgid ":meth:`!str.__str__` for :class:`StrEnum`"
msgstr "對 :class:`StrEnum` 是 :meth:`!str.__str__`"

#: ../../library/enum.rst:699
msgid ""
"Inherit from :class:`!ReprEnum` to keep the :class:`str() <str>` / :func:"
"`format` of the mixed-in data type instead of using the :class:`Enum`-"
"default :meth:`str() <Enum.__str__>`."
msgstr ""
"繼承 :class:`!ReprEnum` 來保留混合資料型別的 :class:`str() <str>` / :func:"
"`format`，而不是使用 :class:`Enum` 預設的 :meth:`str() <Enum.__str__>`。"

#: ../../library/enum.rst:708
msgid ""
"*EnumCheck* contains the options used by the :func:`verify` decorator to "
"ensure various constraints; failed constraints result in a :exc:`ValueError`."
msgstr ""
"*EnumCheck* 包含 :func:`verify` 裝飾器使用的選項，以確保多樣的限制，不符合限"
"制會產生 :exc:`ValueError`。"

#: ../../library/enum.rst:713
msgid "Ensure that each value has only one name::"
msgstr "確保每個值只有一個名稱： ::"

#: ../../library/enum.rst:715
msgid ""
">>> from enum import Enum, verify, UNIQUE\n"
">>> @verify(UNIQUE)\n"
"... class Color(Enum):\n"
"...     RED = 1\n"
"...     GREEN = 2\n"
"...     BLUE = 3\n"
"...     CRIMSON = 1\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: aliases found in <enum 'Color'>: CRIMSON -> RED"
msgstr ""
">>> from enum import Enum, verify, UNIQUE\n"
">>> @verify(UNIQUE)\n"
"... class Color(Enum):\n"
"...     RED = 1\n"
"...     GREEN = 2\n"
"...     BLUE = 3\n"
"...     CRIMSON = 1\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: aliases found in <enum 'Color'>: CRIMSON -> RED"

#: ../../library/enum.rst:729
msgid ""
"Ensure that there are no missing values between the lowest-valued member and "
"the highest-valued member::"
msgstr "確保在最小值成員跟最大值成員間沒有缺少值： ::"

#: ../../library/enum.rst:732
msgid ""
">>> from enum import Enum, verify, CONTINUOUS\n"
">>> @verify(CONTINUOUS)\n"
"... class Color(Enum):\n"
"...     RED = 1\n"
"...     GREEN = 2\n"
"...     BLUE = 5\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: invalid enum 'Color': missing values 3, 4"
msgstr ""
">>> from enum import Enum, verify, CONTINUOUS\n"
">>> @verify(CONTINUOUS)\n"
"... class Color(Enum):\n"
"...     RED = 1\n"
"...     GREEN = 2\n"
"...     BLUE = 5\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: invalid enum 'Color': missing values 3, 4"

#: ../../library/enum.rst:744
msgid ""
"Ensure that any flag groups/masks contain only named flags -- useful when "
"values are specified instead of being generated by :func:`auto`::"
msgstr ""
"確保任何旗標群組 / 遮罩只包含命名旗標 -- 當值是用指定而不是透過 :func:`auto` "
"產生時是很實用的： ::"

#: ../../library/enum.rst:747
msgid ""
">>> from enum import Flag, verify, NAMED_FLAGS\n"
">>> @verify(NAMED_FLAGS)\n"
"... class Color(Flag):\n"
"...     RED = 1\n"
"...     GREEN = 2\n"
"...     BLUE = 4\n"
"...     WHITE = 15\n"
"...     NEON = 31\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: invalid Flag 'Color': aliases WHITE and NEON are missing "
"combined values of 0x18 [use enum.show_flag_values(value) for details]"
msgstr ""
">>> from enum import Flag, verify, NAMED_FLAGS\n"
">>> @verify(NAMED_FLAGS)\n"
"... class Color(Flag):\n"
"...     RED = 1\n"
"...     GREEN = 2\n"
"...     BLUE = 4\n"
"...     WHITE = 15\n"
"...     NEON = 31\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: invalid Flag 'Color': aliases WHITE and NEON are missing "
"combined values of 0x18 [use enum.show_flag_values(value) for details]"

#: ../../library/enum.rst:761
msgid ""
"CONTINUOUS and NAMED_FLAGS are designed to work with integer-valued members."
msgstr "CONTINUOUS 和 NAMED_FLAGS 是設計用來運作在整數值的成員上。"

#: ../../library/enum.rst:767
msgid ""
"``FlagBoundary`` controls how out-of-range values are handled in :class:"
"`Flag` and its subclasses."
msgstr "``FlagBoundary`` 控制在 :class:`Flag` 及其子類別中如何處理範圍外的值。"

#: ../../library/enum.rst:772
msgid ""
"Out-of-range values cause a :exc:`ValueError` to be raised. This is the "
"default for :class:`Flag`::"
msgstr "範圍外的值會引發 :exc:`ValueError`。這是 :class:`Flag` 的預設行為： ::"

#: ../../library/enum.rst:775
msgid ""
">>> from enum import Flag, STRICT, auto\n"
">>> class StrictFlag(Flag, boundary=STRICT):\n"
"...     RED = auto()\n"
"...     GREEN = auto()\n"
"...     BLUE = auto()\n"
"...\n"
">>> StrictFlag(2**2 + 2**4)\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: <flag 'StrictFlag'> invalid value 20\n"
"    given 0b0 10100\n"
"  allowed 0b0 00111"
msgstr ""
">>> from enum import Flag, STRICT, auto\n"
">>> class StrictFlag(Flag, boundary=STRICT):\n"
"...     RED = auto()\n"
"...     GREEN = auto()\n"
"...     BLUE = auto()\n"
"...\n"
">>> StrictFlag(2**2 + 2**4)\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: <flag 'StrictFlag'> invalid value 20\n"
"    given 0b0 10100\n"
"  allowed 0b0 00111"

#: ../../library/enum.rst:790
msgid ""
"Out-of-range values have invalid values removed, leaving a valid :class:"
"`Flag` value::"
msgstr "會移除範圍外的值中的非法值，留下合法的 :class:`Flag` 值： ::"

#: ../../library/enum.rst:793
msgid ""
">>> from enum import Flag, CONFORM, auto\n"
">>> class ConformFlag(Flag, boundary=CONFORM):\n"
"...     RED = auto()\n"
"...     GREEN = auto()\n"
"...     BLUE = auto()\n"
"...\n"
">>> ConformFlag(2**2 + 2**4)\n"
"<ConformFlag.BLUE: 4>"
msgstr ""
">>> from enum import Flag, CONFORM, auto\n"
">>> class ConformFlag(Flag, boundary=CONFORM):\n"
"...     RED = auto()\n"
"...     GREEN = auto()\n"
"...     BLUE = auto()\n"
"...\n"
">>> ConformFlag(2**2 + 2**4)\n"
"<ConformFlag.BLUE: 4>"

#: ../../library/enum.rst:804
msgid ""
"Out-of-range values lose their :class:`Flag` membership and revert to :class:"
"`int`."
msgstr "範圍外的值會失去它們的 :class:`Flag` 成員資格且恢復成 :class:`int`。"

#: ../../library/enum.rst:817
msgid ""
"Out-of-range values are kept, and the :class:`Flag` membership is kept. This "
"is the default for :class:`IntFlag`::"
msgstr ""
"範圍外的值會被保留，:class:`Flag` 成員資格也會被保留。這是 :class:`IntFlag` "
"的預設行為： ::"

#: ../../library/enum.rst:820
msgid ""
">>> from enum import Flag, KEEP, auto\n"
">>> class KeepFlag(Flag, boundary=KEEP):\n"
"...     RED = auto()\n"
"...     GREEN = auto()\n"
"...     BLUE = auto()\n"
"...\n"
">>> KeepFlag(2**2 + 2**4)\n"
"<KeepFlag.BLUE|16: 20>"
msgstr ""
">>> from enum import Flag, KEEP, auto\n"
">>> class KeepFlag(Flag, boundary=KEEP):\n"
"...     RED = auto()\n"
"...     GREEN = auto()\n"
"...     BLUE = auto()\n"
"...\n"
">>> KeepFlag(2**2 + 2**4)\n"
"<KeepFlag.BLUE|16: 20>"

#: ../../library/enum.rst:833
msgid ""
"*EnumDict* is a subclass of :class:`dict` that is used as the namespace for "
"defining enum classes (see :ref:`prepare`). It is exposed to allow "
"subclasses of :class:`EnumType` with advanced behavior like having multiple "
"values per member. It should be called with the name of the enum class being "
"created, otherwise private names and internal classes will not be handled "
"correctly."
msgstr ""
"*EnumDict* 是 :class:`dict` 的子類別，用來作為定義列舉類別的命名空間（參見 :"
"ref:`prepare`）。它被公開來使得 :class:`EnumType` 的子類別能具有進階行為，例"
"如讓每個成員有多個值。它應該在被呼叫時帶上正在建立的列舉類別名稱，否則私有名"
"稱和內部類別將無法被正確處理。"

#: ../../library/enum.rst:840
msgid ""
"Note that only the :class:`~collections.abc.MutableMapping` interface (:meth:"
"`~object.__setitem__` and :meth:`~dict.update`) is overridden. It may be "
"possible to bypass the checks using other :class:`!dict` operations like :"
"meth:`|= <object.__ior__>`."
msgstr ""
"注意只有 :class:`~collections.abc.MutableMapping` 介面（:meth:`~object."
"__setitem__` 和 :meth:`~dict.update`）被覆寫。可能可以使用其他 :class:`!"
"dict` 操作來繞過檢查，例如 :meth:`|= <object.__ior__>`。"

#: ../../library/enum.rst:847
msgid "A list of member names."
msgstr "一個成員名稱的串列。"

#: ../../library/enum.rst:854
msgid "Supported ``__dunder__`` names"
msgstr "支援的 ``__dunder__`` 名稱"

#: ../../library/enum.rst:856
msgid ""
":attr:`~EnumType.__members__` is a read-only ordered mapping of "
"``member_name``:``member`` items.  It is only available on the class."
msgstr ""
":attr:`~EnumType.__members__` 是一個唯讀有序的\\ ``成員名稱``：``成員``\\ 項"
"目的對映。只有在類別上可用。"

#: ../../library/enum.rst:859
msgid ""
":meth:`~Enum.__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:`~Enum.__new__`，如果有指定，它必須建立並回傳列舉成員；適當地設定成員"
"的 :attr:`!_value_` 也是一個很好的主意。一旦所有成員都建立之後就不會再被用"
"到。"

#: ../../library/enum.rst:865
msgid "Supported ``_sunder_`` names"
msgstr "支援的 ``_sunder_`` 名稱"

#: ../../library/enum.rst:867
msgid ""
":meth:`~EnumType._add_alias_` -- adds a new name as an alias to an existing "
"member."
msgstr ":meth:`~EnumType._add_alias_` -- 新增一個名稱作為現有成員的別名。"

#: ../../library/enum.rst:869
msgid ""
":meth:`~EnumType._add_value_alias_` -- adds a new value as an alias to an "
"existing member."
msgstr ":meth:`~EnumType._add_value_alias_` -- 新增一個值作為現有成員的別名。"

#: ../../library/enum.rst:871
msgid ":attr:`~Enum._name_` -- name of the member"
msgstr ":attr:`~Enum._name_` -- 成員名稱"

#: ../../library/enum.rst:872
msgid ":attr:`~Enum._value_` -- value of the member; can be set in ``__new__``"
msgstr ":attr:`~Enum._value_` -- 成員的值；可以在 ``__new__`` 設定"

#: ../../library/enum.rst:873
msgid ""
":meth:`~Enum._missing_` -- a lookup function used when a value is not found; "
"may be overridden"
msgstr ""
":meth:`~Enum._missing_` -- 當值沒有被找到時會使用的查詢函式；可以被覆寫"

#: ../../library/enum.rst:875
msgid ""
":attr:`~Enum._ignore_` -- a list of names, either as a :class:`list` or a :"
"class:`str`, that will not be transformed into members, and will be removed "
"from the final class"
msgstr ""
":attr:`~Enum._ignore_` -- 一個名稱的串列，可以是 :class:`list` 或 :class:"
"`str`，它不會被轉換成成員，且在最後的類別上會被移除"

#: ../../library/enum.rst:878
msgid ""
":attr:`~Enum._order_` -- no longer used, kept for backward compatibility "
"(class attribute, removed during class creation)"
msgstr ""
":attr:`~Enum._order_` -- 不再被使用，僅為了向後相容而保留（類別屬性，在類別建"
"立時移除）"

#: ../../library/enum.rst:880
msgid ""
":meth:`~Enum._generate_next_value_` -- used to get an appropriate value for "
"an enum member; may be overridden"
msgstr ""
":meth:`~Enum._generate_next_value_` -- 用來為列舉成員取得合適的值；可以被覆寫"

#: ../../library/enum.rst:885
msgid ""
"For standard :class:`Enum` classes the next value chosen is the highest "
"value seen incremented by one."
msgstr ""
"對標準的 :class:`Enum` 類別來說，下一個被選擇的值是所看過的最大值加一。"

#: ../../library/enum.rst:888
msgid ""
"For :class:`Flag` classes the next value chosen will be the next highest "
"power-of-two."
msgstr ""
"對 :class:`Flag` 類別來說，下一個被選擇的值是下一個最大的 2 的次方的數字。"

#: ../../library/enum.rst:891
msgid ""
"While ``_sunder_`` names are generally reserved for the further development "
"of the :class:`Enum` class and can not be used, some are explicitly allowed:"
msgstr ""
"雖然 ``_sunder_`` 名稱通常保留用於 :class:`Enum` 類別的進一步開發而不能被使"
"用，但有些是明確允許的："

#: ../../library/enum.rst:894
msgid ""
"``_repr_*`` (e.g. ``_repr_html_``), as used in `IPython's rich display`_"
msgstr ""
"``_repr_*``\\ （例如 ``_repr_html_``），例如用於 `IPython 的豐富顯示 "
"<IPython’s rich display_>`_"

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

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

#: ../../library/enum.rst:898
msgid "``_add_alias_``, ``_add_value_alias_``, ``_repr_*``"
msgstr "``_add_alias_``、``_add_value_alias_``、``_repr_*``"

#: ../../library/enum.rst:904
msgid "Utilities and Decorators"
msgstr "通用項目與裝飾器"

#: ../../library/enum.rst:908
msgid ""
"*auto* can be used in place of a value.  If used, the *Enum* machinery will "
"call an :class:`Enum`'s :meth:`~Enum._generate_next_value_` to get an "
"appropriate value. For :class:`Enum` and :class:`IntEnum` that appropriate "
"value will be the last value plus one; for :class:`Flag` and :class:"
"`IntFlag` it will be the first power-of-two greater than the highest value; "
"for :class:`StrEnum` it will be the lower-cased version of the member's "
"name.  Care must be taken if mixing *auto()* with manually specified values."
msgstr ""
"*auto* 可以用來取代給值。如果使用的話，*Enum* 系統會呼叫 :class:`Enum` 的 :"
"meth:`~Enum._generate_next_value_` 來取得合適的值。對 :class:`Enum` 和 :"
"class:`IntEnum` 來說，合適的值是最後一個值加一；對 :class:`Flag` 和 :class:"
"`IntFlag` 來說，是第一個比最大值還大的 2 的次方的數字；對 :class:`StrEnum` 來"
"說，是成員名稱的小寫版本。如果混用 *auto()* 和手動指定值的話要特別注意。"

#: ../../library/enum.rst:916
msgid ""
"*auto* instances are only resolved when at the top level of an assignment:"
msgstr "*auto* 實例只有在最上層的賦值時才會被解析："

#: ../../library/enum.rst:918
msgid "``FIRST = auto()`` will work (auto() is replaced with ``1``);"
msgstr "``FIRST = auto()`` 可以運作（auto() 會被取代成 ``1``）"

#: ../../library/enum.rst:919
msgid ""
"``SECOND = auto(), -2`` will work (auto is replaced with ``2``, so ``2, -2`` "
"is used to create the ``SECOND`` enum member;"
msgstr ""
"``SECOND = auto(), -2`` 可以運作（auto 會被取代成 ``2``, 因此 ``2, -2`` 會被"
"用來建立列舉成員 ``SECOND``；"

#: ../../library/enum.rst:921
msgid ""
"``THREE = [auto(), -3]`` will *not* work (``<auto instance>, -3`` is used to "
"create the ``THREE`` enum member)"
msgstr ""
"``THREE = [auto(), -3]`` *無法*\\ 運作（\\ ``<auto 實例>, -3`` 會被用來建立列"
"舉成員 ``THREE``）"

#: ../../library/enum.rst:926
msgid ""
"In prior versions, ``auto()`` had to be the only thing on the assignment "
"line to work properly."
msgstr "在之前的版本中，``auto()`` 必須是賦值行裡的唯一內容才能運作正確。"

#: ../../library/enum.rst:929
msgid ""
"``_generate_next_value_`` can be overridden to customize the values used by "
"*auto*."
msgstr "可以覆寫 ``_generate_next_value_`` 來客製 *auto* 使用的值。"

#: ../../library/enum.rst:932
msgid ""
"in 3.13 the default ``_generate_next_value_`` will always return the highest "
"member value incremented by 1, and will fail if any member is an "
"incompatible type."
msgstr ""
"在 3.13 預設 ``_generate_next_value_`` 總是回傳最大的成員值加一，如果任何成員"
"是不相容的型別就會失敗。"

#: ../../library/enum.rst:938
msgid ""
"A decorator similar to the built-in *property*, but specifically for "
"enumerations.  It allows member attributes to have the same names as members "
"themselves."
msgstr ""
"和內建的 *property* 相似的裝飾器，但只專門針對列舉。它允許成員屬性和成員本身"
"有相同名稱。"

#: ../../library/enum.rst:942
msgid ""
"the *property* and the member must be defined in separate classes; for "
"example, the *value* and *name* attributes are defined in the *Enum* class, "
"and *Enum* subclasses can define members with the names ``value`` and "
"``name``."
msgstr ""
"*屬性*\\ 和成員必須定義在分開的類別裡；例如 *value* 和 *name* 屬性定義在 "
"*Enum* 類別而 *Enum* 子類別可以定義成員名稱為 ``value`` 和 ``name``。"

#: ../../library/enum.rst:951
msgid ""
"A :keyword:`class` decorator specifically for enumerations.  It searches an "
"enumeration's :attr:`~EnumType.__members__`, gathering any aliases it finds; "
"if any are found :exc:`ValueError` is raised with the details::"
msgstr ""
"專門針對列舉的 :keyword:`class` 裝飾器。它搜尋列舉的 :attr:`~EnumType."
"__members__`，蒐集任何它找到的別名；如果有找到任何別名則引發 :exc:"
"`ValueError` 並附上細節： ::"

#: ../../library/enum.rst:955
msgid ""
">>> from enum import Enum, unique\n"
">>> @unique\n"
"... class Mistake(Enum):\n"
"...     ONE = 1\n"
"...     TWO = 2\n"
"...     THREE = 3\n"
"...     FOUR = 3\n"
"...\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: duplicate values found in <enum 'Mistake'>: FOUR -> THREE"
msgstr ""
">>> from enum import Enum, unique\n"
">>> @unique\n"
"... class Mistake(Enum):\n"
"...     ONE = 1\n"
"...     TWO = 2\n"
"...     THREE = 3\n"
"...     FOUR = 3\n"
"...\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: duplicate values found in <enum 'Mistake'>: FOUR -> THREE"

#: ../../library/enum.rst:969
msgid ""
"A :keyword:`class` decorator specifically for enumerations.  Members from :"
"class:`EnumCheck` are used to specify which constraints should be checked on "
"the decorated enumeration."
msgstr ""
"專門針對列舉的 :keyword:`class` 裝飾器。使用 :class:`EnumCheck` 裡的成員來指"
"定在裝飾的列舉上應該檢查什麼限制。"

#: ../../library/enum.rst:977
msgid "A decorator for use in enums: its target will become a member."
msgstr "列舉所使用的裝飾器：其目標會變成成員。"

#: ../../library/enum.rst:983
msgid "A decorator for use in enums: its target will not become a member."
msgstr "列舉所使用的裝飾器：其目標不會變成成員。"

#: ../../library/enum.rst:989
msgid ""
"A decorator to change the :class:`str() <str>` and :func:`repr` of an enum "
"to show its members as belonging to the module instead of its class. Should "
"only be used when the enum members are exported to the module global "
"namespace (see :class:`re.RegexFlag` for an example)."
msgstr ""
"修改列舉的 :class:`str() <str>` 及 :func:`repr` 的裝飾器，讓成員顯示為屬於模"
"組而不是其類別。應該只有當列舉成員被匯出到模組的全域命名空間才使用（範例請參"
"考 :class:`re.RegexFlag`）。"

#: ../../library/enum.rst:998
msgid "Return a list of all power-of-two integers contained in a flag *value*."
msgstr "回傳在旗標\\ *值*\\ 中包含的所有 2 的次方的整數串列。"

#: ../../library/enum.rst:1006
msgid "Notes"
msgstr "備註"

#: ../../library/enum.rst:1008
msgid ":class:`IntEnum`, :class:`StrEnum`, and :class:`IntFlag`"
msgstr ":class:`IntEnum`、:class:`StrEnum` 及 :class:`IntFlag`"

#: ../../library/enum.rst:1010
msgid ""
"These three enum types are designed to be drop-in replacements for existing "
"integer- and string-based values; as such, they have extra limitations:"
msgstr ""
"這三種列舉型別是設計來直接取代現有以整數及字串為基底的值；因此它們有額外的限"
"制："

#: ../../library/enum.rst:1013
msgid "``__str__`` uses the value and not the name of the enum member"
msgstr "``__str__`` 使用值而不是列舉成員的名稱"

#: ../../library/enum.rst:1015
msgid ""
"``__format__``, because it uses ``__str__``, will also use the value of the "
"enum member instead of its name"
msgstr "``__format__`` 因為使用 ``__str__``，也會使用值而不是列舉成員的名稱"

#: ../../library/enum.rst:1018
msgid ""
"If you do not need/want those limitations, you can either create your own "
"base class by mixing in the ``int`` or ``str`` type yourself::"
msgstr ""
"如果你不需要或不想要這些限制，你可以透過混合 ``int`` 或 ``str`` 型別來建立自"
"己的基礎類別： ::"

#: ../../library/enum.rst:1021
msgid ""
">>> from enum import Enum\n"
">>> class MyIntEnum(int, Enum):\n"
"...     pass"
msgstr ""
">>> from enum import Enum\n"
">>> class MyIntEnum(int, Enum):\n"
"...     pass"

#: ../../library/enum.rst:1025
msgid "or you can reassign the appropriate :meth:`str`, etc., in your enum::"
msgstr "或者你也可以在你的列舉重新給定合適的 :meth:`str`： ::"

#: ../../library/enum.rst:1027
msgid ""
">>> from enum import Enum, IntEnum\n"
">>> class MyIntEnum(IntEnum):\n"
"...     __str__ = Enum.__str__"
msgstr ""
">>> from enum import Enum, IntEnum\n"
">>> class MyIntEnum(IntEnum):\n"
"...     __str__ = Enum.__str__"