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 является имя элемента в нижнем регистре, тогда как для других перечислений значением по умолчанию служит 1, а последующие значения увеличиваются.

@~enum.property

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

@unique

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

@verify

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

@member

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

@nonmember

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

@global_enum

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

show_flag_values()

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

enum.bin()

Подобно встроенной функции bin(), но отрицательные значения представляются в дополнительном коде, а старший бит всегда указывает знак (0 означает положительное число, 1 — отрицательное).

Типы данных

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_

Больше не используется, сохранён для обратной совместимости. (Атрибут класса, удаляемый при создании класса.)

Атрибут _order_ можно указать, чтобы синхронизировать код Python 2 и Python 3. Он сверяется с фактическим порядком элементов перечисления; если они не совпадают, возникает ошибка:

>>> class Color(Enum):
...     _order_ = 'RED GREEN BLUE'
...     RED = 1
...     BLUE = 3
...     GREEN = 2
...
Traceback (most recent call last):
...
TypeError: member order does not match _order_:
   ['RED', 'BLUE', 'GREEN']
   ['RED', 'GREEN', 'BLUE']

Примечание

В коде Python 2 атрибут _order_ необходим, поскольку порядок определения теряется до того, как его можно сохранить.

Добавлено в версии 3.6.

_ignore_

_ignore_ используется только во время создания и удаляется из перечисления после завершения создания.

_ignore_ — это список имён, которые не станут элементами; их имена также будут удалены из готового перечисления. Пример см. в разделе Период времени.

Добавлено в версии 3.7.

__dir__(self)

Возвращает ['__class__', '__doc__', '__module__', 'name', 'value'] и все открытые методы, определённые в self.__class__:

>>> from enum import Enum
>>> import datetime as dt
>>> class Weekday(Enum):
...     MONDAY = 1
...     TUESDAY = 2
...     WEDNESDAY = 3
...     THURSDAY = 4
...     FRIDAY = 5
...     SATURDAY = 6
...     SUNDAY = 7
...     @classmethod
...     def today(cls):
...         print(f'today is {cls(dt.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:

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

staticmethod, используемый для определения следующего значения, возвращаемого auto.

Примечание

Для стандартных классов Enum следующим выбирается наибольшее из встречавшихся значений, увеличенное на единицу.

Для классов Flag следующим выбирается ближайшая большая степень двойки.

Этот метод можно переопределить, например:

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

Добавлено в версии 3.6.

Изменено в версии 3.13: В предыдущих версиях использовалось последнее встречавшееся значение, а не наибольшее.

__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'>

Добавлено в версии 3.6.

__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-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: Добавлена поддержка dataclass

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

Добавлено в версии 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, если value входит в 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 вызывает метод 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 флага.

Добавлено в версии 3.11.

enum.bin(num, max_bits=None)

Аналог встроенного bin(), за исключением того, что отрицательные значения представляются в дополнительном коде, а старший бит всегда указывает знак (0 означает положительное значение, 1 — отрицательное).

>>> import enum
>>> enum.bin(10)
'0b0 1010'
>>> enum.bin(~10)   # ~10 is -11
'0b1 0101'

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