enum
--- Support for enumerations¶
Ajouté 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', 1), ('GREEN', 2), ('BLUE', 3)])
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
isRED
, the value ofColor.BLUE
is3
, etc.)
Contenu du module¶
Le
type
d'Enum et de ses sous-classes.Classe mère pour créer une énumération de constantes.
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
.Énumération avec les valeurs
CONTINUOUS
,NAMED_FLAGS
etUNIQUE
, à utiliser avecverify()
pour s'assurer que diverses contraintes sont satisfaites par une énumération donnée.Énumération avec les valeurs
STRICT
,CONFORM
,EJECT
etKEEP
qui permet un contrôle plus précis sur la façon dont les valeurs invalides sont traitées dans une énumération.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.Allows
Enum
members to have attributes without conflicting with member names. Thevalue
andname
attributes are implemented this way.Décorateur de classe qui garantit qu'une valeur ne puisse être associée qu'à un seul nom.
Décorateur de classe qui vérifie des contraintes personnalisées pour une énumération.
Fait de
obj
un membre. Peut être utilisé comme décorateur.Fait que
obj
n'est pas un membre. Peut être utilisé comme décorateur.Return a list of all power-of-two integers contained in a flag.
Ajouté dans la version 3.6: Flag
, IntFlag
, auto
Ajouté 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.- __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.
to use the
cls
enum to create a new enum (only if the existing enum does not have any members):- 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).
- __contains__(cls, member)¶
Renvoie
True
si le membre appartient àcls
:>>> some_var = Color.RED >>> some_var in Color True >>> Color.RED.value in Color True
Modifié dans la version 3.12: Before Python 3.12, a
TypeError
is raised if a non-Enum-member is used in a containment check.- __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__']
- __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
- __members__¶
Returns a mapping of every enum name to its member, including aliases
- __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>]
- _add_alias_()¶
Adds a new name as an alias to an existing member. Raises a
NameError
if the name is already assigned to a different member.
- _add_value_alias_()¶
Adds a new value as an alias to an existing member. Raises a
ValueError
if the value is already linked with a different member.
Ajouté dans la version 3.11: Before 3.11
EnumType
was calledEnumMeta
, which is still available as an alias.
- 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
Value of the member, can be set in
__new__()
.Note
Valeurs des membres d'une Enum
Member values can be anything:
int
,str
, etc. If the exact value is unimportant you may useauto
instances and an appropriate value will be chosen for you. Seeauto
for the details.While mutable/unhashable values, such as
dict
,list
or a mutabledataclass
, can be used, they will have a quadratic performance impact during creation relative to the total number of mutable/unhashable values in the enum.
- _name_¶
Name of the member.
- _order_¶
No longer used, kept for backward compatibility. (class attribute, removed during class creation).
- _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.
- __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__(self, *args, **kwds)¶
By default, does nothing. If multiple values are given in the member assignment, those values become separate arguments to
__init__
; e.g.>>> from enum import Enum >>> class Weekday(Enum): ... MONDAY = 1, 'Mon'
Weekday.__init__()
would be called asWeekday.__init__(self, 1, 'Mon')
- __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'>
- __new__(cls, *args, **kwds)¶
By default, doesn't exist. If specified, either in the enum class definition or in a mixin class (such as
int
), all values given in the member assignment will be passed; e.g.>>> from enum import Enum >>> class MyIntEnum(int, Enum): ... TWENTYSIX = '1a', 16
results in the call
int('1a', 16)
and a value of26
for the member.Note
When writing a custom
__new__
, do not usesuper().__new__
-- call the appropriate__new__
instead.
- __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
avecEnum
donne des nombres entiers de valeur croissante, en commençant par1
.Modifié dans la version 3.12: Added Dataclass support
- 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
Note
L'utilisation de
auto
avecIntEnum
donne des entiers de valeur croissante, en commençant par1
.Modifié dans la version 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.Note
There are places in the stdlib that check for an exact
str
instead of astr
subclass (i.e.type(unknown) == str
instead ofisinstance(unknown, str)
), and in those locations you will need to usestr(StrEnum.member)
.Note
__str__()
isstr.__str__()
to better support the replacement of existing constants use-case.__format__()
is likewisestr.__format__()
for that same reason.Ajouté dans la version 3.11.
- class enum.Flag¶
Flag
is the same asEnum
, but its members support the bitwise operators&
(AND),|
(OR),^
(XOR), and~
(INVERT); the results of those operations are (aliases of) members of the enumeration.- __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>]
Ajouté dans la version 3.11.
- __len__(self):
Renvoie le nombre de membres de Flag :
>>> len(Color.GREEN) 1 >>> len(white) 3
Ajouté dans la version 3.11.
- __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):
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_()¶
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()
etoct()
.
Note
L'utilisation de
auto
avecFlag
donne des entiers qui sont des puissances de deux, en commençant par1
.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
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 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
If a
Flag
operation is performed with an IntFlag member and:le résultat est un IntFlag valide : un IntFlag est renvoyé ;
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>
Note
L'utilisation de
auto
avecIntFlag
donne des entiers qui sont des puissances de deux, en commençant par1
.Modifié dans la version 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()
.Ajouté 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, uneValueError
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.
Ajouté dans la version 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>
Ajouté 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¶
_add_alias_()
-- adds a new name as an alias to an existing member._add_value_alias_()
-- adds a new value as an alias to an existing member._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 alist
or astr
, 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 overriddenWhile
_sunder_
names are generally reserved for the further development of theEnum
class and can not be used, some are explicitly allowed:_repr_*
(e.g._repr_html_
), as used in IPython's rich display
Ajouté dans la version 3.6: _missing_
, _order_
, _generate_next_value_
Ajouté dans la version 3.7: _ignore_
Ajouté dans la version 3.13: _add_alias_
, _add_value_alias_
, _repr_*
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. 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
is used to create theSECOND
enum member;THREE = [auto(), -3]
will not work (<auto instance>, -3
is used to create theTHREE
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
etname
.Ajouté 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 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¶
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.Ajouté dans la version 3.11.
- @enum.member¶
Décorateur à utiliser dans les énumérations : sa cible devient un membre.
Ajouté dans la version 3.11.
- @enum.nonmember¶
Décorateur à utiliser dans les énumérations : sa cible ne devient pas un membre.
Ajouté dans la version 3.11.
- @enum.global_enum¶
A decorator to change the
str()
andrepr()
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 (seere.RegexFlag
for an example).Ajouté dans la version 3.11.
- enum.show_flag_values(value)¶
Return a list of all power-of-two integers contained in a flag value.
Ajouté dans la version 3.11.
Notes¶
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 nomSi ces limitations ne vous conviennent pas, vous pouvez créer votre propre classe mère en mélangeant vous-même le type
int
oustr
:>>> from enum import Enum >>> class MyIntEnum(int, Enum): ... passou vous pouvez réassigner la
str()
appropriée, etc., dans votre énumération :>>> from enum import Enum, IntEnum >>> class MyIntEnum(IntEnum): ... __str__ = Enum.__str__