`enum` — 列舉支援¶

3.4 版本加入。

列舉

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

列舉可以透過使用 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 等是列舉成員（或成員），並且在功能上是常量。
列舉成員具有名稱和值（Color.RED 的名稱是 RED，Color.BLUE 的值是 3，等等）

模組內容¶

EnumType

type 用於 Enum 及其子類。

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

當子類化 EnumType 時使用的 dict 子類。

auto

例項將替換為 Enum 成員的適當值。StrEnum 預設為成員名稱的小寫版本，而其他 Enum 預設為 1 並從那裡增加。

property()

允許 Enum 成員具有屬性，而不會與成員名稱衝突。 value 和 name 屬性就是以這種方式實現的。

unique()

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

verify()

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

member()

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

nonmember()

不要使 obj 成為成員。可以用作裝飾器。

global_enum()

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

show_flag_values()

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

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 是 enum 列舉的元類。可以對 EnumType 進行子類化 - 有關詳細資訊，請參閱子類化 EnumType。

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

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

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

查詢現有成員

cls：

正在呼叫的列舉類。

value：

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

cls：

正在呼叫的列舉類。

value：

要建立的新列舉的名稱。

名稱:

新列舉的成員的名稱/值。

模組:

建立新列舉的模組的名稱。

限定名:

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

型別:

新列舉的混入型別。

起始值:

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

邊界:

如何處理位運算中的超出範圍的值（僅限 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>]

_add_alias_()¶: 將新名稱作為現有成員的別名新增。如果該名稱已分配給不同的成員，則引發 NameError。

_add_value_alias_()¶: 將新值作為現有成員的別名新增。如果該值已與不同的成員連結，則引發 ValueError。

在 3.11 版本中新增: 在 3.11 版本之前，EnumType 被稱為 EnumMeta，它仍然可用作別名。

class enum.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 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)¶

名稱:

正在定義的成員的名稱（例如，“RED”）。

起始值:

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

計數:

當前定義的成員數，不包括此成員。

上一個值:

先前值的列表。

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

>>> from enum import auto
>>> 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 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() 呼叫的字串。預設情況下，返回 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() 呼叫的字串。預設情況下，返回 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__() 的返回值，但可以被覆蓋。

>>> 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 版本中更改: 添加了 Dataclass 支援

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 成員執行或使用任何字串操作的結果不屬於列舉。

備註

stdlib 中有些地方會檢查是否為確切的 str，而不是 str 的子類（即 type(unknown) == str 而不是 isinstance(unknown, str)），在這些位置，您需要使用 str(StrEnum.member)。

備註

將 auto 與 StrEnum 一起使用會導致成員名稱的小寫形式作為值。

備註

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

在 3.11 版本中新增。

class enum.Flag¶

Flag 與 Enum 相同，但其成員支援按位運算子 & (AND), | (OR), ^ (XOR), 和 ~ (INVERT)；這些運算的結果是列舉的（別名）成員。

__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)¶

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

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

__and__(self, other)¶

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

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

__xor__(self, other)¶

返回當前標誌與 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 一起使用會導致整數值為 2 的冪，從 1 開始。

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

備註

在 IntFlag 中使用 auto 會生成從 1 開始的 2 的冪的整數。

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

對 IntFlag 取反現在返回一個正值，該值是給定標誌中未包含的所有標誌的並集，而不是負值。這與現有的 Flag 行為一致。

class enum.ReprEnum¶

ReprEnum 使用 repr() of Enum，但使用混合資料型別的 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_` 名稱¶

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

備註

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

對於 Flag 類，選擇的下一個值將是下一個最大的 2 的冪。
雖然 _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，它將是大於最大值的第一個 2 的冪；對於 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 和 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_` 名稱¶