enum — Поддержка перечислений

Содержимое модуля

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

Подкласс dict, используемый при создании подклассов EnumType.

auto

Экземпляры заменяются подходящим значением для элементов Enum. По умолчанию StrEnum использует имя элемента в нижнем регистре, тогда как другие Enum по умолчанию начинают с 1 и увеличивают значение на единицу.

property()

Позволяет элементам Enum иметь атрибуты, не конфликтующие с именами элементов. Атрибуты value и name реализованы таким образом.

unique()

Декоратор класса Enum, гарантирующий, что каждому значению соответствует только одно имя.

verify()

Декоратор класса Enum, проверяющий заданные пользователем ограничения для перечисления.

member()

Сделать obj элементом. Можно использовать как декоратор.

nonmember()

Не делать obj элементом. Можно использовать как декоратор.

global_enum()

Изменить str() и repr() перечисления так, чтобы его элементы отображались как принадлежащие модулю, а не классу, и экспортировать элементы перечисления в глобальное пространство имён.

show_flag_values()

Возвращает список всех целых чисел — степеней двойки, содержащихся во флаге.

Типы данных

class enum.EnumType

EnumType — это метакласс для перечислений enum. От EnumType можно создавать подклассы — подробности см. в разделе Создание подклассов EnumType.

EnumType отвечает за назначение правильных методов __repr__(), __str__(), __format__() и __reduce__() конечному перечислению enum, а также за создание элементов перечисления, правильную обработку дубликатов, поддержку итерации по классу перечисления и т. д.

Добавлено в версии 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:

  Имя создаваемого нового перечисления Enum.

  names:

  Имена/значения элементов нового перечисления Enum.

  module:

  Имя модуля, в котором создаётся новое перечисление Enum.

  qualname:

  Фактическое расположение в модуле, где можно найти это перечисление Enum.

  type:

  Тип примеси для нового перечисления Enum.

  start:

  Первое целочисленное значение для перечисления Enum (используется в auto).

  boundary:

  Способ обработки значений, выходящих за допустимый диапазон при побитовых операциях (только для Flag).

__contains__(cls, member)

Возвращает True, если элемент принадлежит cls:

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

Изменено в версии 3.12: До Python 3.12 при проверке вхождения элемента, не являющегося элементом Enum, возникало исключение 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)

Возвращает элемент Enum в 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 — базовый класс для всех перечислений 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:

Начальное значение для перечисления Enum; по умолчанию равно 1.

count:

Число уже определённых элементов, не включая этот элемент.

last_values:

Список предыдущих значений.

Статический метод, используемый для определения следующего значения, возвращаемого 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)

Метод класса, используемый для дополнительной настройки последующих подклассов. По умолчанию ничего не делает.

_missing_(cls, value)

Метод класса для поиска значений, не найденных в 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(). По умолчанию возвращает имя Enum, имя элемента и значение, но этот метод можно переопределить:

>>> 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(). По умолчанию возвращает имя Enum и имя элемента, но этот метод можно переопределить:

>>> 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-строк. По умолчанию возвращает значение, возвращаемое __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)

Возвращает True, если значение входит в self:

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

Изменено в версии 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.

Изменено в версии 3.11: __str__() теперь int.__str__() для лучшей поддержки сценария замены существующих констант. По той же причине __format__() уже был int.__format__().

Инверсия IntFlag теперь возвращает положительное значение, представляющее объединение всех флагов, отсутствующих в заданном флаге, вместо отрицательного значения. Это соответствует существующему поведению Flag.

class enum.ReprEnum

ReprEnum использует repr() из Enum, но str() смешанного типа данных:

• int.__str__() для IntEnum и IntFlag
• str.__str__() для StrEnum

Наследуйтесь от 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.

Вспомогательные средства и декораторы

class enum.auto

auto можно использовать вместо значения. Если он используется, механизм Enum вызовет метод _generate_next_value_() класса Enum, чтобы получить подходящее значение. Для 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.

Добавлено в версии 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__