> **Источник:** https://python-all.ru/3.16/library/enum.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

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

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

**Исходный код:** [Lib/enum.py](https://python-all.ru/src/main/Lib/enum.py)

Важно

На этой странице содержится справочная информация по API. Обучающую информацию и обсуждение более сложных тем см. в

- [Базовое руководство](https://python-all.ru/3.16/howto/enum.html#enum-basic-tutorial)
- [Продвинутое руководство](https://python-all.ru/3.16/howto/enum.html#enum-advanced-tutorial)
- [Кулинарная книга Enum](https://python-all.ru/3.16/howto/enum.html#enum-cookbook)

---

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

- это набор символических имён (членов), привязанных к уникальным значениям
- может быть перебрано для возврата канонических (т.е. не псевдонимов) членов в порядке определения
- использует синтаксис *вызова* для возврата членов по значению
- использует синтаксис *индексации* для возврата членов по имени

Перечисления создаются либо с помощью синтаксиса [`class`](https://python-all.ru/3.16/reference/compound_stmts.html#class), либо с помощью синтаксиса вызова функции:

```python
>>> from enum import Enum

>>> # синтаксис класса
>>> class Color(Enum):
...     RED = 1
...     GREEN = 2
...     BLUE = 3

>>> # функциональный синтаксис
>>> Color = Enum('Color', [('RED', 1), ('GREEN', 2), ('BLUE', 3)])
```

Хотя для создания перечислений можно использовать синтаксис [`class`](https://python-all.ru/3.16/reference/compound_stmts.html#class), перечисления не являются обычными классами Python. См. [Чем перечисления отличаются?](https://python-all.ru/3.16/howto/enum.html#enum-class-differences) для получения дополнительной информации.

> **Примечание**
>
> Терминология
>
> - Класс `Color` является *перечислением* (или *enum*)
> - Атрибуты `Color.RED`, `Color.GREEN` и т.д. являются *членами перечисления* (или *членами*) и по сути являются константами.
> - Члены перечисления имеют *имена* и *значения* (имя `Color.RED` – `RED`, значение `Color.BLUE` – `3` и т.д.)

---

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

> [`EnumType`](https://python-all.ru/3.16/library/enum.html#enum.EnumType)
>
> > `type` для Enum и его подклассов.
>
> [`Enum`](https://python-all.ru/3.16/library/enum.html#enum.Enum)
>
> > Базовый класс для создания перечисляемых констант.
>
> [`IntEnum`](https://python-all.ru/3.16/library/enum.html#enum.IntEnum)
>
> > Базовый класс для создания перечисляемых констант, которые также являются подклассами [`int`](https://python-all.ru/3.16/library/functions.html#int). ([Примечания](https://python-all.ru/3.16/library/enum.html#notes))
>
> [`StrEnum`](https://python-all.ru/3.16/library/enum.html#enum.StrEnum)
>
> > Базовый класс для создания перечисляемых констант, которые также являются подклассами [`str`](https://python-all.ru/3.16/library/stdtypes.html#str). ([Примечания](https://python-all.ru/3.16/library/enum.html#notes))
>
> [`Flag`](https://python-all.ru/3.16/library/enum.html#enum.Flag)
>
> > Базовый класс для создания перечисляемых констант, которые можно комбинировать с помощью побитовых операций без потери их принадлежности к [`Flag`](https://python-all.ru/3.16/library/enum.html#enum.Flag).
>
> [`IntFlag`](https://python-all.ru/3.16/library/enum.html#enum.IntFlag)
>
> > Базовый класс для создания перечисляемых констант, которые можно комбинировать с помощью побитовых операторов без потери их принадлежности к [`IntFlag`](https://python-all.ru/3.16/library/enum.html#enum.IntFlag). Члены `IntFlag` также являются подклассами [`int`](https://python-all.ru/3.16/library/functions.html#int). ([Примечания](https://python-all.ru/3.16/library/enum.html#notes))
>
> [`ReprEnum`](https://python-all.ru/3.16/library/enum.html#enum.ReprEnum)
>
> > Используется [`IntEnum`](https://python-all.ru/3.16/library/enum.html#enum.IntEnum), [`StrEnum`](https://python-all.ru/3.16/library/enum.html#enum.StrEnum) и [`IntFlag`](https://python-all.ru/3.16/library/enum.html#enum.IntFlag) для сохранения [`str()`](https://python-all.ru/3.16/library/stdtypes.html#str) примешиваемого типа.
>
> [`EnumCheck`](https://python-all.ru/3.16/library/enum.html#enum.EnumCheck)
>
> > Перечисление со значениями `CONTINUOUS`, `NAMED_FLAGS` и `UNIQUE`, для использования с [`verify()`](https://python-all.ru/3.16/library/enum.html#enum.verify), чтобы гарантировать соблюдение различных ограничений для заданного перечисления.
>
> [`FlagBoundary`](https://python-all.ru/3.16/library/enum.html#enum.FlagBoundary)
>
> > Перечисление со значениями `STRICT`, `CONFORM`, `EJECT` и `KEEP`, которое обеспечивает более детальный контроль над обработкой недопустимых значений в перечислении.
>
> [`EnumDict`](https://python-all.ru/3.16/library/enum.html#enum.EnumDict)
>
> > Подкласс [`dict`](https://python-all.ru/3.16/library/stdtypes.html#dict) для использования при создании подкласса [`EnumType`](https://python-all.ru/3.16/library/enum.html#enum.EnumType).
>
> [`auto`](https://python-all.ru/3.16/library/enum.html#enum.auto)
>
> > Экземпляры заменяются подходящим значением для членов Enum. [`StrEnum`](https://python-all.ru/3.16/library/enum.html#enum.StrEnum) по умолчанию принимает значение в нижнем регистре имени члена, в то время как другие перечисления по умолчанию начинаются с 1 и увеличиваются оттуда.
>
> [`@~enum.property`](https://python-all.ru/3.16/library/enum.html#enum.property)
>
> > Позволяет членам [`Enum`](https://python-all.ru/3.16/library/enum.html#enum.Enum) иметь атрибуты без конфликта с именами членов. Атрибуты `value` и `name` реализованы таким образом.
>
> [`@unique`](https://python-all.ru/3.16/library/enum.html#enum.unique)
>
> > Декоратор класса перечисления, который гарантирует, что каждому значению соответствует только одно имя.
>
> [`@verify`](https://python-all.ru/3.16/library/enum.html#enum.verify)
>
> > Декоратор класса перечисления, который проверяет выбираемые пользователем ограничения для перечисления.
>
> [`@member`](https://python-all.ru/3.16/library/enum.html#enum.member)
>
> > Превращает `obj` в член. Может использоваться как декоратор.
>
> [`@nonmember`](https://python-all.ru/3.16/library/enum.html#enum.nonmember)
>
> > Не превращает `obj` в член. Может использоваться как декоратор.
>
> [`@global_enum`](https://python-all.ru/3.16/library/enum.html#enum.global_enum)
>
> > Изменяет [`str()`](https://python-all.ru/3.16/library/stdtypes.html#str) и [`repr()`](https://python-all.ru/3.16/library/functions.html#repr) перечисления, чтобы его члены отображались как принадлежащие модулю, а не его классу, и экспортирует члены перечисления в глобальное пространство имён.
>
> [`show_flag_values()`](https://python-all.ru/3.16/library/enum.html#enum.show_flag_values)
>
> > Возвращает список всех целых чисел, являющихся степенями двойки, содержащихся во флаге.
>
> [`enum.bin()`](https://python-all.ru/3.16/library/enum.html#enum.bin)
>
> > Как встроенная [`bin()`](https://python-all.ru/3.16/library/functions.html#bin), за исключением того, что отрицательные значения представляются в dополнительном коде, и старший бит всегда указывает знак (`0` означает положительное, `1` – отрицательное).

Добавлено в версии 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* – это [метакласс](https://python-all.ru/3.16/glossary.html#term-metaclass) для перечислений *enum*. Есть возможность создать подкласс *EnumType* – подробнее см. в разделе [Subclassing EnumType](https://python-all.ru/3.16/howto/enum.html#enumtype-examples).

`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:**
  >
  > Имя нового создаваемого перечисления.
  >
  > **names:**
  >
  > Имена/значения членов нового перечисления.
  >
  > **модуль:**
  >
  > Имя модуля, в котором создаётся новое перечисление.
  >
  > **qualname:**
  >
  > Фактическое расположение в модуле, где можно найти это перечисление.
  >
  > **тип:**
  >
  > Примесный тип для нового перечисления.
  >
  > **start:**
  >
  > Первое целое значение для перечисления (используется функцией [`auto`](https://python-all.ru/3.16/library/enum.html#enum.auto)).
  >
  > **boundary:**
  >
  > Как обрабатывать значения, выходящие за пределы диапазона в битовых операциях (только для [`Flag`](https://python-all.ru/3.16/library/enum.html#enum.Flag)).

#### `__contains__(cls, member)`

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

```python
>>> 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*:

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

#### `__getitem__(cls, name)`

Возвращает член Enum из *cls*, соответствующий *name*, или вызывает [`KeyError`](https://python-all.ru/3.16/library/exceptions.html#KeyError):

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

#### `__iter__(cls)`

Возвращает каждый член из *cls* в порядке определения:

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

#### `__len__(cls)`

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

```python
>>> len(Color)
3
```

#### `__members__`

Возвращает отображение каждого имени enum на его член, включая псевдонимы

#### `__reversed__(cls)`

Возвращает каждый член из *cls* в обратном порядке определения:

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

#### `class enum.Enum`

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

#### `name`

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

```python
>>> Color.BLUE.name
'BLUE'
```

#### `value`

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

```python
>>> Color.RED.value
1
```

Значение члена; может быть задано в [`__new__()`](https://python-all.ru/3.16/library/enum.html#enum.Enum.__new__).

> **Примечание**
>
> Значения членов Enum
>
> Значения членов могут быть любыми: [`int`](https://python-all.ru/3.16/library/functions.html#int), [`str`](https://python-all.ru/3.16/library/stdtypes.html#str) и т. д. Если точное значение не важно, можно использовать экземпляры [`auto`](https://python-all.ru/3.16/library/enum.html#enum.auto), и подходящее значение будет выбрано автоматически. Подробнее см. `auto`.
>
> Хотя можно использовать изменяемые/нехешируемые значения, такие как [`dict`](https://python-all.ru/3.16/library/stdtypes.html#dict), [`list`](https://python-all.ru/3.16/library/stdtypes.html#list) или изменяемый [`dataclass`](https://python-all.ru/3.16/library/dataclasses.html#dataclasses.dataclass), они будут оказывать квадратичное влияние на производительность при создании по сравнению с общим количеством изменяемых/нехешируемых значений в перечислении.

#### `_name_`

Имя члена.

#### `_value_`

Значение члена; может быть задано в [`__new__()`](https://python-all.ru/3.16/library/enum.html#enum.Enum.__new__).

#### `_order_`

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

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

```python
>>> 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_` – это список имён, которые не станут членами, и их имена также будут удалены из готового перечисления. См. пример [TimePeriod](https://python-all.ru/3.16/howto/enum.html#enum-time-period).

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

#### `__dir__(self)`

Возвращает `['__class__', '__doc__', '__module__', 'name', 'value']` и все публичные методы, определённые в *self.\_\_class\_\_*:

```python
>>> 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__', '_add_alias_', '_add_value_alias_', '_generate_next_value_', '_missing_', 'name', 'today', 'value']
```

#### `_generate_next_value_(name, start, count, last_values)`

> **name:**
>
> Имя определяемого члена (например, 'RED').
>
> **start:**
>
> Начальное значение для Enum; по умолчанию 1.
>
> **count:**
>
> Количество уже определённых членов, не включая текущий.
>
> **last\_values:**
>
> Список предыдущих значений.

Метод *staticmethod*, используемый для определения следующего значения, возвращаемого [`auto`](https://python-all.ru/3.16/library/enum.html#enum.auto).

> **Примечание**
>
> Для стандартных классов `Enum` следующее выбираемое значение – это максимальное увиденное значение, увеличенное на единицу.
>
> Для классов [`Flag`](https://python-all.ru/3.16/library/enum.html#enum.Flag) следующее выбираемое значение будет следующей по величине степенью двойки.

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

```python
>>> 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__`; например:

```python
>>> 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*. По умолчанию он ничего не делает, но может быть переопределён для реализации собственного поиска:

```python
>>> 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`), все значения, заданные в определении члена, будут переданы; например:

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

приводит к вызову `int('1a', 16)` и значению `26` для члена.

> **Примечание**
>
> При написании пользовательского `__new__` не используйте `super().__new__` – вместо этого вызывайте соответствующий `__new__`.

#### `__repr__(self)`

Возвращает строку, используемую для вызовов *repr()*. По умолчанию возвращает имя *Enum*, имя элемента и значение, но может быть переопределено:

```python
>>> 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* и имя элемента, но может быть переопределено:

```python
>>> 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__()`](https://python-all.ru/3.16/library/enum.html#enum.Enum.__str__), но может быть переопределено:

```python
>>> 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`](https://python-all.ru/3.16/library/enum.html#enum.auto) с `Enum` даёт целые числа с возрастающим значением, начиная с `1`.

Изменено в версии 3.12: Добавлена [поддержка Dataclass](https://python-all.ru/3.16/howto/enum.html#enum-dataclass-support).

#### `_add_alias_()`

Добавляет новое имя как псевдоним существующего элемента:

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

Вызывает [`NameError`](https://python-all.ru/3.16/library/exceptions.html#NameError), если имя уже назначено другому элементу.

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

#### `_add_value_alias_()`

Добавляет новое значение как псевдоним существующего элемента:

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

Вызывает

[`ValueError`](https://python-all.ru/3.16/library/exceptions.html#ValueError)

, если значение уже связано с другим элементом.

Пример см. в

[MultiValueEnum](https://python-all.ru/3.16/howto/enum.html#multi-value-enum)

.

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

#### `class enum.IntEnum`

*IntEnum* – то же, что и [`Enum`](https://python-all.ru/3.16/library/enum.html#enum.Enum), но его элементы также являются целыми числами и могут использоваться везде, где можно использовать целое число. Если над элементом *IntEnum* выполняется какая-либо целочисленная операция, результирующее значение теряет статус перечисления.

```python
>>> 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`](https://python-all.ru/3.16/library/enum.html#enum.auto) с `IntEnum` даёт целые числа с возрастающим значением, начиная с `1`.

Изменено в версии 3.11: [`__str__()`](https://python-all.ru/3.16/reference/datamodel.html#object.__str__) теперь `int.__str__()`, чтобы лучше поддерживать вариант использования *замены существующих констант*. [`__format__()`](https://python-all.ru/3.16/reference/datamodel.html#object.__format__) уже был `int.__format__()` по той же причине.

#### `class enum.StrEnum`

*StrEnum* – то же, что и [`Enum`](https://python-all.ru/3.16/library/enum.html#enum.Enum), но его элементы также являются строками и могут использоваться почти везде, где можно использовать строку. Результат любой строковой операции, выполненной над элементом *StrEnum* или с его участием, не является частью перечисления.

```python
>>> 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`](https://python-all.ru/3.16/library/stdtypes.html#str), а не с подклассом `str` (например, `type(unknown) == str` вместо `isinstance(unknown, str)`), и в таких случаях потребуется использовать `str(MyStrEnum.MY_MEMBER)`.

> **Примечание**
>
> Использование [`auto`](https://python-all.ru/3.16/library/enum.html#enum.auto) с `StrEnum` даёт имя элемента в нижнем регистре в качестве значения.

> **Примечание**
>
> [`__str__()`](https://python-all.ru/3.16/reference/datamodel.html#object.__str__) – `str.__str__()`, чтобы лучше поддерживать вариант использования *замены существующих констант*. [`__format__()`](https://python-all.ru/3.16/reference/datamodel.html#object.__format__) также `str.__format__()` по той же причине.

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

#### `class enum.Flag`

`Flag` – то же, что и [`Enum`](https://python-all.ru/3.16/library/enum.html#enum.Enum), но его элементы поддерживают побитовые операторы `&` (*AND*), `|` (*OR*), `^` (*XOR*) и `~` (*INVERT*); результаты этих операций являются (псевдонимами) элементов перечисления.

#### `__contains__(self, value)`

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

```python
>>> 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)`

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

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

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

#### `__len__(self)`

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

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

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

#### `__bool__(self)`

Возвращает *True*, если в флаге есть хотя бы один элемент, иначе *False*:

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

#### `__or__(self, other)`

Возвращает текущий флаг, логически сложенный (OR) с другим:

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

#### `__and__(self, other)`

Возвращает текущий флаг, логически умноженный (AND) с другим:

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

#### `__xor__(self, other)`

Возвращает текущий флаг, логически сложенный по исключающему ИЛИ (XOR) с другим:

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

#### `__invert__(self)`

Возвращает все флаги из *type(self)*, которых нет в *self*:

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

#### `_numeric_repr_()`

Функция, используемая для форматирования оставшихся безымянных числовых значений. По умолчанию – repr значения; распространённые варианты: [`hex()`](https://python-all.ru/3.16/library/functions.html#hex) и [`oct()`](https://python-all.ru/3.16/library/functions.html#oct).

> **Примечание**
>
> Использование [`auto`](https://python-all.ru/3.16/library/enum.html#enum.auto) с `Flag` даёт целые числа, являющиеся степенями двойки, начиная с `1`.

Изменено в версии 3.11: Вывод *repr()* для флагов с нулевым значением изменился. Теперь он:

```python
>>> Color(0)
<Color: 0>
```

#### `class enum.IntFlag`

`IntFlag` – то же, что и [`Flag`](https://python-all.ru/3.16/library/enum.html#enum.Flag), но его члены также являются целыми числами и могут использоваться везде, где можно использовать целое число.

```python
>>> 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*:

```python
>>> Color.RED + 2
3
```

Если к члену *IntFlag* применяется операция [`Flag`](https://python-all.ru/3.16/library/enum.html#enum.Flag) и:

- результат является допустимым *IntFlag*: возвращается *IntFlag*
- результат не является допустимым *IntFlag*: результат зависит от настройки [`FlagBoundary`](https://python-all.ru/3.16/library/enum.html#enum.FlagBoundary)

[`repr()`](https://python-all.ru/3.16/library/functions.html#repr) безымянных флагов с нулевым значением изменилось. Теперь он:

```python
>>> Color(0)
<Color: 0>
```

> **Примечание**
>
> Использование [`auto`](https://python-all.ru/3.16/library/enum.html#enum.auto) с `IntFlag` даёт целые числа, являющиеся степенями двойки, начиная с `1`.

Изменено в версии 3.11: [`__str__()`](https://python-all.ru/3.16/reference/datamodel.html#object.__str__) теперь `int.__str__()` для лучшей поддержки сценария *замены существующих констант*. [`__format__()`](https://python-all.ru/3.16/reference/datamodel.html#object.__format__) уже было `int.__format__()` по той же причине.

Инверсия `IntFlag` теперь возвращает положительное значение – объединение всех флагов, не входящих в заданный флаг, вместо отрицательного значения. Это соответствует существующему поведению [`Flag`](https://python-all.ru/3.16/library/enum.html#enum.Flag).

#### `class enum.ReprEnum`

`ReprEnum` использует [`repr()`](https://python-all.ru/3.16/library/enum.html#enum.Enum.__repr__) от [`Enum`](https://python-all.ru/3.16/library/enum.html#enum.Enum), но [`str()`](https://python-all.ru/3.16/library/stdtypes.html#str) от примешиваемого типа данных:

- `int.__str__()` для [`IntEnum`](https://python-all.ru/3.16/library/enum.html#enum.IntEnum) и [`IntFlag`](https://python-all.ru/3.16/library/enum.html#enum.IntFlag)
- `str.__str__()` для [`StrEnum`](https://python-all.ru/3.16/library/enum.html#enum.StrEnum)

Наследуйте от `ReprEnum`, чтобы сохранить [`str()`](https://python-all.ru/3.16/library/stdtypes.html#str) / [`format()`](https://python-all.ru/3.16/library/functions.html#format) примешиваемого типа данных вместо использования [`Enum`](https://python-all.ru/3.16/library/enum.html#enum.Enum)-умолчания [`str()`](https://python-all.ru/3.16/library/enum.html#enum.Enum.__str__).

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

#### `class enum.EnumCheck`

*EnumCheck* содержит параметры, используемые декоратором [`verify()`](https://python-all.ru/3.16/library/enum.html#enum.verify) для проверки различных ограничений; нарушение ограничений приводит к [`ValueError`](https://python-all.ru/3.16/library/exceptions.html#ValueError).

#### `UNIQUE`

Гарантирует, что каждое значение имеет только одно имя:

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

Убедитесь, что между членом с наименьшим значением и членом с наибольшим значением нет пропущенных значений:

```python
>>> 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()`](https://python-all.ru/3.16/library/enum.html#enum.auto):

```python
>>> 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.12.

#### `class enum.FlagBoundary`

`FlagBoundary` определяет обработку значений, выходящих за пределы диапазона, в [`Flag`](https://python-all.ru/3.16/library/enum.html#enum.Flag) и его подклассах.

#### `STRICT`

Значения вне диапазона приводят к возбуждению [`ValueError`](https://python-all.ru/3.16/library/exceptions.html#ValueError). Это поведение по умолчанию для [`Flag`](https://python-all.ru/3.16/library/enum.html#enum.Flag):

```python
>>> 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`](https://python-all.ru/3.16/library/enum.html#enum.Flag):

```python
>>> 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`](https://python-all.ru/3.16/library/enum.html#enum.Flag) и возвращаются к [`int`](https://python-all.ru/3.16/library/functions.html#int).

```python
>>> 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`](https://python-all.ru/3.16/library/enum.html#enum.Flag) также сохраняется. Это поведение по умолчанию для [`IntFlag`](https://python-all.ru/3.16/library/enum.html#enum.IntFlag):

```python
>>> 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.12.

#### `class enum.EnumDict`

*EnumDict* является подклассом [`dict`](https://python-all.ru/3.16/library/stdtypes.html#dict), который используется в качестве пространства имен для определения классов перечислений (см. [Подготовка пространства имен класса](https://python-all.ru/3.16/reference/datamodel.html#prepare)). Он предоставляется для поддержки подклассов [`EnumType`](https://python-all.ru/3.16/library/enum.html#enum.EnumType) с расширенным поведением, например, с несколькими значениями на одного члена. Его следует вызывать с именем создаваемого класса перечисления, в противном случае частные имена и внутренние классы будут обрабатываться некорректно.

Обратите внимание, что переопределяется только интерфейс [`MutableMapping`](https://python-all.ru/3.16/library/collections.abc.html#collections.abc.MutableMapping) ([`__setitem__()`](https://python-all.ru/3.16/reference/datamodel.html#object.__setitem__) и [`update()`](https://python-all.ru/3.16/library/stdtypes.html#dict.update)). Возможно обойти проверки с помощью других операций `dict`, например [`|=`](https://python-all.ru/3.16/reference/datamodel.html#object.__ior__).

#### `member_names`

Список имен членов.

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

---

### Поддерживаемые `__dunder__` имена

[`__members__`](https://python-all.ru/3.16/library/enum.html#enum.EnumType.__members__) представляет собой упорядоченное отображение только для чтения элементов `member_name`:`member`. Оно доступно только на уровне класса.

[`__new__()`](https://python-all.ru/3.16/library/enum.html#enum.Enum.__new__), если указан, должен создавать и возвращать члены перечисления; также настоятельно рекомендуется соответствующим образом задать [`_value_`](https://python-all.ru/3.16/library/enum.html#enum.Enum._value_) элемента. После создания всех членов он больше не используется.

### Поддерживаемые `_sunder_` имена

- [`_name_`](https://python-all.ru/3.16/library/enum.html#enum.Enum._name_) – имя члена
- [`_value_`](https://python-all.ru/3.16/library/enum.html#enum.Enum._value_) – значение члена; может быть задано в `__new__`
- [`_missing_()`](https://python-all.ru/3.16/library/enum.html#enum.Enum._missing_) – функция поиска, используемая, когда значение не найдено; может быть переопределена
- [`_ignore_`](https://python-all.ru/3.16/library/enum.html#enum.Enum._ignore_) – список имен, представленный в виде [`list`](https://python-all.ru/3.16/library/stdtypes.html#list) или [`str`](https://python-all.ru/3.16/library/stdtypes.html#str), которые не будут преобразованы в члены и будут удалены из итогового класса
- [`_order_`](https://python-all.ru/3.16/library/enum.html#enum.Enum._order_) – больше не используется, сохранено для обратной совместимости (атрибут класса, удаляется при создании класса)
- [`_generate_next_value_()`](https://python-all.ru/3.16/library/enum.html#enum.Enum._generate_next_value_) – используется для получения подходящего значения для члена перечисления; может быть переопределен
- [`_add_alias_()`](https://python-all.ru/3.16/library/enum.html#enum.Enum._add_alias_) – добавляет новое имя как псевдоним для существующего члена.
- [`_add_value_alias_()`](https://python-all.ru/3.16/library/enum.html#enum.Enum._add_value_alias_) – добавляет новое значение как псевдоним для существующего члена.
- Хотя имена `_sunder_` обычно зарезервированы для дальнейшего развития класса [`Enum`](https://python-all.ru/3.16/library/enum.html#enum.Enum) и не могут использоваться, некоторые явно разрешены:

  - `_repr_*` (например, `_repr_html_`), как используется в [расширенном отображении IPython](https://python-all.ru/3.16/library/enum.html)

Добавлено в версии 3.6: `_missing_`, `_order_`, `_generate_next_value_`

Добавлено в версии 3.7: `_ignore_`

Добавлено в версии 3.13: `_add_alias_`, `_add_value_alias_`, `_repr_*`

---

## Утилиты и декораторы

#### `class enum.auto`

*auto* можно использовать вместо значения. При использовании механизм *Enum* вызовет [`Enum`](https://python-all.ru/3.16/library/enum.html#enum.Enum).[`_generate_next_value_()`](https://python-all.ru/3.16/library/enum.html#enum.Enum._generate_next_value_), чтобы получить подходящее значение. Для `Enum` и [`IntEnum`](https://python-all.ru/3.16/library/enum.html#enum.IntEnum) подходящим значением будет наибольшее из уже использованных плюс один; для [`Flag`](https://python-all.ru/3.16/library/enum.html#enum.Flag) и [`IntFlag`](https://python-all.ru/3.16/library/enum.html#enum.IntFlag) – первая степень двойки, превышающая наибольшее использованное значение; для [`StrEnum`](https://python-all.ru/3.16/library/enum.html#enum.StrEnum) – версия имени элемента в нижнем регистре. Следует соблюдать осторожность при смешивании *auto()* с явно указанными значениями.

Экземпляры *auto* разрешаются только на верхнем уровне присваивания, отдельно или как часть кортежа:

- `FIRST = auto()` будет работать (auto() заменяется на `1`);
- `SECOND = auto(), -2` будет работать (auto заменяется на `2`, поэтому `2, -2` используется для создания элемента перечисления `SECOND`;
- `THIRD = [auto(), -3]` *не* будет работать (`[<auto instance>, -3]` используется для создания элемента перечисления `THIRD`)

Изменено в версии 3.11.1: В предыдущих версиях `auto()` должен был быть единственным на строке присваивания, чтобы работать правильно.

`_generate_next_value_` можно переопределить, чтобы настроить значения, используемые *auto*.

> **Примечание**
>
> В версии 3.13 значение по умолчанию `_generate_next_value_` всегда будет возвращать наибольшее значение элемента, увеличенное на 1, и будет завершаться ошибкой, если какой-либо элемент имеет несовместимый тип.

#### `@enum.property`

Декоратор, похожий на встроенный [`@property`](https://python-all.ru/3.16/library/functions.html#property), но предназначенный специально для перечислений. Он позволяет атрибутам элементов иметь те же имена, что и сами элементы.

> **Примечание**
>
> Декоратор *property* и элемент должны быть определены в разных классах; например, атрибуты *value* и *name* определены в классе *Enum*, а подклассы *Enum* могут определять элементы с именами `value` и `name`.

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

#### `@enum.unique`

Декоратор [`class`](https://python-all.ru/3.16/reference/compound_stmts.html#class), специально предназначенный для перечислений. Он просматривает [`__members__`](https://python-all.ru/3.16/library/enum.html#enum.EnumType.__members__) перечисления, собирая все найденные псевдонимы; если какие-либо найдены, вызывается [`ValueError`](https://python-all.ru/3.16/library/exceptions.html#ValueError) с подробностями:

```python
>>> 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`](https://python-all.ru/3.16/reference/compound_stmts.html#class), специально предназначенный для перечислений. Элементы из [`EnumCheck`](https://python-all.ru/3.16/library/enum.html#enum.EnumCheck) используются для указания, какие ограничения должны проверяться в декорированном перечислении.

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

#### `@enum.member`

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

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

#### `@enum.nonmember`

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

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

#### `@enum.global_enum`

Декоратор, изменяющий [`str()`](https://python-all.ru/3.16/library/stdtypes.html#str) и [`repr()`](https://python-all.ru/3.16/library/functions.html#repr) перечисления, чтобы показывать его элементы как принадлежащие модулю, а не классу. Должен использоваться только когда элементы перечисления экспортируются в глобальное пространство имён модуля (см. пример [`re.RegexFlag`](https://python-all.ru/3.16/library/re.html#re.RegexFlag)).

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

#### `enum.show_flag_values(value)`

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

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

#### `enum.bin(num, max_bits=None)`

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

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

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

---

## Примечания

[`IntEnum`](https://python-all.ru/3.16/library/enum.html#enum.IntEnum), [`StrEnum`](https://python-all.ru/3.16/library/enum.html#enum.StrEnum) и [`IntFlag`](https://python-all.ru/3.16/library/enum.html#enum.IntFlag)

> Эти три типа перечислений предназначены для прямой замены существующих целочисленных и строковых значений; поэтому у них есть дополнительные ограничения:
>
> - `__str__` использует значение, а не имя элемента перечисления
> - `__format__`, поскольку он использует `__str__`, также будет использовать значение элемента перечисления, а не его имя
>
> Если эти ограничения не нужны или нежелательны, можно либо создать свой собственный базовый класс, смешав в нём типы `int` или `str`:
>
> ```python
> >>> from enum import Enum
> >>> class MyIntEnum(int, Enum):
> ...     pass
> ```
>
> или можно переназначить соответствующее [`str()`](https://python-all.ru/3.16/library/stdtypes.html#str) и т.д. в своём перечислении:
>
> ```python
> >>> from enum import Enum, IntEnum
> >>> class MyIntEnum(IntEnum):
> ...     __str__ = Enum.__str__
> ```