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

---

# 8.13. [`enum`](https://python-all.ru/3.5/library/enum.html#module-enum) – Поддержка перечислений

Новое в версии 3.4.

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

---

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

## 8.13.1. Содержание модуля

Этот модуль определяет два класса перечислений, которые можно использовать для определения уникальных\\nнаборов имен и значений: [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) и [`IntEnum`](https://python-all.ru/3.5/library/enum.html#enum.IntEnum). Он также определяет\\nодин декоратор, [`unique()`](https://python-all.ru/3.5/library/enum.html#enum.unique).

#### `class enum.Enum`

Базовый класс для создания перечислимых констант. См. раздел [Функциональный API](https://python-all.ru/3.5/library/enum.html#functional-api) для альтернативного синтаксиса создания.

#### `class enum.IntEnum`

Базовый класс для создания перечислимых констант, которые также являются подклассами [`int`](https://python-all.ru/3.5/library/functions.html#int).

#### `enum.unique()`

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

## 8.13.2. Создание Enum

Перечисления создаются с использованием синтаксиса [`class`](https://python-all.ru/3.5/reference/compound_stmts.html#class), что делает их легко читаемыми и удобными для записи. Альтернативный метод создания описан в [Функциональный API](https://python-all.ru/3.5/library/enum.html#functional-api). Чтобы определить перечисление, создайте подкласс [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) следующим образом:

```python
>>> from enum import Enum
>>> class Color(Enum):
...     red = 1
...     green = 2
...     blue = 3
...
```

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

> **Примечание**
>
> Хотя для создания перечислений мы используем синтаксис [`class`](https://python-all.ru/3.5/reference/compound_stmts.html#class), перечисления не являются обычными классами Python. Подробнее см. [Чем отличаются перечисления?](https://python-all.ru/3.5/library/enum.html#how-are-enums-different).

Члены перечисления имеют удобочитаемые строковые представления:

```python
>>> print(Color.red)
Color.red
```

…в то время как их `repr` содержит больше информации:

```python
>>> print(repr(Color.red))
<Color.red: 1>
```

*Тип* члена перечисления – это перечисление, к которому он принадлежит:

```python
>>> type(Color.red)
<enum 'Color'>
>>> isinstance(Color.green, Color)
True
>>>
```

Члены перечисления также имеют свойство, содержащее только их имя:

```python
>>> print(Color.red.name)
red
```

Перечисления поддерживают итерацию в порядке определения:

```python
>>> class Shake(Enum):
...     vanilla = 7
...     chocolate = 4
...     cookies = 9
...     mint = 3
...
>>> for shake in Shake:
...     print(shake)
...
Shake.vanilla
Shake.chocolate
Shake.cookies
Shake.mint
```

Члены перечисления хешируемы, поэтому их можно использовать в словарях и множествах:

```python
>>> apples = {}
>>> apples[Color.red] = 'red delicious'
>>> apples[Color.green] = 'granny smith'
>>> apples == {Color.red: 'red delicious', Color.green: 'granny smith'}
True
```

## 8.13.3. Программный доступ к членам перечисления и их атрибутам

Иногда бывает полезно обращаться к членам перечисления программно (например, в ситуациях, когда `Color.red` не подходит, поскольку точный цвет неизвестен на момент написания программы). `Enum` предоставляет такой доступ:

```python
>>> Color(1)
<Color.red: 1>
>>> Color(3)
<Color.blue: 3>
```

Если требуется обратиться к членам перечисления по *имени*, используйте доступ по ключу:

```python
>>> Color['red']
<Color.red: 1>
>>> Color['green']
<Color.green: 2>
```

Если есть член перечисления и требуется его `name` или `value`:

```python
>>> member = Color.red
>>> member.name
'red'
>>> member.value
1
```

## 8.13.4. Дублирование членов enum и значений

Наличие двух членов перечисления с одинаковым именем недопустимо:

```python
>>> class Shape(Enum):
...     square = 2
...     square = 3
...
Traceback (most recent call last):
...
TypeError: Attempted to reuse key: 'square'
```

Однако двум членам перечисления разрешено иметь одинаковое значение. Если два члена A и B имеют одинаковое значение (и A определён первым), то B является псевдонимом A. Поиск по значению A и B вернёт A. Поиск по имени B также вернёт A:

```python
>>> class Shape(Enum):
...     square = 2
...     diamond = 1
...     circle = 3
...     alias_for_square = 2
...
>>> Shape.square
<Shape.square: 2>
>>> Shape.alias_for_square
<Shape.square: 2>
>>> Shape(2)
<Shape.square: 2>
```

> **Примечание**
>
> Попытка создать член с тем же именем, что и уже определённый атрибут (другой член, метод и т.д.), или попытка создать атрибут с тем же именем, что и член, не допускается.

## 8.13.5. Обеспечение уникальности значений перечисления

По умолчанию перечисления допускают несколько имён в качестве псевдонимов для одного и того же значения. Если такое поведение нежелательно, можно использовать следующий декоратор, чтобы гарантировать, что каждое значение используется в перечислении только один раз:

#### `@enum.unique`

Декоратор [`class`](https://python-all.ru/3.5/reference/compound_stmts.html#class), предназначенный специально для перечислений. Он просматривает `__members__` перечисления, собирая все найденные псевдонимы; если таковые обнаружены, возбуждается [`ValueError`](https://python-all.ru/3.5/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
```

## 8.13.6. Итерация

Перебор членов перечисления не включает псевдонимы:

```python
>>> list(Shape)
[<Shape.square: 2>, <Shape.diamond: 1>, <Shape.circle: 3>]
```

Специальный атрибут `__members__` – это упорядоченный словарь, сопоставляющий имена с элементами. Он включает все имена, определённые в перечислении, включая псевдонимы:

```python
>>> for name, member in Shape.__members__.items():
...     name, member
...
('square', <Shape.square: 2>)
('diamond', <Shape.diamond: 1>)
('circle', <Shape.circle: 3>)
('alias_for_square', <Shape.square: 2>)
```

Атрибут `__members__` можно использовать для детального программного доступа к членам перечисления. Например, для поиска всех псевдонимов:

```python
>>> [name for name, member in Shape.__members__.items() if member.name != name]
['alias_for_square']
```

## 8.13.7. Сравнения

Члены перечисления сравниваются по идентичности:

```python
>>> Color.red is Color.red
True
>>> Color.red is Color.blue
False
>>> Color.red is not Color.blue
True
```

Упорядоченные сравнения между значениями перечисления *не* поддерживаются. Члены перечисления – не целые числа (но см. [IntEnum](https://python-all.ru/3.5/library/enum.html#intenum) ниже):

```python
>>> Color.red < Color.blue
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: Color() < Color()
```

Однако сравнения на равенство определены:

```python
>>> Color.blue == Color.red
False
>>> Color.blue != Color.red
True
>>> Color.blue == Color.blue
True
```

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

```python
>>> Color.blue == 2
False
```

## 8.13.8. Допустимые члены и атрибуты перечислений

В примерах выше для значений перечислений используются целые числа. Использование целых чисел – это кратко и удобно (и предусмотрено по умолчанию [функциональным API](https://python-all.ru/3.5/library/enum.html#functional-api)), но не является строгим требованием. В подавляющем большинстве случаев не важно, каково фактическое значение элемента перечисления. Но если значение *является* важным, перечисления могут иметь произвольные значения.

Перечисления – это классы Python и могут иметь обычные методы и специальные методы. Если есть такое перечисление:

```python
>>> class Mood(Enum):
...     funky = 1
...     happy = 3
...
...     def describe(self):
...         # self – это член перечисления
...         return self.name, self.value
...
...     def __str__(self):
...         return 'my custom str! {0}'.format(self.value)
...
...     @classmethod
...     def favorite_mood(cls):
...         # cls здесь – это перечисление
...         return cls.happy
...
```

Тогда:

```python
>>> Mood.favorite_mood()
<Mood.happy: 3>
>>> Mood.happy.describe()
('happy', 3)
>>> str(Mood.funky)
'my custom str! 1'
```

Правила допустимости следующие: имена, начинающиеся и заканчивающиеся одним подчеркиванием, зарезервированы для перечисления и не могут использоваться; все остальные атрибуты, определенные в перечислении, становятся его членами, за исключением специальных методов ([`__str__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__str__), [`__add__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__add__) и т. д.) и дескрипторов (методы также являются дескрипторами).

Примечание: если в перечислении определены [`__new__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__new__) и/или [`__init__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__init__), то все значения, переданные элементу перечисления, будут переданы в эти методы. В качестве примера см. [Planet](https://python-all.ru/3.5/library/enum.html#planet).

## 8.13.9. Ограниченное наследование перечислений

Создание подкласса перечисления разрешено только в том случае, если перечисление не определяет никаких членов. Так делать запрещено:

```python
>>> class MoreColor(Color):
...     pink = 17
...
Traceback (most recent call last):
...
TypeError: Cannot extend enumerations
```

Но это разрешено:

```python
>>> class Foo(Enum):
...     def some_behavior(self):
...         pass
...
>>> class Bar(Foo):
...     happy = 1
...     sad = 2
...
```

Разрешение создания подклассов перечислений, определяющих члены, привело бы к нарушению некоторых важных инвариантов типов и экземпляров. С другой стороны, имеет смысл разрешить общее поведение для группы перечислений. (Пример см. в [OrderedEnum](https://python-all.ru/3.5/library/enum.html#orderedenum).)

## 8.13.10. Сериализация

Перечисления могут быть упакованы и распакованы с помощью модуля pickle.

```python
>>> from test.test_enum import Fruit
>>> from pickle import dumps, loads
>>> Fruit.tomato is loads(dumps(Fruit.tomato))
True
```

Обычные ограничения для упаковки с помощью модуля pickle применяются: перечисления, которые можно упаковать, должны быть определены на верхнем уровне модуля, так как для распаковки их нужно импортировать из этого модуля.

> **Примечание**
>
> С протоколом pickle версии 4 можно легко упаковывать перечисления, вложенные в другие классы.

Можно изменить способ сериализации/десериализации членов Enum, определив [`__reduce_ex__()`](https://python-all.ru/3.5/library/pickle.html#object.__reduce_ex__) в классе перечисления.

## 8.13.11. Функциональный API

Класс [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) является вызываемым и предоставляет следующее функциональное API:

```python
>>> Animal = Enum('Animal', 'ant bee cat dog')
>>> Animal
<enum 'Animal'>
>>> Animal.ant
<Animal.ant: 1>
>>> Animal.ant.value
1
>>> list(Animal)
[<Animal.ant: 1>, <Animal.bee: 2>, <Animal.cat: 3>, <Animal.dog: 4>]
```

Семантика этого API напоминает [`namedtuple`](https://python-all.ru/3.5/library/collections.html#collections.namedtuple). Первый аргумент вызова [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) – это имя перечисления.

Второй аргумент – это *источник* имён членов перечисления. Это может быть строка имён, разделённых пробелами, последовательность имён, последовательность двухэлементных кортежей с парами ключ/значение или отображение (например, словарь) имён на значения. Последние два варианта позволяют присваивать произвольные значения перечислениям; остальные автоматически присваивают увеличивающиеся целые числа, начиная с 1 (используйте параметр `start` для указания другого начального значения). Возвращается новый класс, производный от [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum). Другими словами, приведённое выше присваивание `Animal` эквивалентно:

```python
>>> class Animal(Enum):
...     ant = 1
...     bee = 2
...     cat = 3
...     dog = 4
...
```

Причина, по которой по умолчанию используется `1`, а не `0`, заключается в том, что `0` равно `False` с точки зрения булевой логики, но все члены перечисления вычисляются в `True`.

Сериализация перечислений, созданных с помощью функционального API, может быть сложной, поскольку для определения модуля, в котором создаётся перечисление, используются детали реализации стека вызовов (например, это не сработает, если использовать вспомогательную функцию в отдельном модуле, а также может не работать в IronPython или Jython). Решение – явно указать имя модуля следующим образом:

```python
>>> Animal = Enum('Animal', 'ant bee cat dog', module=__name__)
```

> **Предупреждение**
>
> Если `module` не указан, и Enum не может его определить, новые члены Enum не будут поддерживать распаковку; чтобы ошибки были ближе к источнику, pickling будет отключён.

Новый протокол pickle 4 также в некоторых обстоятельствах полагается на то, что [`__qualname__`](https://python-all.ru/3.5/library/stdtypes.html#definition.__qualname__) установлен в расположение, где pickle сможет найти класс. Например, если класс стал доступен в классе SomeData в глобальной области видимости:

```python
>>> Animal = Enum('Animal', 'ant bee cat dog', qualname='SomeData.Animal')
```

Полная сигнатура:

```python
Enum(value='NewEnumName', names=<...>, *, module='...', qualname='...', type=<mixed-in class>, start=1)
```

| value: | Что новый класс Enum запишет в качестве своего имени. |
| --- | --- |
| names: | Члены перечисления. Это может быть строка, разделённая пробелами или запятыми (значения будут начинаться с 1, если не указано иное): 'red green blue' \| 'red,green,blue' \| 'red, green, blue' или итератор имён: \['red', 'green', 'blue'\] или итератор пар (имя, значение): \[('cyan', 4), ('magenta', 5), ('yellow', 6)\] или отображение: {'chartreuse': 7, 'sea\_green': 11, 'rosemary': 42} |
| module: | имя модуля, в котором находится новый класс Enum. |
| qualname: | где в модуле находится новый класс Enum. |
| type: | тип, который следует примешать к новому классу Enum. |
| start: | число, с которого начинать отсчёт, если переданы только имена. |

Изменено в версии 3.5: Добавлен параметр *start*.

## 8.13.12. Производные перечисления

### 8.13.12.1. IntEnum

Предоставляется вариант [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum), который также является подклассом\\n[`int`](https://python-all.ru/3.5/library/functions.html#int). Члены [`IntEnum`](https://python-all.ru/3.5/library/enum.html#enum.IntEnum) можно сравнивать с целыми числами;\\nпо аналогии, целочисленные перечисления разных типов также можно сравнивать\\nдруг с другом:

```python
>>> from enum import IntEnum
>>> class Shape(IntEnum):
...     circle = 1
...     square = 2
...
>>> class Request(IntEnum):
...     post = 1
...     get = 2
...
>>> Shape == 1
False
>>> Shape.circle == 1
True
>>> Shape.circle == Request.post
True
```

Однако их по-прежнему нельзя сравнивать со стандартными перечислениями [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum):

```python
>>> class Shape(IntEnum):
...     circle = 1
...     square = 2
...
>>> class Color(Enum):
...     red = 1
...     green = 2
...
>>> Shape.circle == Color.red
False
```

Значения [`IntEnum`](https://python-all.ru/3.5/library/enum.html#enum.IntEnum) ведут себя как целые числа и в других ожидаемых аспектах:

```python
>>> int(Shape.circle)
1
>>> ['a', 'b', 'c'][Shape.circle]
'b'
>>> [i for i in range(Shape.square)]
[0, 1]
```

Для подавляющего большинства кода настоятельно рекомендуется [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum),\\nпоскольку [`IntEnum`](https://python-all.ru/3.5/library/enum.html#enum.IntEnum) нарушает некоторые семантические обещания перечисления (из-за\\nвозможности сравнения с целыми числами и, соответственно, транзитивного сравнения с другими\\nне связанными перечислениями). Его следует использовать только в особых случаях, когда\\nнет другого выбора; например, когда целочисленные константы\\nзаменяются перечислениями и требуется обратная совместимость с кодом,\\nкоторый всё ещё ожидает целые числа.

### 8.13.12.2. Другие

Хотя [`IntEnum`](https://python-all.ru/3.5/library/enum.html#enum.IntEnum) является частью модуля [`enum`](https://python-all.ru/3.5/library/enum.html#module-enum), его очень просто реализовать самостоятельно:

```python
class IntEnum(int, Enum):
    pass
```

Это показывает, как можно определить подобные производные перечисления; например, `StrEnum`, в который примешивается [`str`](https://python-all.ru/3.5/library/stdtypes.html#str) вместо [`int`](https://python-all.ru/3.5/library/functions.html#int).

Некоторые правила:

1. При создании подкласса [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) типы-примеси должны располагаться перед самим [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) в последовательности базовых классов, как в [`IntEnum`](https://python-all.ru/3.5/library/enum.html#enum.IntEnum) примере выше.
2. Хотя [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) может содержать элементы любого типа, как только к нему примешивается дополнительный тип, все элементы должны иметь значения этого типа, например [`int`](https://python-all.ru/3.5/library/functions.html#int) выше. Это ограничение не распространяется на примеси, которые только добавляют методы и не указывают другой тип данных, такие как [`int`](https://python-all.ru/3.5/library/functions.html#int) или [`str`](https://python-all.ru/3.5/library/stdtypes.html#str).
3. При примешивании другого типа данных атрибут `value` *отличается* от самого члена перечисления, хотя он эквивалентен и будет равным при сравнении.
4. Форматирование в стиле %: *%s* и *%r* вызывают методы [`__str__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__str__) и [`__repr__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__repr__) класса [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) соответственно; другие коды (например, *%i* или *%h* для IntEnum) обрабатывают член перечисления как его примешанный тип.
5. [`str.format()`](https://python-all.ru/3.5/library/stdtypes.html#str.format) (или [`format()`](https://python-all.ru/3.5/library/functions.html#format)) будет использовать [`__format__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__format__)\\nпримешанного типа. Если требуется [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) класса [`str()`](https://python-all.ru/3.5/library/stdtypes.html#str) или [`repr()`](https://python-all.ru/3.5/library/functions.html#repr), используйте коды форматирования *!s* или *!r*.

## 8.13.13. Интересные примеры

Хотя ожидается, что [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) и [`IntEnum`](https://python-all.ru/3.5/library/enum.html#enum.IntEnum) покрывают большинство\\nвариантов использования, они не могут покрыть их все. Здесь приведены рецепты для некоторых различных\\nтипов перечислений, которые можно использовать напрямую или как примеры для создания\\nсобственных.

### 8.13.13.1. AutoNumber

Позволяет избежать необходимости указывать значение для каждого члена перечисления:

```python
>>> class AutoNumber(Enum):
...     def __new__(cls):
...         value = len(cls.__members__) + 1
...         obj = object.__new__(cls)
...         obj._value_ = value
...         return obj
...
>>> class Color(AutoNumber):
...     red = ()
...     green = ()
...     blue = ()
...
>>> Color.green.value == 2
True
```

> **Примечание**
>
> Метод [`__new__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__new__), если он определён, используется во время создания членов Enum; затем он заменяется методом [`__new__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__new__) класса Enum, который используется после создания класса для поиска существующих членов.

### 8.13.13.2. OrderedEnum

Упорядоченное перечисление, которое не основано на [`IntEnum`](https://python-all.ru/3.5/library/enum.html#enum.IntEnum) и поэтому сохраняет обычные инварианты [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) (например, несравнимость с другими перечислениями):

```python
>>> class OrderedEnum(Enum):
...     def __ge__(self, other):
...         if self.__class__ is other.__class__:
...             return self.value >= other.value
...         return NotImplemented
...     def __gt__(self, other):
...         if self.__class__ is other.__class__:
...             return self.value > other.value
...         return NotImplemented
...     def __le__(self, other):
...         if self.__class__ is other.__class__:
...             return self.value <= other.value
...         return NotImplemented
...     def __lt__(self, other):
...         if self.__class__ is other.__class__:
...             return self.value < other.value
...         return NotImplemented
...
>>> class Grade(OrderedEnum):
...     A = 5
...     B = 4
...     C = 3
...     D = 2
...     F = 1
...
>>> Grade.C < Grade.A
True
```

### 8.13.13.3. DuplicateFreeEnum

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

```python
>>> class DuplicateFreeEnum(Enum):
...     def __init__(self, *args):
...         cls = self.__class__
...         if any(self.value == e.value for e in cls):
...             a = self.name
...             e = cls(self.value).name
...             raise ValueError(
...                 "aliases not allowed in DuplicateFreeEnum:  %r --> %r"
...                 % (a, e))
...
>>> class Color(DuplicateFreeEnum):
...     red = 1
...     green = 2
...     blue = 3
...     grene = 2
...
Traceback (most recent call last):
...
ValueError: aliases not allowed in DuplicateFreeEnum:  'grene' --> 'green'
```

> **Примечание**
>
> Это полезный пример подкласса Enum для добавления или изменения другого поведения, а также запрета псевдонимов. Если требуется только запрет псевдонимов, вместо этого можно использовать декоратор [`unique()`](https://python-all.ru/3.5/library/enum.html#enum.unique).

### 8.13.13.4. Planet

Если определены [`__new__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__new__) или [`__init__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__init__), значение члена перечисления будет передано этим методам:

```python
>>> class Planet(Enum):
...     MERCURY = (3.303e+23, 2.4397e6)
...     VENUS   = (4.869e+24, 6.0518e6)
...     EARTH   = (5.976e+24, 6.37814e6)
...     MARS    = (6.421e+23, 3.3972e6)
...     JUPITER = (1.9e+27,   7.1492e7)
...     SATURN  = (5.688e+26, 6.0268e7)
...     URANUS  = (8.686e+25, 2.5559e7)
...     NEPTUNE = (1.024e+26, 2.4746e7)
...     def __init__(self, mass, radius):
...         self.mass = mass       # в килограммах
...         self.radius = radius   # в метрах
...     @property
...     def surface_gravity(self):
...         # гравитационная постоянная (м3 кг-1 с-2)
...         G = 6.67300E-11
...         return G * self.mass / (self.radius * self.radius)
...
>>> Planet.EARTH.value
(5.976e+24, 6378140.0)
>>> Planet.EARTH.surface_gravity
9.802652743337129
```

## 8.13.14. Чем отличаются перечисления?

Перечисления имеют собственный метакласс, который влияет на многие аспекты как производных классов Enum, так и их экземпляров (членов).

### 8.13.14.1. Классы перечислений

Мета-класс `EnumMeta` отвечает за предоставление [`__contains__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__contains__), [`__dir__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__dir__), [`__iter__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__iter__) и других методов, которые позволяют выполнять с классом [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) действия, которые на обычном классе не сработают, например *list(Color)* или *some\_var in Color*. `EnumMeta` отвечает за обеспечение того, чтобы различные другие методы итогового класса [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) были корректны (таких как [`__new__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__new__), [`__getnewargs__()`](https://python-all.ru/3.5/library/pickle.html#object.__getnewargs__), [`__str__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__str__) и [`__repr__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__repr__)).

### 8.13.14.2. Члены перечисления (экземпляры)

Самое интересное в членах Enum – это то, что они являются синглтонами. `EnumMeta` создаёт их все при создании самого класса [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum), а затем помещает на место настраиваемый [`__new__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__new__), чтобы гарантировать, что новые экземпляры никогда не будут созданы, возвращая только существующие экземпляры членов.

### 8.13.14.3. Тонкости

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

```python
>>> class FieldTypes(Enum):
...     name = 0
...     value = 1
...     size = 2
...
>>> FieldTypes.value.size
<FieldTypes.size: 2>
>>> FieldTypes.size.value
2
```

Изменено в версии 3.5.

Атрибут `__members__` доступен только для класса.

Если добавить подклассу [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) дополнительные методы, как в классе [Planet](https://python-all.ru/3.5/library/enum.html#planet) выше, эти методы будут видны в [`dir()`](https://python-all.ru/3.5/library/functions.html#dir) члена, но не класса:

```python
>>> dir(Planet)
['EARTH', 'JUPITER', 'MARS', 'MERCURY', 'NEPTUNE', 'SATURN', 'URANUS', 'VENUS', '__class__', '__doc__', '__members__', '__module__']
>>> dir(Planet.EARTH)
['__class__', '__doc__', '__module__', 'name', 'surface_gravity', 'value']
```

Метод [`__new__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__new__) будет использоваться только для создания [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) членов – после этого он заменяется. Любой пользовательский метод [`__new__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__new__) должен создать объект и установить атрибут `_value_` соответствующим образом.

Если требуется изменить способ поиска членов [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum), следует либо написать вспомогательную функцию или создать [`classmethod()`](https://python-all.ru/3.5/library/functions.html#classmethod) для [`Enum`](https://python-all.ru/3.5/library/enum.html#enum.Enum) подкласса.