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

Added in version 3.4.

Источник: Lib/enum.py

Перечисление:

это набор символических имен (членов), связанных с уникальными значениями
можно итерировать, чтобы вернуть его канонические (то есть неалиасные) члены в порядке определения
использует синтаксис call для возврата членов по значению
использует синтаксис index для возврата членов по имени

Перечисления создаются либо с помощью синтаксиса class, либо с помощью синтаксиса вызова функции:

>>> from enum import Enum

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

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

Несмотря на то, что мы можем использовать синтаксис class для создания Enums, Enums не являются обычными классами Python. Более подробную информацию см. в разделе How are Enums different?.

Примечание

Номенклатура

Класс Color - это перечисление (или перечисление)
Атрибуты Color.RED, Color.GREEN и т. д. являются членами перечисления (или членами) и функционально являются константами.
Члены перечисления имеют имена и значения (имя Color.RED - это RED, значение Color.BLUE - это 3 и т.д.).

Содержание модуля¶

EnumType

type для Enum и его подклассов.

Enum

Базовый класс для создания перечисляемых констант.

IntEnum

Базовый класс для создания перечисляемых констант, которые также являются подклассами int. (Notes)

StrEnum

Базовый класс для создания перечисляемых констант, которые также являются подклассами str. (Notes)

Flag

Базовый класс для создания перечисляемых констант, которые можно объединять с помощью побитовых операций без потери их принадлежности к Flag.

IntFlag

Базовый класс для создания перечисляемых констант, которые можно объединять с помощью побитовых операторов без потери принадлежности к IntFlag. Члены IntFlag также являются подклассами int. (Notes)

ReprEnum

Используется IntEnum, StrEnum и IntFlag для сохранения str() смешанного типа.

EnumCheck

Перечисление со значениями CONTINUOUS, NAMED_FLAGS и UNIQUE, используемое вместе с verify() для обеспечения выполнения различных ограничений данным перечислением.

FlagBoundary

Перечисление со значениями STRICT, CONFORM, EJECT и KEEP, которое позволяет более тонко управлять тем, как обрабатываются недопустимые значения в перечислении.

auto

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

property()

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

unique()

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

verify()

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

member()

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

nonmember()

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

global_enum()

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

show_flag_values()

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

Added in version 3.6: Flag, IntFlag, auto

Added in version 3.11: StrEnum, EnumCheck, ReprEnum, FlagBoundary, property, member, nonmember, global_enum, show_flag_values

Типы данных¶

class enum.EnumType¶

EnumType - это metaclass для перечислений enum. Возможно создание подклассов EnumType - подробности см. в Subclassing EnumType.

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

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

Этот метод вызывается двумя разными способами:

чтобы найти существующего пользователя:

cls:

Вызываемый класс перечисления.

значение:

Значение для поиска.
использовать перечисление cls для создания нового перечисления (только если существующее перечисление не имеет членов):

cls:

Вызываемый класс перечисления.

значение:

Имя нового создаваемого Enum.

имена:

Имена/значения членов нового Enum.

модуль:

Имя модуля, в котором создается новый Enum.

qualname:

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

тип:

Смешанный тип для нового Enum.

запустить:

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

граница:

Как обрабатывать значения, выходящие за пределы диапазона при битовых операциях (только:class: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, если в проверке содержимого используется член, не являющийся числом, то возникает ошибка 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>]

_add_alias_()¶: Добавляет новое имя в качестве псевдонима к существующему участнику. Вызывает ошибку NameError, если имя уже присвоено другому участнику.

_add_value_alias_()¶: Добавляет новое значение в качестве псевдонима к существующему члену. Вызывает ошибку ValueError, если значение уже связано с другим членом.

Added in version 3.11: До версии 3.11 EnumType назывался EnumMeta, который по-прежнему доступен в качестве псевдонима.

class enum.Enum¶

Enum - это базовый класс для всех перечислений enum.

name¶

Имя, используемое для определения члена Enum:

>>> Color.BLUE.name
'BLUE'

value¶

Значение, присваиваемое члену Enum:

>>> Color.RED.value
1

Значение члена, может быть установлено в __new__().

Примечание

Значения членов Enum

Значения членов могут быть любыми: 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“).

запустить:

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

считать:

Количество определенных в данный момент членов, не включая этот.

последние_значения:

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

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

По умолчанию не существует. Если указано либо в определении класса enum, либо в классе mixin (например, 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: Добавлено Поддержка классов данных

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__() по той же причине.

Added in version 3.11.

class enum.Flag¶

Flag - то же самое, что и Enum, но его члены поддерживают побитовые операторы & (AND), | (OR), ^ (XOR) и ~ (INVERT); результаты этих операторов являются членами перечисления.

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

Added in version 3.11.

__len__(self):

Возвращает количество членов во флаге:

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

__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

Если операция Flag выполняется с членом IntFlag и:

результат является допустимым 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().

Added in version 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 предназначены для работы с членами, имеющими целочисленное значение.

Added in version 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>

Added in version 3.11.

Поддерживаемые имена `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 в качестве следующего значения будет выбрана наибольшая степень двойки.
Хотя имена _sunder_ обычно резервируются для дальнейшего развития класса Enum и не могут быть использованы, некоторые из них явно разрешены:
- _repr_* (например, _repr_html_), как используется в IPython’s rich display

Added in version 3.6: _missing_, _order_, _generate_next_value_

Added in version 3.7: _ignore_

Added in version 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, но специально для перечислений. Он позволяет атрибутам членов иметь те же имена, что и сами члены.

Примечание

свойство* и член должны быть определены в отдельных классах; например, атрибуты value и name определены в классе Enum, а подклассы Enum могут определять члены с именами value и name.

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

Added in version 3.11.

@enum.member¶: Декоратор для использования в перечислениях: его цель становится членом перечисления.

Added in version 3.11.

@enum.nonmember¶: Декоратор для использования в перечислениях: его цель не станет членом перечисления.

Added in version 3.11.

@enum.global_enum¶: Декоратор, изменяющий str() и repr() перечисления, чтобы показать его члены как принадлежащие модулю, а не его классу. Должен использоваться только в том случае, если члены перечисления экспортируются в глобальное пространство имен модуля (пример см. в re.RegexFlag).

Added in version 3.11.

enum.show_flag_values(value)¶: Возвращает список всех целых чисел, содержащихся во флаге значение.

Added in version 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_`¶