# `enum` --- Support for enumerations

Added in 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()`

> > Allows `Enum` members to have attributes without conflicting with member names. The `value` and `name` attributes are implemented this way.

> `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, and export the enum members to the global namespace.

> `show_flag_values()`

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

Added in version 3.6: `Flag`, `IntFlag`, `auto`

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

  Added in version 3.11: Before 3.11 `enum` used `EnumMeta` type, which is kept 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 use `auto` instances and an appropriate value will be chosen for you. See `auto` for the details.

    While mutable/unhashable values, such as `dict`, `list` or a mutable `dataclass`, 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.

  _value_

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

  _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 as `Weekday.__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 of `26` for the member.

    Note

    When writing a custom `__new__`, do not use `super().__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` avec `Enum` donne des nombres entiers de valeur croissante, en commençant par `1`.

  Modifié dans la version 3.12: Added Dataclass support

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

  Added in version 3.11.

class enum.Flag

  `Flag` is the same as `Enum`, but its members support the bitwise operators `&` (AND), `|` (OR), `^` (XOR), and `~` (INVERT); the results of those operators are 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>]

    Added in version 3.11.

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

  - `int.__str__()` for `IntEnum` and `IntFlag`

  - `str.__str__()` for `StrEnum`

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

  Added in 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.

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

    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

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

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

Added in 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_` -- 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

  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.

Added in version 3.6: `_missing_`, `_order_`, `_generate_next_value_`

Added in 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`.

  Added in 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.

  Added in version 3.11.

@enum.member

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

  Added in version 3.11.

@enum.nonmember

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

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

  Added in version 3.11.

enum.show_flag_values(value)

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

  Added in 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 Enum, IntEnum
>     >>> class MyIntEnum(IntEnum):
>     ...     __str__ = Enum.__str__