`enum` --- 對列舉的支援¶

在 3.4 版本加入。

原始碼： Lib/enum.py

列舉

是繫結到唯一值的符號名稱（成員）的集合
可以被迭代以按定義順序返回其規範（即非別名）成員
使用*呼叫*語法按值返回成員
使用*索引*語法按名稱返回成員

列舉可以透過使用 class 語法，或透過使用函式呼叫語法來建立

>>> from enum import Enum

>>> # class syntax
>>> class Color(Enum):
...     RED = 1
...     GREEN = 2
...     BLUE = 3

>>> # functional syntax
>>> Color = Enum('Color', [('RED', 1), ('GREEN', 2), ('BLUE', 3)])

儘管我們可以使用 class 語法來建立列舉，但列舉並不是普通的 Python 類。更多細節請參閱列舉有何不同？。

備註

命名法

類 Color 是一個*列舉* (或 *enum*)
屬性 Color.RED, Color.GREEN 等，是*列舉成員* (或 *members*)，在功能上是常量。
列舉成員有*名稱*和*值*（Color.RED 的名稱是 RED，Color.BLUE 的值是 3，等等）

模組內容¶

EnumType

Enum 及其子類的 type。

Enum

用於建立列舉常量的基類。

IntEnum

用於建立列舉常量的基類，這些常量也是 int 的子類。 (註釋)

StrEnum

用於建立列舉常量的基類，這些常量也是 str 的子類。 (註釋)

Flag

用於建立列舉常量的基類，這些常量可以使用按位運算進行組合，而不會失去其 Flag 成員資格。

IntFlag

用於建立列舉常量的基類，這些常量可以使用按位運算子進行組合，而不會失去其 IntFlag 成員資格。IntFlag 成員也是 int 的子類。(註釋)

ReprEnum

IntEnum、StrEnum 和 IntFlag 使用它來保留混入型別的 str()。

EnumCheck

一個值為 CONTINUOUS、NAMED_FLAGS 和 UNIQUE 的列舉，與 verify() 一起使用，以確保給定列舉滿足各種約束。

FlagBoundary

一個值為 STRICT、CONFORM、EJECT 和 KEEP 的列舉，允許更精細地控制列舉中如何處理無效值。

EnumDict

一個 dict 的子類，用於子類化 EnumType 時使用。

auto

例項會被替換為適合 Enum 成員的值。StrEnum 預設為成員名稱的小寫版本，而其他列舉預設為 1 並從此遞增。

property()

允許 Enum 成員擁有屬性而不與成員名稱衝突。value 和 name 屬性就是這樣實現的。

unique()

列舉類的裝飾器，確保只有一個名稱繫結到任何一個值。

verify()

列舉類的裝飾器，用於檢查列舉上使用者可選擇的約束。

member()

使 obj 成為一個成員。可以用作裝飾器。

nonmember()

不使 obj 成為一個成員。可用作裝飾器。

global_enum()

修改列舉的 str() 和 repr()，以顯示其成員屬於模組而不是其類，並將列舉成員匯出到全域性名稱空間。

show_flag_values()

返回標誌中包含的所有2的冪的整數列表。

在 3.6 版本加入: Flag, IntFlag, auto

在 3.11 版本加入: StrEnum, EnumCheck, ReprEnum, FlagBoundary, property, member, nonmember, global_enum, show_flag_values

在 3.13 版本加入: EnumDict

資料型別¶

class enum.EnumType¶

EnumType 是*列舉*的元類。可以子類化 EnumType —— 詳情請參見子類化 EnumType。

EnumType 負責在最終的*列舉*上設定正確的 __repr__(), __str__(), __format__() 和 __reduce__() 方法，以及建立列舉成員、正確處理重複項、提供對列舉類的迭代等。

在 3.11 版本加入: 在 3.11 之前，EnumType 被稱為 EnumMeta，它仍然可以作為別名使用。

__call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)¶

此方法以兩種不同的方式被呼叫

查詢一個現有的成員

cls:

被呼叫的列舉類。

value:

要查詢的值。
使用 cls 列舉建立一個新的列舉（僅當現有列舉沒有任何成員時）

cls:

被呼叫的列舉類。

value:

要建立的新列舉的名稱。

names:

新列舉成員的名稱/值。

module:

新 Enum 建立所在的模組的名稱。

qualname:

此列舉在模組中的實際位置。

type:

新 Enum 的混入型別。

start:

列舉的第一個整數值（由 auto 使用）。

boundary:

如何處理位運算中的超出範圍的值（僅限 Flag）。

__contains__(cls, member)¶

如果成員屬於 cls，則返回 True

>>> some_var = Color.RED
>>> some_var in Color
True
>>> Color.RED.value in Color
True

在 3.12 版本發生變更: 在 Python 3.12 之前，如果在包含性檢查中使用非列舉成員，會引發 TypeError。

__dir__(cls)¶

返回 ['__class__', '__doc__', '__members__', '__module__'] 和 cls 中成員的名稱

>>> dir(Color)
['BLUE', 'GREEN', 'RED', '__class__', '__contains__', '__doc__', '__getitem__', '__init_subclass__', '__iter__', '__len__', '__members__', '__module__', '__name__', '__qualname__']

__getitem__(cls, name)¶

返回 cls 中匹配 name 的列舉成員，否則引發 KeyError

>>> Color['BLUE']
<Color.BLUE: 3>

__iter__(cls)¶

按定義順序返回 cls 中的每個成員

>>> list(Color)
[<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>]

__len__(cls)¶

返回 cls 中的成員數量

>>> len(Color)
3

__members__¶: 返回每個列舉名稱到其成員的對映，包括別名

__reversed__(cls)¶

按定義順序的逆序返回 cls 中的每個成員

>>> list(reversed(Color))
[<Color.BLUE: 3>, <Color.GREEN: 2>, <Color.RED: 1>]

class enum.Enum¶

Enum 是所有*列舉*的基類。

name¶

用於定義 Enum 成員的名稱

>>> Color.BLUE.name
'BLUE'

value¶

賦予 Enum 成員的值

>>> Color.RED.value
1

成員的值，可以在 __new__() 中設定。

備註

列舉成員值

成員值可以是任何東西：int, str 等。如果確切的值不重要，你可以使用 auto 例項，一個適當的值將被為你選擇。詳見 auto。

雖然可以使用可變/不可雜湊的值，例如 dict、list 或可變的 dataclass，但這將在建立期間產生相對於列舉中可變/不可雜湊值總數的二次效能影響。

_name_¶: 成員的名稱。

_value_¶: 成員的值，可以在 __new__() 中設定。

_order_¶: 不再使用，為向後相容而保留。（類屬性，在類建立期間被移除）。

_ignore_¶

_ignore_ 僅在建立期間使用，並在建立完成後從列舉中移除。

_ignore_ 是一個名稱列表，這些名稱不會成為成員，並且其名稱也將從完成的列舉中移除。請參閱 TimePeriod 示例。

__dir__(self)¶

返回 ['__class__', '__doc__', '__module__', 'name', 'value'] 以及在 self.__class__ 上定義的任何公共方法

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

_generate_next_value_(name, start, count, last_values)¶

name:

正在定義的成員的名稱（例如 'RED'）。

start:

列舉的起始值；預設為 1。

count:

當前已定義的成員數量，不包括這一個。

last_values:

先前值的列表。

一個 *staticmethod*，用於確定 auto 返回的下一個值

>>> from enum import auto, Enum
>>> class PowersOfThree(Enum):
...     @staticmethod
...     def _generate_next_value_(name, start, count, last_values):
...         return 3 ** (count + 1)
...     FIRST = auto()
...     SECOND = auto()
...
>>> PowersOfThree.SECOND.value
9

__init__(self, *args, **kwds)¶

預設情況下，什麼也不做。如果在成員賦值中給出了多個值，這些值將成為 __init__ 的獨立引數；例如

>>> from enum import Enum
>>> class Weekday(Enum):
...     MONDAY = 1, 'Mon'

Weekday.__init__() 將被呼叫為 Weekday.__init__(self, 1, 'Mon')

__init_subclass__(cls, **kwds)¶: 一個 classmethod，用於進一步配置後續子類。預設情況下，什麼也不做。

_missing_(cls, value)¶

一個 classmethod，用於查詢在 cls 中未找到的值。預設情況下它什麼都不做，但可以被重寫以實現自定義搜尋行為。

>>> from enum import auto, StrEnum
>>> class Build(StrEnum):
...     DEBUG = auto()
...     OPTIMIZED = auto()
...     @classmethod
...     def _missing_(cls, value):
...         value = value.lower()
...         for member in cls:
...             if member.value == value:
...                 return member
...         return None
...
>>> Build.DEBUG.value
'debug'
>>> Build('deBUG')
<Build.DEBUG: 'debug'>

__new__(cls, *args, **kwds)¶

預設情況下，不存在。如果指定，無論是在列舉類定義中還是在混入類中（例如 int），成員賦值中給出的所有值都將被傳遞；例如

>>> from enum import Enum
>>> class MyIntEnum(int, Enum):
...     TWENTYSIX = '1a', 16

結果是對 int('1a', 16) 的呼叫，成員的值為 26。

備註

當編寫自定義 __new__ 時，不要使用 super().__new__ —— 而是呼叫相應的 __new__。

__repr__(self)¶

返回用於 repr() 呼叫的字串。預設情況下，返回*列舉*名稱、成員名稱和值，但可以被重寫

>>> from enum import auto, Enum
>>> class OtherStyle(Enum):
...     ALTERNATE = auto()
...     OTHER = auto()
...     SOMETHING_ELSE = auto()
...     def __repr__(self):
...         cls_name = self.__class__.__name__
...         return f'{cls_name}.{self.name}'
...
>>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
(OtherStyle.ALTERNATE, 'OtherStyle.ALTERNATE', 'OtherStyle.ALTERNATE')

__str__(self)¶

返回用於 str() 呼叫的字串。預設情況下，返回*列舉*名稱和成員名稱，但可以被重寫

>>> from enum import auto, Enum
>>> class OtherStyle(Enum):
...     ALTERNATE = auto()
...     OTHER = auto()
...     SOMETHING_ELSE = auto()
...     def __str__(self):
...         return f'{self.name}'
...
>>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
(<OtherStyle.ALTERNATE: 1>, 'ALTERNATE', 'ALTERNATE')

__format__(self)¶

返回用於 format() 和 f-string 呼叫的字串。預設情況下，返回 __str__() 的返回值，但可以被重寫

>>> from enum import auto, Enum
>>> class OtherStyle(Enum):
...     ALTERNATE = auto()
...     OTHER = auto()
...     SOMETHING_ELSE = auto()
...     def __format__(self, spec):
...         return f'{self.name}'
...
>>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
(<OtherStyle.ALTERNATE: 1>, 'OtherStyle.ALTERNATE', 'ALTERNATE')

備註

將 auto 與 Enum 一起使用會產生從 1 開始遞增的整數。

在 3.12 版本發生變更: 添加了資料類支援

_add_alias_()¶

將一個新名稱作為現有成員的別名新增

>>> Color.RED._add_alias_("ERROR")
>>> Color.ERROR
<Color.RED: 1>

如果名稱已分配給不同的成員，則引發 NameError。

在 3.13 版本加入。

_add_value_alias_()¶

將一個新值作為現有成員的別名新增

>>> Color.RED._add_value_alias_(42)
>>> Color(42)
<Color.RED: 1>

如果該值已與不同成員關聯，則引發 ValueError。

在 3.13 版本加入。

class enum.IntEnum¶

IntEnum 與 Enum 相同，但其成員也是整數，並且可以在任何可以使用整數的地方使用。如果對 IntEnum 成員執行任何整數運算，結果值將失去其列舉狀態。

>>> from enum import IntEnum
>>> class Number(IntEnum):
...     ONE = 1
...     TWO = 2
...     THREE = 3
...
>>> Number.THREE
<Number.THREE: 3>
>>> Number.ONE + Number.TWO
3
>>> Number.THREE + 5
8
>>> Number.THREE == 3
True

備註

將 auto 與 IntEnum 一起使用會產生從 1 開始遞增的整數。

在 3.11 版本發生變更: __str__() 現在是 int.__str__()，以更好地支援*替換現有常量*的用例。__format__() 出於同樣的原因，已經是 int.__format__()。

class enum.StrEnum¶

StrEnum 與 Enum 相同，但其成員也是字串，並且可以在大多數可以使用字串的地方使用。對 StrEnum 成員執行或與之相關的任何字串操作的結果都不屬於該列舉。

>>> from enum import StrEnum, auto
>>> class Color(StrEnum):
...     RED = 'r'
...     GREEN = 'g'
...     BLUE = 'b'
...     UNKNOWN = auto()
...
>>> Color.RED
<Color.RED: 'r'>
>>> Color.UNKNOWN
<Color.UNKNOWN: 'unknown'>
>>> str(Color.UNKNOWN)
'unknown'

備註

標準庫中有一些地方會檢查確切的 str 而不是 str 子類（即 type(unknown) == str 而不是 isinstance(unknown, str)），在這些地方你需要使用 str(MyStrEnum.MY_MEMBER)。

備註

將 auto 與 StrEnum 一起使用會產生小寫的成員名稱作為值。

備註

為了更好地支援*替換現有常量*的用例，__str__() 是 str.__str__()。出於同樣的原因，__format__() 同樣是 str.__format__()。

在 3.11 版本中新增。

class enum.Flag¶

Flag 與 Enum 相同，但其成員支援位運算子 & (*與*), | (*或*), ^ (*異或*) 和 ~ (*取反*)；這些操作的結果是列舉的成員（的別名）。

__contains__(self, value)¶

如果 value 在 self 中，則返回 *True*

>>> from enum import Flag, auto
>>> class Color(Flag):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> purple = Color.RED | Color.BLUE
>>> white = Color.RED | Color.GREEN | Color.BLUE
>>> Color.GREEN in purple
False
>>> Color.GREEN in white
True
>>> purple in white
True
>>> white in purple
False

__iter__(self)

返回所有包含的非別名成員

>>> list(Color.RED)
[<Color.RED: 1>]
>>> list(purple)
[<Color.RED: 1>, <Color.BLUE: 4>]

在 3.11 版本中新增。

__len__(self)

返回標誌中的成員數

>>> len(Color.GREEN)
1
>>> len(white)
3

在 3.11 版本中新增。

__bool__(self)

如果標誌中有任何成員，則返回 *True*，否則返回 *False*

>>> bool(Color.GREEN)
True
>>> bool(white)
True
>>> black = Color(0)
>>> bool(black)
False

__or__(self, other)¶

返回當前標誌與另一個標誌進行二進位制或運算的結果

>>> Color.RED | Color.GREEN
<Color.RED|GREEN: 3>

__and__(self, other)¶

返回當前標誌與另一個標誌進行二進位制與運算的結果

>>> purple & white
<Color.RED|BLUE: 5>
>>> purple & Color.GREEN
<Color: 0>

__xor__(self, other)¶

返回當前標誌與另一個標誌進行二進位制異或運算的結果

>>> purple ^ white
<Color.GREEN: 2>
>>> purple ^ Color.GREEN
<Color.RED|GREEN|BLUE: 7>

__invert__(self)

返回 *type(self)* 中所有不在 *self* 中的標誌

>>> ~white
<Color: 0>
>>> ~purple
<Color.GREEN: 2>
>>> ~Color.RED
<Color.GREEN|BLUE: 6>

_numeric_repr_()¶: 用於格式化任何剩餘的未命名數值的函式。預設是值的 repr；常見的選擇是 hex() 和 oct()。

備註

將 auto 與 Flag 一起使用會產生從 1 開始的 2 的冪的整數。

在 3.11 版本發生變更: 零值標誌的 *repr()* 已更改。現在是

>>> Color(0)
<Color: 0>

class enum.IntFlag¶

IntFlag 與 Flag 相同，但其成員也是整數，並且可以在任何可以使用整數的地方使用。

>>> from enum import IntFlag, auto
>>> class Color(IntFlag):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> Color.RED & 2
<Color: 0>
>>> Color.RED | 2
<Color.RED|GREEN: 3>

如果對 IntFlag 成員執行任何整數運算，結果不是 IntFlag

>>> Color.RED + 2
3

如果對一個 IntFlag 成員執行一個 Flag 操作並且

結果是有效的 IntFlag：返回一個 IntFlag
結果不是有效的 IntFlag：結果取決於 FlagBoundary 設定

未命名的零值標誌的 repr() 已更改。現在是

>>> Color(0)
<Color: 0>

備註

將 auto 與 IntFlag 一起使用會產生從 1 開始的2的冪的整數。

在 3.11 版本發生變更: __str__() 現在是 int.__str__()，以更好地支援*替換現有常量*的用例。__format__() 出於同樣的原因，已經是 int.__format__()。

IntFlag 的反轉現在返回一個正值，該值是所有不在給定標誌中的標誌的並集，而不是一個負值。這與現有的 Flag 行為相匹配。

class enum.ReprEnum¶

ReprEnum 使用 Enum 的 repr()，但使用混入資料型別的 str()

IntEnum 和 IntFlag 的 int.__str__()
StrEnum 的 str.__str__()

從 ReprEnum 繼承，以保留混入資料型別的 str() / format()，而不是使用 Enum 預設的 str()。

在 3.11 版本中新增。

class enum.EnumCheck¶

EnumCheck 包含 verify() 裝飾器使用的選項，以確保各種約束；未透過的約束會導致 ValueError。

UNIQUE¶

確保每個值只有一個名稱

>>> from enum import Enum, verify, UNIQUE
>>> @verify(UNIQUE)
... class Color(Enum):
...     RED = 1
...     GREEN = 2
...     BLUE = 3
...     CRIMSON = 1
Traceback (most recent call last):
...
ValueError: aliases found in <enum 'Color'>: CRIMSON -> RED

CONTINUOUS¶

確保最低值成員和最高值成員之間沒有缺失的值

>>> from enum import Enum, verify, CONTINUOUS
>>> @verify(CONTINUOUS)
... class Color(Enum):
...     RED = 1
...     GREEN = 2
...     BLUE = 5
Traceback (most recent call last):
...
ValueError: invalid enum 'Color': missing values 3, 4

NAMED_FLAGS¶

確保任何標誌組/掩碼只包含已命名的標誌——當值是指定的而不是由 auto() 生成時很有用

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

備註

CONTINUOUS 和 NAMED_FLAGS 設計用於處理整數值的成員。

在 3.11 版本中新增。

class enum.FlagBoundary¶

FlagBoundary 控制在 Flag 及其子類中如何處理超出範圍的值。

STRICT¶

超出範圍的值會導致引發 ValueError。這是 Flag 的預設行為

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

CONFORM¶

超出範圍的值會移除無效值，留下一個有效的 Flag 值

>>> from enum import Flag, CONFORM, auto
>>> class ConformFlag(Flag, boundary=CONFORM):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> ConformFlag(2**2 + 2**4)
<ConformFlag.BLUE: 4>

EJECT¶

超出範圍的值將失去其 Flag 成員資格並恢復為 int。

>>> from enum import Flag, EJECT, auto
>>> class EjectFlag(Flag, boundary=EJECT):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> EjectFlag(2**2 + 2**4)
20

KEEP¶

超出範圍的值將被保留，並且 Flag 成員資格也會被保留。這是 IntFlag 的預設行為

>>> from enum import Flag, KEEP, auto
>>> class KeepFlag(Flag, boundary=KEEP):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> KeepFlag(2**2 + 2**4)
<KeepFlag.BLUE|16: 20>

在 3.11 版本中新增。

class enum.EnumDict¶

EnumDict 是 dict 的子類，用作定義列舉類的名稱空間（參見準備類名稱空間）。它被公開以允許 EnumType 的子類具有高階行為，例如每個成員有多個值。呼叫時應提供正在建立的列舉類的名稱，否則私有名稱和內部類將無法正確處理。

請注意，只有 MutableMapping 介面（__setitem__() 和 update()）被重寫。可能會透過其他 dict 操作（如 |=）繞過檢查。

member_names¶: 一個成員名稱的列表。

在 3.13 版本加入。

受支援的 `dunder` 名稱¶

__members__ 是一個只讀的有序對映，包含 member_name:member 項。它僅在類上可用。

__new__()，如果指定，必須建立並返回列舉成員；同時，適當地設定成員的 _value_ 也是一個很好的做法。一旦所有成員都建立完畢，它就不再被使用。

支援的 `_sunder_` 名稱¶

_name_ -- 成員的名稱
_value_ -- 成員的值；可以在 __new__ 中設定
_missing_() -- 當未找到值時使用的查詢函式；可以被重寫
_ignore_ -- 一個名稱列表，可以是 list 或 str，這些名稱不會被轉換為成員，並且將從最終的類中移除
_order_ – 已不再使用，為保持向後相容而保留（類屬性，在類建立期間被移除）
_generate_next_value_() – 用於為列舉成員獲取適當的值；可以被重寫

備註

對於標準的 Enum 類，選擇的下一個值是所見過的最高值加一。

對於 Flag 類，下一個選擇的值將是下一個更高的2的冪。
_add_alias_() – 將一個新名稱作為現有成員的別名新增。
_add_value_alias_() – 將一個新值作為現有成員的別名新增。
雖然 _sunder_ 名稱通常保留用於 Enum 類的進一步開發，不能使用，但有些是明確允許的
- _repr_* (例如 _repr_html_), 如在 IPython的富文字顯示中使用

在 3.6 版本加入: _missing_, _order_, _generate_next_value_

在 3.7 版本加入: _ignore_

在 3.13 版本加入: _add_alias_, _add_value_alias_, _repr_*

工具與裝飾器¶

class enum.auto¶

auto 可以用來代替一個值。如果使用，Enum 機制將呼叫一個 Enum 的 _generate_next_value_() 來獲取一個適當的值。對於 Enum 和 IntEnum，這個適當的值將是最後一個值加一；對於 Flag 和 IntFlag，它將是大於最高值的第一個二的冪；對於 StrEnum，它將是成員名稱的小寫版本。如果將 auto() 與手動指定的值混合使用，必須小心。

auto 例項僅在賦值的頂層被解析

FIRST = auto() 會工作 (auto() 被替換為 1)；
SECOND = auto(), -2 會工作 (auto 被替換為 2, 所以 2, -2 被用來建立 SECOND 列舉成員；
THREE = [auto(), -3] 將*不*工作 (<auto instance>, -3 被用來建立 THREE 列舉成員)

在 3.11.1 版本發生變更: 在早期版本中，auto() 必須是賦值行上的唯一內容才能正常工作。

_generate_next_value_ 可以被重寫以自定義 auto 使用的值。

備註

在 3.13 中，預設的 _generate_next_value_ 將總是返回最高成員值加 1，如果任何成員是不相容的型別，則會失敗。

@enum.property¶: 一個類似於內建 property 的裝飾器，但專門用於列舉。它允許成員屬性與成員本身具有相同的名稱。

備註

property 和成員必須在不同的類中定義；例如，value 和 name 屬性在 Enum 類中定義，而 Enum 子類可以定義名為 value 和 name 的成員。

在 3.11 版本中新增。

@enum.unique¶

一個專門用於列舉的 class 裝飾器。它搜尋列舉的 __members__，收集它找到的任何別名；如果找到任何別名，則會引發 ValueError 並附帶詳細資訊。

>>> from enum import Enum, unique
>>> @unique
... class Mistake(Enum):
...     ONE = 1
...     TWO = 2
...     THREE = 3
...     FOUR = 3
...
Traceback (most recent call last):
...
ValueError: duplicate values found in <enum 'Mistake'>: FOUR -> THREE

@enum.verify¶: 一個專門用於列舉的 class 裝飾器。來自 EnumCheck 的成員用於指定應在被裝飾的列舉上檢查哪些約束。

在 3.11 版本中新增。

@enum.member¶: 一個用於列舉的裝飾器：其目標將成為一個成員。

在 3.11 版本中新增。

@enum.nonmember¶: 一個用於列舉的裝飾器：其目標將不會成為一個成員。

在 3.11 版本中新增。

@enum.global_enum¶: 一個裝飾器，用於更改列舉的 str() 和 repr()，以顯示其成員屬於模組而不是其類。只應在列舉成員匯出到模組全域性名稱空間時使用（參見 re.RegexFlag 示例）。

在 3.11 版本中新增。

enum.show_flag_values(value)¶: 返回一個標誌 *value* 中包含的所有2的冪的整數列表。

在 3.11 版本中新增。

註釋¶

IntEnum, StrEnum, and IntFlag

這三種列舉型別旨在作為現有基於整數和字串的值的直接替代品；因此，它們有額外的限制

__str__ 使用值而不是列舉成員的名稱

__format__，因為它使用 __str__，也將使用列舉成員的值而不是其名稱

如果你不需要/不想要這些限制，你可以自己透過混入 int 或 str 型別來建立你自己的基類
>>> from enum import Enum
>>> class MyIntEnum(int, Enum):
...     pass
或者你可以在你的列舉中重新分配相應的 str() 等。
>>> from enum import Enum, IntEnum
>>> class MyIntEnum(IntEnum):
...     __str__ = Enum.__str__

`enum` --- 對列舉的支援¶

模組內容¶

資料型別¶

受支援的 `dunder` 名稱¶

支援的 `_sunder_` 名稱¶

工具與裝飾器¶

註釋¶

目錄

上一主題

下一主題

本頁

enum --- 對列舉的支援¶

模組內容¶

資料型別¶

受支援的 __dunder__ 名稱¶

支援的 _sunder_ 名稱¶

工具與裝飾器¶

註釋¶

`enum` --- 對列舉的支援¶

受支援的 `dunder` 名稱¶

支援的 `_sunder_` 名稱¶