enum
— Soporte para enumeraciones¶
Nuevo en la versión 3.4.
Código fuente: Lib/enum.py
Una enumeración:
es un conjunto de nombres simbólicos (miembros) vinculados a valores únicos
can be iterated over to return its canonical (i.e. non-alias) members in definition order
usa la sintaxis call para retornar miembros por valor
usa la sintaxis index para retornar miembros por nombre
Las enumeraciones se crean mediante la sintaxis class
o mediante la sintaxis de llamadas a funciones:
>>> from enum import Enum
>>> # class syntax
>>> class Color(Enum):
... RED = 1
... GREEN = 2
... BLUE = 3
>>> # functional syntax
>>> Color = Enum('Color', ['RED', 'GREEN', 'BLUE'])
Aunque podemos usar la sintaxis class
para crear enumeraciones, las enumeraciones no son clases normales de Python. Ver ¿En qué se diferencian las enumeraciones? para más detalles.
Nota
Nomenclatura
The class
Color
is an enumeration (or enum)The attributes
Color.RED
,Color.GREEN
, etc., are enumeration members (or members) and are functionally constants.The enum members have names and values (the name of
Color.RED
isRED
, the value ofColor.BLUE
is3
, etc.)
Contenido del Módulo¶
El
type
para Enum y sus subclases.Clase base para crear constantes enumeradas.
Clase base para crear constantes enumeradas que se pueden combinar utilizando las operaciones bitwise sin perder su membresía
Flag
.Una enumeración con los valores
CONTINUOUS
,NAMED_FLAGS
yUNIQUE
, para usar converify()
para garantizar que una enumeración determinada cumpla varias restricciones.Una enumeración con los valores
STRICT
,CONFORM
,EJECT
yKEEP
que permite un control más detallado sobre cómo se tratan los valores no válidos en una enumeración.Las instancias se reemplazan con un valor apropiado para los miembros de Enum.
StrEnum
usa de manera predeterminada la versión en minúsculas del nombre del miembro, mientras que otras enumeraciones tienen el valor predeterminado de 1 y aumentan a partir de ahí.Allows
Enum
members to have attributes without conflicting with member names. Thevalue
andname
attributes are implemented this way.El decorador de clase Enum que garantiza que solo un nombre esté vinculado a cualquier valor.
Decorador de clase Enum que verifica las restricciones seleccionables por el usuario en una enumeración.
Convierta a
obj
en miembro. Se puede utilizar como decorador.No convierta a
obj
en miembro. Se puede utilizar como decorador.Retorna una lista de todos los enteros de potencia de dos contenidos en una bandera.
Nuevo en la versión 3.6: Flag
, IntFlag
, auto
Nuevo en la versión 3.11: StrEnum
, EnumCheck
, ReprEnum
, FlagBoundary
, property
, member
, nonmember
, global_enum
, show_flag_values
Tipos de datos¶
- class enum.EnumType¶
EnumType es el metaclass para enumeraciones enum. Es posible subclasificar EnumType; consulte Subclassing EnumType para obtener más detalles.
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 se llama de dos maneras diferentes:
para buscar un miembro existente:
- cls:
La clase de enumeración que se llama.
- value:
El valor a buscar.
to use the
cls
enum to create a new enum (only if the existing enum does not have any members):- cls:
La clase de enumeración que se llama.
- value:
El nombre del nuevo Enum para crear.
- names:
Los nombres/valores de los miembros para el nuevo Enum.
- module:
El nombre del módulo en el que se crea el nuevo Enum.
- qualname:
La ubicación real en el módulo donde se puede encontrar este Enum.
- type:
Un tipo de mezcla para el nuevo Enum.
- start:
The first integer value for the Enum (used by
auto
).- boundary:
How to handle out-of-range values from bit operations (
Flag
only).
- __contains__(cls, member)¶
Retorna
True
si el miembro pertenece acls
:>>> some_var = Color.RED >>> some_var in Color True >>> Color.RED.value in Color True
Distinto en la versión 3.12: Before Python 3.12, a
TypeError
is raised if a non-Enum-member is used in a containment check.- __dir__(cls)¶
Retorna
['__class__', '__doc__', '__members__', '__module__']
y los nombres de los miembros en cls:>>> dir(Color) ['BLUE', 'GREEN', 'RED', '__class__', '__contains__', '__doc__', '__getitem__', '__init_subclass__', '__iter__', '__len__', '__members__', '__module__', '__name__', '__qualname__']
- __getitem__(cls, name)¶
Returns the Enum member in cls matching name, or raises a
KeyError
:>>> Color['BLUE'] <Color.BLUE: 3>
- __iter__(cls)¶
Retorna cada miembro en cls en orden de definición:
>>> list(Color) [<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>]
- __len__(cls)¶
Retorna el número de miembro en cls:
>>> len(Color) 3
- __reversed__(cls)¶
Retorna cada miembro en cls en orden de definición inverso:
>>> list(reversed(Color)) [<Color.BLUE: 3>, <Color.GREEN: 2>, <Color.RED: 1>]
Nuevo en la versión 3.11: Before 3.11
enum
usedEnumMeta
type, which is kept as an alias.
- class enum.Enum¶
Enum es la clase base para todas las enumeraciones enum.
- name¶
El nombre utilizado para definir el miembro
Enum
:>>> Color.BLUE.name 'BLUE'
- value¶
El valor dado al miembro
Enum
:>>> Color.RED.value 1
- _ignore_¶
_ignore_
solo se usa durante la creación y se elimina de la enumeración una vez que se completa la creación._ignore_
es una lista de nombres que no se convertirán en miembros y cuyos nombres también se eliminarán de la enumeración completa. Consulte TimePeriod para ver un ejemplo.
- __dir__(self)¶
Retorna
['__class__', '__doc__', '__module__', 'name', 'value']
y cualquier método público definido en 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)¶
- name:
El nombre del miembro que se está definiendo (por ejemplo, “RED”).
- start:
El valor inicial de Enum; el valor predeterminado es 1.
- count:
El número de miembros actualmente definidos, sin incluir este.
- last_values:
Una lista de los valores anteriores.
Un staticmethod que se usa para determinar el siguiente 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)¶
Un classmethod que se usa para configurar más subclases subsiguientes. Por defecto, no hace nada.
- _missing_(cls, value)¶
Un classmethod para buscar valores que no se encuentran en cls. De forma predeterminada, no hace nada, pero se puede anular para implementar un comportamiento de búsqueda 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)¶
Retorna la cadena utilizada para las llamadas repr(). De forma predeterminada, retorna el nombre Enum, el nombre del miembro y el valor, pero se puede anular:
>>> 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)¶
Retorna la cadena utilizada para las llamadas str(). De forma predeterminada, retorna el nombre Enum y el nombre del miembro, pero se puede anular:
>>> 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
El uso de
auto
conEnum
da como resultado números enteros de valor creciente, comenzando con1
.Distinto en la versión 3.12: Added Soporte de Dataclass
- 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
El uso de
auto
conIntEnum
da como resultado números enteros de valor creciente, comenzando con1
.Distinto en la versión 3.11:
__str__()
is nowint.__str__()
to better support the replacement of existing constants use-case.__format__()
was alreadyint.__format__()
for that same reason.
- class enum.StrEnum¶
StrEnum
is the same asEnum
, 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
Hay lugares en stdlib que buscan un
str
exacto en lugar de una subclasestr
(es decir,type(unknown) == str
en lugar deisinstance(unknown, str)
), y en esos lugares necesitará usarstr(StrEnum.member)
.Nota
__str__()
isstr.__str__()
to better support the replacement of existing constants use-case.__format__()
is likewisestr.__format__()
for that same reason.Nuevo en la versión 3.11.
- class enum.Flag¶
Los miembros Flag admiten los operadores bit a bit
&
(AND),|
(OR),^
(XOR) y~
(INVERT); los resultados de esos operadores son miembros de la enumeración.- __contains__(self, value)¶
Retorna True si el valor está en sí mismo:
>>> 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>]
Distinto en la versión 3.11: Aliases are no longer returned during iteration.
- __len__(self):
Retorna el número de miembros en la bandera:
>>> len(Color.GREEN) 1 >>> len(white) 3
- __bool__(self):
Retorna True si hay algún miembro en la bandera, False de lo contrario:
>>> bool(Color.GREEN) True >>> bool(white) True >>> black = Color(0) >>> bool(black) False
- __or__(self, other)¶
Retorna la bandera actual binaria o con otra:
>>> Color.RED | Color.GREEN <Color.RED|GREEN: 3>
- __and__(self, other)¶
Retorna el binario de la bandera actual y se combina con otro:
>>> purple & white <Color.RED|BLUE: 5> >>> purple & Color.GREEN <Color: 0>
- __xor__(self, other)¶
Retorna la bandera actual binaria xor’ed con otra:
>>> purple ^ white <Color.GREEN: 2> >>> purple ^ Color.GREEN <Color.RED|GREEN|BLUE: 7>
- __invert__(self):
Retorna todas las banderas en type(self) que no están en uno mismo:
>>> ~white <Color: 0> >>> ~purple <Color.GREEN: 2> >>> ~Color.RED <Color.GREEN|BLUE: 6>
- _numeric_repr_()¶
Función utilizada para dar formato a los valores numéricos restantes sin nombre. El valor predeterminado es la repr del valor; las opciones comunes son
hex()
yoct()
.
Nota
El uso de
auto
conFlag
da como resultado números enteros que son potencias de dos, comenzando con1
.Distinto en la versión 3.11: El repr() de las banderas de valor cero ha cambiado. Esto es ahora:
>>> Color(0) <Color: 0>
- class enum.IntFlag¶
IntFlag
is the same asFlag
, 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>
Si se realiza alguna operación con enteros con un miembro IntFlag, el resultado no es un IntFlag:
>>> Color.RED + 2 3
If a
Flag
operation is performed with an IntFlag member and:el resultado es un IntFlag válido: se retorna un IntFlag
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
El uso de
auto
conIntFlag
da como resultado números enteros que son potencias de dos, comenzando con1
.Distinto en la versión 3.11:
__str__()
is nowint.__str__()
to better support the replacement of existing constants use-case.__format__()
was alreadyint.__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 existingFlag
behavior.
- class enum.ReprEnum¶
ReprEnum
uses therepr()
ofEnum
, but thestr()
of the mixed-in data type:Inherit from
ReprEnum
to keep thestr()
/format()
of the mixed-in data type instead of using theEnum
-defaultstr()
.Nuevo en la versión 3.11.
- class enum.EnumCheck¶
EnumCheck contiene las opciones utilizadas por el decorador
verify()
para garantizar diversas restricciones; las restricciones fallidas dan como resultado unValueError
.- UNIQUE¶
Asegúrese de que cada valor tenga un solo nombre:
>>> 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¶
Asegúrese de que no falten valores entre el miembro de menor valor y el miembro de mayor valor:
>>> 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 y NAMED_FLAGS están diseñados para funcionar con miembros con valores enteros.
Nuevo en la versión 3.11.
- class enum.FlagBoundary¶
FlagBoundary
controls how out-of-range values are handled inFlag
and its subclasses.- STRICT¶
Out-of-range values cause a
ValueError
to be raised. This is the default forFlag
:>>> 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>
Nuevo en la versión 3.11.
Nombres soportados __dunder__
¶
__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.
Nombres _sunder_
compatibles¶
_name_
— nombre del miembro_value_
— valor del miembro; se puede definir / modificar en__new__
_missing_
— una función de búsqueda utilizada cuando no se encuentra un valor; puede ser anulado_ignore_
– una lista de nombres, ya sea como unalist()
o unastr()
que no será transformada en miembros, y que se eliminará de la clase final_order_
— usado en código Python 2/3 para asegurar que el orden de los miembros sea consistente (atributo de clase, eliminado durante la creación de la clase)_generate_next_value_
: se usa para obtener un valor apropiado para un miembro de enumeración; puede ser anulado
Nuevo en la versión 3.6: _missing_
, _order_
, _generate_next_value_
Nuevo en la versión 3.7: _ignore_
Utilidades y decoradores¶
- 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. ForEnum
andIntEnum
that appropriate value will be the last value plus one; forFlag
andIntFlag
it will be the first power-of-two greater than the highest value; forStrEnum
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 with1
);SECOND = auto(), -2
will work (auto is replaced with2
, so2, -2
isused to create the
SECOND
enum member;
THREE = [auto(), -3]
will not work (<auto instance>, -3
is used to create theTHREE
enum member)
Distinto en la versión 3.11.1: In prior versions,
auto()
had to be the only thing on the assignment line to work properly._generate_next_value_
se puede anular para personalizar los valores utilizados por 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¶
Un decorador similar al property integrado, pero específico para enumeraciones. Permite que los atributos de los miembros tengan los mismos nombres que los propios miembros.
Nota
el property y el miembro deben definirse en clases separadas; por ejemplo, los atributos value y name se definen en la clase Enum y las subclases Enum pueden definir miembros con los nombres
value
yname
.Nuevo en la versión 3.11.
- @enum.unique¶
A
class
decorator specifically for enumerations. It searches an enumeration’s__members__
, gathering any aliases it finds; if any are foundValueError
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¶
Un decorador
class
específicamente para enumeraciones. Los miembros deEnumCheck
se utilizan para especificar qué restricciones deben verificarse en la enumeración decorada.Nuevo en la versión 3.11.
- @enum.member¶
Un decorador para usar en enumeraciones: su objetivo se convertirá en miembro.
Nuevo en la versión 3.11.
- @enum.nonmember¶
Un decorador para usar en enumeraciones: su destino no se convertirá en miembro.
Nuevo en la versión 3.11.
- @enum.global_enum¶
Un decorador para cambiar el
str()
yrepr()
de una enumeración para mostrar sus miembros como pertenecientes al módulo en lugar de a su clase. Solo debe usarse cuando los miembros de la enumeración se exportan al espacio de nombres global del módulo (consultere.RegexFlag
para ver un ejemplo).Nuevo en la versión 3.11.
- enum.show_flag_values(value)¶
Retorna una lista de todos los enteros de potencia de dos contenidos en un indicador value.
Nuevo en la versión 3.11.
Notas¶
Estos tres tipos de enumeración están diseñados para ser reemplazos directos de los valores existentes basados en cadenas y enteros; como tales, tienen limitaciones adicionales:
__str__
usa el valor y no el nombre del miembro de enumeración
__format__
, debido a que usa__str__
, también usará el valor del miembro de enumeración en lugar de su nombreSi no necesita/quiere esas limitaciones, puede crear su propia clase base mezclando el tipo
int
ostr
usted mismo:>>> from enum import Enum >>> class MyIntEnum(int, Enum): ... passo puede reasignar el
str()
apropiado, etc., en su enumeración:>>> from enum import Enum, IntEnum >>> class MyIntEnum(IntEnum): ... __str__ = Enum.__str__