enum — Énumérations

Nouveau dans la version 3.4.

Code source : Lib/enum.py


Une énumération :

  • est un ensemble de noms symboliques (appelés membres) liés à des valeurs uniques,

  • can be iterated over to return its canonical (i.e. non-alias) members in definition order

  • utilise la syntaxe d'appel pour renvoyer les valeurs de ses membres,

  • utilise la syntaxe d'indiçage pour renvoyer les noms de ses membres.

Les énumérations sont créées soit en utilisant la syntaxe class, soit en utilisant la syntaxe d'appel de fonction :

>>> from enum import Enum

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

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

Même si on peut utiliser la syntaxe class pour créer des énumérations, les Enums ne sont pas des vraies classes Python. Lisez En quoi les énumérations sont-elles différentes ? pour plus de détails.

Note

Nomenclature

  • 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 is RED, the value of Color.BLUE is 3, etc.)


Contenu du module

EnumType

Le type d'Enum et de ses sous-classes.

Enum

Classe mère pour créer une énumération de constantes.

IntEnum

Classe mère pour créer une énumération de constantes qui sont également des sous-classes de int (notes).

StrEnum

Classe mère pour créer une énumération de constantes qui sont également des sous-classes de str (notes).

Flag

Classe mère pour créer une énumération de constantes pouvant être combinées avec des opérateurs de comparaison bit-à-bit, sans perdre leur qualité de Flag.

IntFlag

Classe mère pour créer une énumération de constantes pouvant être combinées avec des opérateurs de comparaison bit-à-bit, sans perdre leur qualité de IntFlag. Les membres de IntFlag sont aussi des sous-classes de int (notes).

ReprEnum

Used by IntEnum, StrEnum, and IntFlag to keep the str() of the mixed-in type.

EnumCheck

Énumération avec les valeurs CONTINUOUS, NAMED_FLAGS et UNIQUE, à utiliser avec verify() pour s'assurer que diverses contraintes sont satisfaites par une énumération donnée.

FlagBoundary

Énumération avec les valeurs STRICT, CONFORM, EJECT et KEEP qui permet un contrôle plus précis sur la façon dont les valeurs invalides sont traitées dans une énumération.

auto

Les instances sont remplacées par une valeur appropriée pour les membres de l'énumération. StrEnum utilise par défaut la version minuscule du nom du membre, tandis que les autres énumérations utilisent 1 par défaut et puis augmentent.

property()

Permet aux membres d'une Enum d'avoir des attributs sans entrer en conflit avec les noms des membres.

unique()

Décorateur de classe qui garantit qu'une valeur ne puisse être associée qu'à un seul nom.

verify()

Décorateur de classe qui vérifie des contraintes personnalisées pour une énumération.

member()

Fait de obj un membre. Peut être utilisé comme décorateur.

nonmember()

Fait que obj n'est pas un membre. Peut être utilisé comme décorateur.

global_enum()

Modify the str() and repr() of an enum to show its members as belonging to the module instead of its class. Should only be used if the enum members will be exported to the module global namespace.

show_flag_values()

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

Nouveau dans la version 3.6: Flag, IntFlag, auto

Nouveau dans la version 3.11: StrEnum, EnumCheck, ReprEnum, FlagBoundary, property, member, nonmember, global_enum, show_flag_values


Types de données

class enum.EnumType

EnumType est la métaclasse pour les énumérations. Il est possible de sous-classer EnumType ­— voir Sous-classer EnumType pour plus de détails.

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.

__contains__(cls, member)

Renvoie True si le membre appartient à cls :

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

Note

Dans Python 3.12, il sera possible de vérifier les valeurs des membres et pas seulement les membres ; en attendant, une TypeError est levée si un membre non-Enum est utilisé dans une vérification d'appartenance.

__dir__(cls)

Renvoie ['__class__', '__doc__', '__members__', '__module__'] et les noms des membres de cls :

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

Renvoie le membre de l'énumération cls correspondant à name ou lève une AttributeError :

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

Returns the Enum member in cls matching name, or raises a KeyError:

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

Renvoie chaque membre de cls dans l'ordre de définition :

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

Renvoie le nombre de membres de cls :

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

Renvoie chaque membre de cls dans l'ordre inverse de définition :

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

Enum est la classe mère de toutes les énumérations.

name

Le nom utilisé pour définir le membre de l'Enum :

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

La valeur attribuée au membre de l'Enum :

>>> Color.RED.value
1

Note

Valeurs des membres d'une Enum

Member values can be anything: int, str, etc. If the exact value is unimportant you may use auto instances and an appropriate value will be chosen for you. See auto for the details.

_ignore_

_ignore_ n'est utilisé que lors de la création et est supprimé de l'énumération une fois la création terminée.

_ignore_ est une liste de noms qui ne deviendront pas membres et qui seront également supprimés de l'énumération terminée. Voir Intervalle de temps pour un exemple.

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

Cette méthode peut être appelée de deux manières différentes :

  • pour chercher un membre existant :

    cls

    Classe de l'énumération concernée.

    value

    Valeur à chercher.

  • pour utiliser l'énumération cls afin de créer une nouvelle énumération :

    cls

    Classe de l'énumération concernée.

    value

    Nom de la nouvelle énumération à créer.

    names

    Couples nom-valeur des membres de la nouvelle énumération.

    module

    Nom du module dans lequel la classe Enum se trouve.

    qualname

    Position dans le module où la classe Enum se trouve.

    type

    Type à mélanger pour la nouvelle énumération.

    start

    The first integer value for the Enum (used by auto).

    boundary

    How to handle out-of-range values from bit operations (Flag only).

__dir__(self)

Renvoie ['__class__', '__doc__', '__module__', 'name', 'value'] et toutes les méthodes publiques définies pour 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

Nom du membre en cours de définition (par ex. RED).

start

Valeur de départ pour l'énumération ; 1 par défaut.

count

Nombre de membres actuellement définis, le membre actuel n'étant pas inclus.

last_values

Liste des valeurs précédentes.

Méthode statique utilisée pour déterminer la prochaine valeur à renvoyer par 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)

Méthode de classe utilisée pour personnaliser davantage les sous-classes à venir. Ne fait rien par défaut.

_missing_(cls, value)

Méthode de classe pour chercher des valeurs non trouvées dans cls. Ne fait rien par défaut mais peut être surchargée pour implémenter un comportement personnalisé de recherche :

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

Renvoie la chaîne utilisée pour les appels à repr(). Par défaut, renvoie le nom de l'énumération, le nom du membre et sa valeur, mais peut être surchargée :

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

Renvoie la chaîne utilisée pour les appels à str(). Par défaut, renvoie le nom Enum et le nom du membre, mais peut être remplacé :

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

Note

L'utilisation de auto avec Enum donne des nombres entiers de valeur croissante, en commençant par 1.

class enum.IntEnum

IntEnum est identique à Enum, mais ses membres sont également des entiers et peuvent être utilisés partout où un entier peut être utilisé. Si une opération sur un entier est effectuée avec un membre IntEnum, la valeur résultante perd son statut de membre d'énumération.

>>> from enum import IntEnum
>>> class Numbers(IntEnum):
...     ONE = 1
...     TWO = 2
...     THREE = 3
>>> Numbers.THREE
<Numbers.THREE: 3>
>>> Numbers.ONE + Numbers.TWO
3
>>> Numbers.THREE + 5
8
>>> Numbers.THREE == 3
True

Note

L'utilisation de auto avec IntEnum donne des entiers de valeur croissante, en commençant par 1.

Modifié dans la version 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 est identique à Enum, mais ses membres sont également des chaînes et peuvent être utilisés dans la plupart des endroits où une chaîne peut être utilisée. Le résultat de toute opération de chaîne effectuée sur ou avec un membre StrEnum ne fait pas partie de l'énumération.

Note

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

Note

L'utilisation de auto avec StrEnum donne le nom du membre en minuscule comme valeur.

Note

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

Nouveau dans la version 3.11.

class enum.Flag

Les membres Flag prennent en charge les opérateurs bit-à-bit & (ET), | (OU), ^ (OU EXCLUSIF) et ~ (NON) ; les résultats de ces opérations sont membres de l'énumération.

__contains__(self, value)

Renvoie True si la valeur est dans 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>]

Modifié dans la version 3.11: Aliases are no longer returned during iteration.

__len__(self):

Renvoie le nombre de membres de Flag :

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

Renvoie True s'il y a un membre dans les bits de Flag, False sinon :

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

Renvoie le OU logique entre le membre et other :

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

Renvoie le ET logique entre le membre et other :

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

Renvoie le OU Exclusif logique entre le membre et other :

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

Renvoie tous les membres de type(self) qui ne sont pas dans self (opération logique sur les bits) :

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

Fonction utilisée pour formater toutes les valeurs numériques sans nom restantes. La valeur par défaut est la représentation de la valeur ; les choix courants sont hex() et oct().

Note

L'utilisation de auto avec Flag donne des entiers qui sont des puissances de deux, en commençant par 1.

Modifié dans la version 3.11: La repr() des membres de valeur zéro a changé. C'est maintenant :

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

IntFlag est identique à Flag, mais ses membres sont également des entiers et peuvent être utilisés partout où un entier peut être utilisé.

>>> 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 une opération sur un entier est effectuée avec un membre d'un IntFlag, le résultat n'est pas un IntFlag :

>>> Color.RED + 2
3

Si une opération Flag est effectuée avec un membre IntFlag et :

  • le résultat est un IntFlag valide : un IntFlag est renvoyé ;

  • le résultat n'est pas un IntFlag valide : le résultat dépend du paramètre FlagBoundary.

La repr() des intflag sans nom à valeur nulle a changé. C'est maintenant :

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

Note

L'utilisation de auto avec IntFlag donne des entiers qui sont des puissances de deux, en commençant par 1.

Modifié dans la version 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().

Nouveau dans la version 3.11.

class enum.EnumCheck

EnumCheck contient les options utilisées par le décorateur verify() pour assurer diverses contraintes ; si une contrainte n'est pas validée, une ValueError est levée.

UNIQUE

Assure que chaque valeur n'a qu'un seul nom :

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

Assure qu'il n'y a pas de valeurs manquantes entre le membre ayant la valeur la plus faible et le membre ayant la valeur la plus élevée :

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

Note

CONTINUOUS et NAMED_FLAGS sont conçus pour fonctionner avec des membres à valeur entière.

Nouveau dans la version 3.11.

class enum.FlagBoundary

FlagBoundary contrôle la façon dont les valeurs hors plage sont gérées dans Flag et ses sous-classes.

STRICT

Les valeurs hors plage provoquent la levée d'une ValueError. C'est la valeur par défaut pour Flag :

>>> from enum import Flag, STRICT
>>> 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

Les valeurs hors plage, invalides, sont supprimées laissant une valeur Flag valide :

>>> from enum import Flag, CONFORM
>>> class ConformFlag(Flag, boundary=CONFORM):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
>>> ConformFlag(2**2 + 2**4)
<ConformFlag.BLUE: 4>
EJECT

Les valeurs hors plage perdent leur appartenance à Flag et reviennent à int. C'est la valeur par défaut pour IntFlag :

>>> from enum import Flag, EJECT
>>> class EjectFlag(Flag, boundary=EJECT):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
>>> EjectFlag(2**2 + 2**4)
20
KEEP

Les valeurs hors plage sont conservées et l'appartenance Flag est conservée. C'est utilisé pour certains drapeaux de la bibliothèque standard :

>>> from enum import Flag, KEEP
>>> class KeepFlag(Flag, boundary=KEEP):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
>>> KeepFlag(2**2 + 2**4)
<KeepFlag.BLUE|16: 20>

Nouveau dans la version 3.11.


Noms de la forme __dunder__ disponibles

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

Noms de la forme _sunder_ disponibles

  • _name_ — nom du membre

  • _value_ — valeur du membre ; il est possible d'y accéder et de la modifier dans __new__

  • _missing_ — fonction de recherche appelée quand la valeur n'est pas trouvée ; elle peut être redéfinie

  • _ignore_ — liste de noms, sous la forme d'une list() ou d'une str(), qui ne sont pas convertis en membres et sont supprimés de la classe résultante

  • _order_ — utilisée en Python 2 ou 3 pour s'assurer que l'ordre des membres est cohérent dans les différentes versions de Python (attribut de classe, supprimé durant la création de la classe)

  • _generate_next_value_ — utilisée pour obtenir une valeur appropriée à affecter à un membre de l’énumération ; elle peut être redéfinie

    Note

    Pour les classes standard Enum, la valeur suivante choisie est la dernière valeur vue incrémentée de un.

    Pour les classes Flag, la valeur suivante choisie est la puissance de deux la plus élevée suivante, quelle que soit la dernière valeur vue.

Nouveau dans la version 3.6: _missing_, _order_, _generate_next_value_

Nouveau dans la version 3.7: _ignore_


Utilitaires et décorateurs

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)

Modifié dans la version 3.11.1: In prior versions, auto() had to be the only thing on the assignment line to work properly.

_generate_next_value_ peut être surchargée pour personnaliser les valeurs produites par auto.

Note

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

Décorateur similaire au property natif, mais spécifique aux énumérations. Il permet aux attributs de membre d'avoir les mêmes noms que les membres eux-mêmes.

Note

property et le membre doivent être définis dans des classes distinctes ; par exemple, les attributs value et name sont définis dans la classe Enum, et les sous-classes d'Enum peuvent définir des membres avec les noms value et name.

Nouveau dans la version 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

Décorateur de classe spécifique aux énumérations. Utilisé pour spécifier quelles contraintes doivent être vérifiées par les membres de l'EnumCheck décorée.

Nouveau dans la version 3.11.

@enum.member

Décorateur à utiliser dans les énumérations : sa cible devient un membre.

Nouveau dans la version 3.11.

@enum.nonmember

Décorateur à utiliser dans les énumérations : sa cible ne devient pas un membre.

Nouveau dans la version 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).

Nouveau dans la version 3.11.

enum.show_flag_values(value)

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

Nouveau dans la version 3.11.


Notes

IntEnum, StrEnum et IntFlag

Ces trois types d'énumération sont conçus pour remplacer directement les valeurs existantes basées sur des entiers et des chaînes ; en tant que tels, ils ont des limitations supplémentaires :

  • __str__ utilise la valeur et pas le nom du membre de l'énumération

  • __format__, parce qu'elle fait appel à __str__, utilise également la valeur du membre de l'énumération au lieu de son nom

Si ces limitations ne vous conviennent pas, vous pouvez créer votre propre classe mère en mélangeant vous-même le type int ou str :

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

ou vous pouvez réassigner la str() appropriée, etc., dans votre énumération :

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