enum — Suporte a enumerações

Novo na versão 3.4.

Código-fonte: Lib/enum.py

Uma enumeração:

  • é um conjunto de nomes simbólicos (membros) vinculados a valores únicos

  • pode ser iterado para retornar seus membros canônicos (ou seja, não incluindo apelidos) na ordem de definição

  • usa a sintaxe call para retornar membros por valor

  • usa a sintaxe index para retornar membros por nome

As enumerações são criadas usando a sintaxe de class ou usando a sintaxe de chamada de função:

>>> from enum import Enum

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

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

Embora possamos usar a sintaxe class para criar Enums, Enums não são classes Python normais. Veja Como Enums são diferentes? para mais detalhes.

Nota

Nomenclatura

  • A classe Color é uma enumeração (ou enum)

  • Os atributos Color.RED, Color.GREEN, etc., são membros de enumeração (ou membros) e são constantes funcionalmente.

  • Os membros enum têm nomes e valores (o nome de Color.RED é RED, o valor de Color.BLUE é 3, etc.)

Conteúdo do módulo

EnumType

O type para Enum e suas subclasses.

Enum

Classe base para criação de constantes enumeradas.

IntEnum

Classe base para criar constantes enumeradas que também são subclasses de int. (Notas)

StrEnum

Classe base para criar constantes enumeradas que também são subclasses de str. (Notas)

Flag

Classe base para criar constantes enumeradas que podem ser combinadas usando operações bit a bit sem perder sua associação Flag.

IntFlag

Classe base para criar constantes enumeradas que podem ser combinadas usando operadores bit a bit sem perder sua associação IntFlag. Membros de IntFlag também são subclasses de int. (Notas)

ReprEnum

Usado por IntEnum, StrEnum e IntFlag para manter o str() do tipo misto.

EnumCheck

Uma enumeração com os valores CONTINUOUS, NAMED_FLAGS e UNIQUE, para uso com verify() para garantir que várias restrições sejam atendidas por uma determinada enumeração.

FlagBoundary

Uma enumeração com os valores STRICT, CONFORM, EJECT e KEEP que permite um controle mais refinado sobre como valores inválidos são tratados em uma enumeração.

auto

As instâncias são substituídas por um valor apropriado para membros Enum. StrEnum assume como padrão a versão em minúsculas do nome do membro, enquanto outros Enums assumem como padrão 1 e aumentam a partir daí.

property()

Allows Enum members to have attributes without conflicting with member names.

unique()

Decorador de classe Enum que garante que apenas um nome seja vinculado a cada valor.

verify()

Decorador de classe Enum que verifica restrições selecionáveis pelo usuário em uma enumeração.

member()

Torna obj um membro. Pode ser usado como um decorador.

nonmember()

Não torna obj um membro. Pode ser usado como um decorador.

global_enum()

Modifica str() e repr() de uma enumeração para mostrar seus membros como pertencentes ao módulo em vez de sua classe, e exporta os membros da enumeração para o espaço de nomes global.

show_flag_values()

Retorna uma lista de todos os inteiros de potência de dois contidos em um sinalizador.

Novo na versão 3.6: Flag, IntFlag, auto

Novo na versão 3.11: StrEnum, EnumCheck, ReprEnum, FlagBoundary, property, member, nonmember, global_enum, show_flag_values

Tipos de Dados

class enum.EnumType

EnumType é a metaclasse para enumerações enum. É possível criar subclasse de EnumType – veja Criando subclasses de EnumType para detalhes.

EnumType is responsible for setting the correct __repr__(), __str__(), __format__(), and __reduce__() methods on the final enum, as well as creating the enum members, properly handling duplicates, providing iteration over the enum class, etc.

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

Este método é chamado de formas diferentes:

  • para procurar um membro existente:

    cls:

    A classe enum sendo chamada.

    valor:

    O valor para procurar.

  • para usar a enumeração cls para criar uma nova enumeração (somente se a enumeração existente não tiver nenhum membro):

    cls:

    A classe enum sendo chamada.

    valor:

    O nome do novo Enum para criar.

    nomes:

    Os nomes/valores dos membros para o novo Enum.

    módulo:

    O nome do módulo no qual o novo Enum é criado.

    qualname:

    O local real no módulo onde este Enum pode ser encontrado.

    tipo:

    Um tipo de mix-in para o novo Enum.

    start:

    O primeiro valor inteiro para o Enum (usado por auto).

    boundary:

    Como lidar com valores fora do intervalo de operações de bits (somente Flag).

__contains__(cls, member)

Retorna True se o membro pertencer a cls:

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

Nota

In Python 3.12 it will be possible to check for member values and not just members; until then, a TypeError will be raised if a non-Enum-member is used in a containment check.

__dir__(cls)

Retorna ['__class__', '__doc__', '__members__', '__module__'] e os nomes dos membros em cls:

>>> dir(Color)
['BLUE', 'GREEN', 'RED', '__class__', '__contains__', '__doc__', '__getitem__', '__init_subclass__', '__iter__', '__len__', '__members__', '__module__', '__name__', '__qualname__']
__getattr__(cls, name)

Returns the Enum member in cls matching name, or raises an AttributeError:

>>> Color.GREEN
<Color.GREEN: 2>
__getitem__(cls, name)

Retorna o membro Enum em cls correspondente a name ou levanta KeyError:

>>> Color['BLUE']
<Color.BLUE: 3>
__iter__(cls)

Retorna cada membro em cls na ordem de definição:

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

Retorna o número de membros em cls:

>>> len(Color)
3
__reversed__(cls)

Retorna cada membro em cls na ordem inversa de definição:

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

Novo na versão 3.11: Before 3.11 enum used EnumMeta type, which is kept as an alias.

class enum.Enum

Enum é a classe base para todas as enumerações enum.

name

O nome usado para definir o membro Enum:

>>> Color.BLUE.name
'BLUE'
value

O valor dado ao membro Enum:

>>> Color.RED.value
1

Value of the member, can be set in __new__().

Nota

Valores de membros de Enum

Os valores dos membros podem ser qualquer coisa: int, str, etc. Se o valor exato não for importante, você pode usar instâncias de auto e um valor apropriado será escolhido para você. Consulte auto para obter detalhes.

Embora valores mutáveis/não hasheáveis, como dict, list ou um mutável dataclass, possam ser usados, eles terão um impacto quadrático no desempenho durante a criação em relação ao número total de valores mutáveis/não hasheáveis na enumeração.

_name_

Nome do membro.

_value_

Value of the member, can be set in __new__().

_order_

Não é mais usado, mantido para compatibilidade com versões anteriores. (atributo de classe, removido durante a criação da classe).

_ignore_

_ignore_ é usado somente durante a criação e é removido da enumeração quando a criação é concluída.

_ignore_ é uma lista de nomes que não se tornarão membros e cujos nomes também serão removidos da enumeração concluída. Veja TimePeriod para um exemplo.

__dir__(self)

Retorna ['__class__', '__doc__', '__module__', 'name', 'value'] e quaisquer métodos públicos definidos em 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)
nome:

O nome do membro que está sendo definido (por exemplo, ‘RED’).

start:

O valor inicial do Enum; o padrão é 1.

count:

O número de membros atualmente definido, sem incluir este.

last_values:

Uma lista de valores anteriores.

Um staticmethod que é usado para determinar o próximo valor retornado por 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_subclass__(cls, **kwds)

Um classmethod usado para configurar subclasses subsequentes. Por padrão, não faz nada.

_missing_(cls, value)

Um classmethod para procurar valores não encontrados em cls. Por padrão, ele não faz nada, mas pode ser substituído para implementar um comportamento de pesquisa personalizado:

>>> 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'>
__repr__(self)

Returns the string used for repr() calls. By default, returns the Enum name, member name, and value, but can be overridden:

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

Returns the string used for str() calls. By default, returns the Enum name and member name, but can be overridden:

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

Returns the string used for format() and f-string calls. By default, returns __str__() return value, but can be overridden:

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

Nota

Using auto with Enum results in integers of increasing value, starting with 1.

class enum.IntEnum

IntEnum is the same as Enum, but its members are also integers and can be used anywhere that an integer can be used. If any integer operation is performed with an IntEnum member, the resulting value loses its enumeration status.

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

Nota

Using auto with IntEnum results in integers of increasing value, starting with 1.

Alterado na versão 3.11: __str__() is now int.__str__() to better support the replacement of existing constants use-case. __format__() was already int.__format__() for that same reason.

class enum.StrEnum

StrEnum is the same as Enum, but its members are also strings and can be used in most of the same places that a string can be used. The result of any string operation performed on or with a StrEnum member is not part of the enumeration.

Nota

There are places in the stdlib that check for an exact str instead of a str subclass (i.e. type(unknown) == str instead of isinstance(unknown, str)), and in those locations you will need to use str(StrEnum.member).

Nota

Using auto with StrEnum results in the lower-cased member name as the value.

Nota

__str__() is str.__str__() to better support the replacement of existing constants use-case. __format__() is likewise str.__format__() for that same reason.

Novo na versão 3.11.

class enum.Flag

Flag members support the bitwise operators & (AND), | (OR), ^ (XOR), and ~ (INVERT); the results of those operators are members of the enumeration.

__contains__(self, value)

Returns True if value is in 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):

Returns all contained non-alias members:

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

Novo na versão 3.11.

__len__(self):

Returns number of members in flag:

>>> len(Color.GREEN)
1
>>> len(white)
3
__bool__(self):

Returns True if any members in flag, False otherwise:

>>> bool(Color.GREEN)
True
>>> bool(white)
True
>>> black = Color(0)
>>> bool(black)
False
__or__(self, other)

Returns current flag binary or’ed with other:

>>> Color.RED | Color.GREEN
<Color.RED|GREEN: 3>
__and__(self, other)

Returns current flag binary and’ed with other:

>>> purple & white
<Color.RED|BLUE: 5>
>>> purple & Color.GREEN
<Color: 0>
__xor__(self, other)

Returns current flag binary xor’ed with other:

>>> purple ^ white
<Color.GREEN: 2>
>>> purple ^ Color.GREEN
<Color.RED|GREEN|BLUE: 7>
__invert__(self):

Returns all the flags in type(self) that are not in self:

>>> ~white
<Color: 0>
>>> ~purple
<Color.GREEN: 2>
>>> ~Color.RED
<Color.GREEN|BLUE: 6>
_numeric_repr_()

Function used to format any remaining unnamed numeric values. Default is the value’s repr; common choices are hex() and oct().

Nota

Using auto with Flag results in integers that are powers of two, starting with 1.

Alterado na versão 3.11: The repr() of zero-valued flags has changed. It is now::

>>> Color(0) 
<Color: 0>
class enum.IntFlag

IntFlag is the same as Flag, but its members are also integers and can be used anywhere that an integer can be used.

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

If any integer operation is performed with an IntFlag member, the result is not an IntFlag:

>>> Color.RED + 2
3

If a Flag operation is performed with an IntFlag member and:

  • the result is a valid IntFlag: an IntFlag is returned

  • the result is not a valid IntFlag: the result depends on the FlagBoundary setting

The repr() of unnamed zero-valued flags has changed. It is now:

>>> Color(0)
<Color: 0>

Nota

Using auto with IntFlag results in integers that are powers of two, starting with 1.

Alterado na versão 3.11: __str__() is now int.__str__() to better support the replacement of existing constants use-case. __format__() was already int.__format__() for that same reason.

Inversion of an IntFlag now returns a positive value that is the union of all flags not in the given flag, rather than a negative value. This matches the existing Flag behavior.

class enum.ReprEnum

ReprEnum uses the repr() of Enum, but the str() of the mixed-in data type:

Inherit from ReprEnum to keep the str() / format() of the mixed-in data type instead of using the Enum-default str().

Novo na versão 3.11.

class enum.EnumCheck

EnumCheck contains the options used by the verify() decorator to ensure various constraints; failed constraints result in a ValueError.

UNIQUE

Ensure that each value has only one name:

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

Ensure that there are no missing values between the lowest-valued member and the highest-valued member:

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

Ensure that any flag groups/masks contain only named flags – useful when values are specified instead of being generated by 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]

Nota

CONTINUOUS and NAMED_FLAGS are designed to work with integer-valued members.

Novo na versão 3.11.

class enum.FlagBoundary

FlagBoundary controls how out-of-range values are handled in Flag and its subclasses.

STRICT

Out-of-range values cause a ValueError to be raised. This is the default for 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

Out-of-range values have invalid values removed, leaving a valid Flag value:

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

Out-of-range values lose their Flag membership and revert to 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

Out-of-range values are kept, and the Flag membership is kept. This is the default for 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>

Novo na versão 3.11.

Nomes __dunder__ suportados

__members__ is a read-only ordered mapping of member_name:member items. It is only available on the class.

__new__(), if specified, must create and return the enum members; it is also a very good idea to set the member’s _value_ appropriately. Once all the members are created it is no longer used.

Nomes _sunder_ suportados

  • _name_ – name of the member

  • _value_ – value of the member; can be set in __new__

  • _missing_() – a lookup function used when a value is not found; may be overridden

  • _ignore_ – a list of names, either as a list or a str, that will not be transformed into members, and will be removed from the final class

  • _order_ – no longer used, kept for backward compatibility (class attribute, removed during class creation)

  • _generate_next_value_() – used to get an appropriate value for an enum member; may be overridden

    Nota

    Para classes Enum padrão, o próximo valor escolhido é o último valor visto incrementado em um.

    Para as classes Flag o próximo valor escolhido será a próxima potência de dois mais alta, independentemente do último valor visto.

Novo na versão 3.6: _missing_, _order_, _generate_next_value_

Novo na versão 3.7: _ignore_

Utilities and Decorators

class enum.auto

auto can be used in place of a value. If used, the Enum machinery will call an Enum’s _generate_next_value_() to get an appropriate value. For Enum and IntEnum that appropriate value will be the last value plus one; for Flag and IntFlag it will be the first power-of-two greater than the highest value; for StrEnum it will be the lower-cased version of the member’s name. Care must be taken if mixing auto() with manually specified values.

auto instances are only resolved when at the top level of an assignment:

  • FIRST = auto() will work (auto() is replaced with 1);

  • SECOND = auto(), -2 will work (auto is replaced with 2, so 2, -2 is used to create the SECOND enum member;

  • THREE = [auto(), -3] will not work (<auto instance>, -3 is used to create the THREE enum member)

Alterado na versão 3.11.1: In prior versions, auto() had to be the only thing on the assignment line to work properly.

_generate_next_value_ can be overridden to customize the values used by auto.

Nota

in 3.13 the default _generate_next_value_ will always return the highest member value incremented by 1, and will fail if any member is an incompatible type.

@enum.property

A decorator similar to the built-in property, but specifically for enumerations. It allows member attributes to have the same names as members themselves.

Nota

the property and the member must be defined in separate classes; for example, the value and name attributes are defined in the Enum class, and Enum subclasses can define members with the names value and name.

Novo na versão 3.11.

@enum.unique

A class decorator specifically for enumerations. It searches an enumeration’s __members__, gathering any aliases it finds; if any are found ValueError is raised with the details:

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

A class decorator specifically for enumerations. Members from EnumCheck are used to specify which constraints should be checked on the decorated enumeration.

Novo na versão 3.11.

@enum.member

A decorator for use in enums: its target will become a member.

Novo na versão 3.11.

@enum.nonmember

A decorator for use in enums: its target will not become a member.

Novo na versão 3.11.

@enum.global_enum

A decorator to change the str() and repr() of an enum to show its members as belonging to the module instead of its class. Should only be used when the enum members are exported to the module global namespace (see re.RegexFlag for an example).

Novo na versão 3.11.

enum.show_flag_values(value)

Return a list of all power-of-two integers contained in a flag value.

Novo na versão 3.11.

Notas

IntEnum, StrEnum, and IntFlag

These three enum types are designed to be drop-in replacements for existing integer- and string-based values; as such, they have extra limitations:

  • __str__ uses the value and not the name of the enum member

  • __format__, because it uses __str__, will also use the value of the enum member instead of its name

If you do not need/want those limitations, you can either create your own base class by mixing in the int or str type yourself:

>>> from enum import Enum
>>> class MyIntEnum(int, Enum):
...     pass

or you can reassign the appropriate str(), etc., in your enum:

>>> from enum import Enum, IntEnum
>>> class MyIntEnum(IntEnum):
...     __str__ = Enum.__str__