创新互联Python教程：enum—-对枚举的支持

enum —- 对枚举的支持

3.4 新版功能.

10年积累的成都网站制作、成都网站设计经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有建水免费网站建设让你可以放心的选择与我们合作。

源代码： Lib/enum.py

Important

This page contains the API reference information. For tutorial information and discussion of more advanced topics, see

Basic Tutorial
Advanced Tutorial
Enum Cookbook

An enumeration:

is a set of symbolic names (members) bound to unique values
can be iterated over to return its members in definition order
uses call syntax to return members by value
uses index syntax to return members by name

Enumerations are created either by using class syntax, or by using function-call syntax:

 
 
 
 
  
  
  
  >>> from enum import Enum
  
  
  
  
  
  
  
  >>> # class syntax
  
  
  
  >>> class Color(Enum):
  
  
  
  ... RED = 1
  
  
  
  ... GREEN = 2
  
  
  
  ... BLUE = 3
  
  
  
  
  
  
  
  >>> # functional syntax
  
  
  
  >>> Color = Enum('Color', ['RED', 'GREEN', 'BLUE'])

Even though we can use class syntax to create Enums, Enums are not normal python classes. See How are Enums different? for more details.

备注

命名法

类 Color 是枚举（或称为 enum ）。
The attributes Color.RED, Color.GREEN, etc., are enumeration members (or members) and are functionally constants.
枚举成员具有名称和值 (例如 Color.RED 的名称为 RED，Color.BLUE 的值为 3 等等)

模块内容

EnumType

The type for Enum and its subclasses.

Enum

Base class for creating enumerated constants.

IntEnum

Base class for creating enumerated constants that are also subclasses of int. (Notes)

StrEnum

Base class for creating enumerated constants that are also subclasses of str. (Notes)

Flag

创建可与位运算符搭配使用，又不会失去 Flag 成员资格的枚举常量的基类。

IntFlag

Base class for creating enumerated constants that can be combined using the bitwise operators without losing their IntFlag membership. IntFlag members are also subclasses of int. (Notes)

ReprEnum

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

EnumCheck

An enumeration with the values CONTINUOUS, NAMED_FLAGS, and UNIQUE, for use with verify() to ensure various constraints are met by a given enumeration.

FlagBoundary

An enumeration with the values STRICT, CONFORM, EJECT, and KEEP which allows for more fine-grained control over how invalid values are dealt with in an enumeration.

auto

Instances are replaced with an appropriate value for Enum members. StrEnum defaults to the lower-cased version of the member name, while other Enums default to 1 and increase from there.

property()

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

unique()

确保一个名称只绑定一个值的 Enum 类装饰器。

verify()

Enum class decorator that checks user-selectable constraints on an enumeration.

member()

Make obj a member. Can be used as a decorator.

nonmember()

Do not make obj a member. Can be used as a decorator.

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.

3.6 新版功能: Flag, IntFlag, auto

3.11 新版功能: StrEnum, EnumCheck, ReprEnum, FlagBoundary, property, member, nonmember, global_enum, show_flag_values

Data Types

class enum.EnumType

EnumType is the metaclass for enum enumerations. It is possible to subclass EnumType — see Subclassing EnumType for details.

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)
Returns True if member belongs to the cls:
```
   
   
   
   
    
    
    
    >>> some_var = Color.RED
    
    
    
    >>> some_var in Color
    
    
    
    True
   
   
   
   
```
备注
In Python 3.12 it will be possible to check for member values and not just members; until then, a TypeError will be raised if a non-Enum-member is used in a containment check.

__dir__(cls)

Returns ['__class__', '__doc__', '__members__', '__module__'] and the names of the members in cls:

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

__getattr__(cls, name)

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

   
   
   
   
    
    
    
    >>> Color.GREEN

__getitem__(cls, name)

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

   
   
   
   
    
    
    
    >>> Color['BLUE']

__iter__(cls)

Returns each member in cls in definition order:

   
   
   
   
    
    
    
    >>> list(Color)
    
    
    
    [, , ]

__len__(cls)

Returns the number of member in cls:

   
   
   
   
    
    
    
    >>> len(Color)
    
    
    
    3

__reversed__(cls)

Returns each member in cls in reverse definition order:

   
   
   
   
    
    
    
    >>> list(reversed(Color))
    
    
    
    [, , ]

class enum.Enum

Enum is the base class for all enum enumerations.

name

The name used to define the Enum member:

   
   
   
   
    
    
    
    >>> Color.BLUE.name
    
    
    
    'BLUE'

value
The value given to the Enum member:
```
   
   
   
   
    
    
    
    >>> Color.RED.value
    
    
    
    1
   
   
   
   
```
备注
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_ is only used during creation and is removed from the enumeration once creation is complete.
_ignore_ is a list of names that will not become members, and whose names will also be removed from the completed enumeration. See TimePeriod for an example.
__call__(cls, value, names=None, \**, module=None, qualname=None, type=None, start=1, boundary=None*)
This method is called in two different ways:
- to look up an existing member:
  - cls
    The enum class being called.
    值
    The value to lookup.
- to use the cls enum to create a new enum:
  - cls
    The enum class being called.
    值
    The name of the new Enum to create.
    names
    The names/values of the members for the new Enum.
    module — 模块
    The name of the module the new Enum is created in.
    qualname
    The actual location in the module where this Enum can be found.
    type — 类型
    A mix-in type for the new 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)

__dir__(self)

Returns ['__class__', '__doc__', '__module__', 'name', 'value'] and any public methods defined on 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
The name of the member being defined (e.g. ‘RED’).
start
The start value for the Enum; the default is 1.
count
The number of members currently defined, not including this one.
last_values
A list of the previous values.

A staticmethod that is used to determine the next value returned by auto:

   
   
   
   
    
    
    
    >>> from enum import auto
    
    
    
    >>> class PowersOfThree(Enum):
    
    
    
    ... @staticmethod
    
    
    
    ... def _generate_next_value_(name, start, count, last_values):
    
    
    
    ... return (count + 1) * 3
    
    
    
    ... FIRST = auto()
    
    
    
    ... SECOND = auto()
    
    
    
    >>> PowersOfThree.SECOND.value
    
    
    
    6

__init_subclass__(cls, \\*kwds*)
A classmethod that is used to further configure subsequent subclasses. By default, does nothing.

_missing_(cls, value)

A classmethod for looking up values not found in cls. By default it does nothing, but can be overridden to implement custom search behavior:

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

__repr__(self)

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

   
   
   
   
    
    
    
    >>> class OtherStyle(Enum):
    
    
    
    ... ALTERNATE = auto()
    
    
    
    ... OTHER = auto()
    
    
    
    ... SOMETHING_ELSE = auto()
    
    
    
    ... def __repr__(self):
    
    
    
    ... cls_name = self.__class__.__name__
    
    
    
    ... return f'{cls_name}.{self.name}'
    
    
    
    >>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
    
    
    
    (OtherStyle.ALTERNATE, 'OtherStyle.ALTERNATE', 'OtherStyle.ALTERNATE')

__str__(self)

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

   
   
   
   
    
    
    
    >>> class OtherStyle(Enum):
    
    
    
    ... ALTERNATE = auto()
    
    
    
    ... OTHER = auto()
    
    
    
    ... SOMETHING_ELSE = auto()
    
    
    
    ... def __str__(self):
    
    
    
    ... return f'{self.name}'
    
    
    
    >>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
    
    
    
    (, 'ALTERNATE', 'ALTERNATE')

__format__(self)

Returns the string used for format() and f-string calls. By default, returns __str__() returns, 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', 'ALTERNATE')

备注

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

class enum.IntEnum

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

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

备注

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

在 3.11 版更改: __str__() is now int.__str__() to better support the replacement of existing constants use-case. __format__() was already int.__format__() for that same reason.

class enum.StrEnum

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

备注

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

备注

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

备注

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

3.11 新版功能.

class enum.Flag

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

__contains__(self, value)

Returns True if value is in self:

   
   
   
   
    
    
    
    >>> from enum import Flag, auto
    
    
    
    >>> class Color(Flag):
    
    
    
    ... RED = auto()
    
    
    
    ... GREEN = auto()
    
    
    
    ... BLUE = auto()
    
    
    
    >>> purple = Color.RED | Color.BLUE
    
    
    
    >>> white = Color.RED | Color.GREEN | Color.BLUE
    
    
    
    >>> Color.GREEN in purple
    
    
    
    False
    
    
    
    >>> Color.GREEN in white
    
    
    
    True
    
    
    
    >>> purple in white
    
    
    
    True
    
    
    
    >>> white in purple
    
    
    
    False

__iter__(self):

Returns all contained members:

   
   
   
   
    
    
    
    >>> list(Color.RED)
    
    
    
    []
    
    
    
    >>> list(purple)
    
    
    
    [, ]

__len__(self):

Returns number of members in flag:

   
   
   
   
    
    
    
    >>> len(Color.GREEN)
    
    
    
    1
    
    
    
    >>> len(white)
    
    
    
    3

__bool__(self):

Returns True if any members in flag, False otherwise:

   
   
   
   
    
    
    
    >>> bool(Color.GREEN)
    
    
    
    True
    
    
    
    >>> bool(white)
    
    
    
    True
    
    
    
    >>> black = Color(0)
    
    
    
    >>> bool(black)
    
    
    
    False

__or__(self, other)

Returns current flag binary or’ed with other:

   
   
   
   
    
    
    
    >>> Color.RED | Color.GREEN

__and__(self, other)

Returns current flag binary and’ed with other:

   
   
   
   
    
    
    
    >>> purple & white
    
    
    
    
    
    
    
    >>> purple & Color.GREEN

__xor__(self, other)

Returns current flag binary xor’ed with other:

   
   
   
   
    
    
    
    >>> purple ^ white
    
    
    
    
    
    
    
    >>> purple ^ Color.GREEN

__invert__(self):

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

   
   
   
   
    
    
    
    >>> ~white
    
    
    
    
    
    
    
    >>> ~purple
    
    
    
    
    
    
    
    >>> ~Color.RED

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

备注

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

在 3.11 版更改: The repr() of zero-valued flags has changed. It is now::

 
 
 
 
  
  
  
  >>> Color(0)

class enum.IntFlag

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

 
 
 
 
  
  
  
  >>> from enum import IntFlag, auto
  
  
  
  >>> class Color(IntFlag):
  
  
  
  ... RED = auto()
  
  
  
  ... GREEN = auto()
  
  
  
  ... BLUE = auto()
  
  
  
  >>> Color.RED & 2
  
  
  
  
  
  
  
  >>> Color.RED | 2

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

 
 
 
 
  
  
  
  >>> Color.RED + 2
  
  
  
  3

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

the result is a valid IntFlag: an IntFlag is returned

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

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

 
 
 
 
  
  
  
  >>> Color(0)

备注

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

在 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.ReprEnum

ReprEum 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() / :func:`format of the mixed-in data type instead of using the Enum-default str().

3.11 新版功能.

class enum.EnumCheck

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

UNIQUE

Ensure that each value has only one name:

   
   
   
   
    
    
    
    >>> from enum import Enum, verify, UNIQUE
    
    
    
    >>> @verify(UNIQUE)
    
    
    
    ... class Color(Enum):
    
    
    
    ... RED = 1
    
    
    
    ... GREEN = 2
    
    
    
    ... BLUE = 3
    
    
    
    ... CRIMSON = 1
    
    
    
    Traceback (most recent call last):
    
    
    
    ...
    
    
    
    ValueError: aliases found in : CRIMSON -> RED

CONTINUOUS

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

   
   
   
   
    
    
    
    >>> from enum import Enum, verify, CONTINUOUS
    
    
    
    >>> @verify(CONTINUOUS)
    
    
    
    ... class Color(Enum):
    
    
    
    ... RED = 1
    
    
    
    ... GREEN = 2
    
    
    
    ... BLUE = 5
    
    
    
    Traceback (most recent call last):
    
    
    
    ...
    
    
    
    ValueError: invalid enum 'Color': missing values 3, 4

NAMED_FLAGS

Ensure that any flag groups/masks contain only named flags — useful when values are specified instead of being generated by auto()

   
   
   
   
    
    
    
    >>> from enum import Flag, verify, NAMED_FLAGS
    
    
    
    >>> @verify(NAMED_FLAGS)
    
    
    
    ... class Color(Flag):
    
    
    
    ... RED = 1
    
    
    
    ... GREEN = 2
    
    
    
    ... BLUE = 4
    
    
    
    ... WHITE = 15
    
    
    
    ... NEON = 31
    
    
    
    Traceback (most recent call last):
    
    
    
    ...
    
    
    
    ValueError: invalid Flag 'Color': aliases WHITE and NEON are missing combined values of 0x18 [use enum.show_flag_values(value) for details]

备注

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

3.11 新版功能.

class enum.FlagBoundary

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

STRICT

Out-of-range values cause a ValueError to be raised. This is the default for Flag:

   
   
   
   
    
    
    
    >>> from enum import Flag, STRICT
    
    
    
    >>> class StrictFlag(Flag, boundary=STRICT):
    
    
    
    ... RED = auto()
    
    
    
    ... GREEN = auto()
    
    
    
    ... BLUE = auto()
    
    
    
    >>> StrictFlag(2**2 + 2**4)
    
    
    
    Traceback (most recent call last):
    
    
    
    ...
    
    
    
    ValueError:  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
    
    
    
    >>> class ConformFlag(Flag, boundary=CONFORM):
    
    
    
    ... RED = auto()
    
    
    
    ... GREEN = auto()
    
    
    
    ... BLUE = auto()
    
    
    
    >>> ConformFlag(2**2 + 2**4)

EJECT

Out-of-range values lose their Flag membership and revert to int. This is the default for IntFlag:

   
   
   
   
    
    
    
    >>> from enum import Flag, EJECT
    
    
    
    >>> 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 used for some stdlib flags:

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

3.11 新版功能.

支持的 `dunder` 名称

__members__ 是一个 member_name:member 条目的只读有序映射。它只在类上可用。

如果指定了 __new__()，它必须创建并返回枚举成员；相应地设定成员的 _value_ 也是一个很好的主意。一旦所有成员都创建完成它就不会再被使用。

支持的 `_sunder_` 名称

_name_ — 成员的名称
_value_ — 成员的值；可以在 __new__ 中设置 / 修改
_missing_ — 当未发现某个值时所使用的查找函数；可被重载
_ignore_ — 一个名称列表，可以为 list 或 str，它不会被转化为成员，并将从最终类中被移除
_order_ — 用于 Python 2/3 代码以确保成员顺序一致（类属性，在类创建期间会被移除）
_generate_next_value_ — used to get an appropriate value for an enum member; may be overridden

备注
For standard Enum classes the next value chosen is the last value seen incremented by one.
For Flag classes the next value chosen will be the next highest power-of-two, regardless of the last value seen.

3.6 新版功能: _missing_, _order_, _generate_next_value_

3.7 新版功能: _ignore_

Utilities and Decorators

class enum.auto

auto can be used in place of a value. If used, the Enum machinery will call an Enum‘s _generate_next_value_() to get an appropriate value. For Enum and IntEnum that appropriate value will be the last value plus one; for Flag and IntFlag it will be the first power-of-two greater than the last 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 (, -3 is used to create the THREE enum member)

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

备注

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

@enum.property

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

备注

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

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 : FOUR -> THREE

@enum.verify

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

3.11 新版功能.

@enum.member

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

3.11 新版功能.

@enum.nonmember

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

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

3.11 新版功能.

enum.show_flag_values(value)

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

3.11 新版功能.

Notes

IntEnum, StrEnum, and IntFlag

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

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

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

If you do not need/want those limitations, you can either create your own base class by mixing in the int or str type yourself:
   
   
   
   
    
    
    
    >>> from enum import Enum
    
    
    
    >>> class MyIntEnum(int, Enum):
    
    
    
    ... pass
   
   
   
   
or you can reassign the appropriate str(), etc., in your enum:
  
  
  
  
   
   
   
   >>> from enum import IntEnum
   
   
   
   >>> class MyIntEnum(IntEnum):
   
   
   
   ... __str__ = IntEnum.__str__
  
  
  
  

标题名称：创新互联Python教程：enum—-对枚举的支持
网站路径：http://www.bluegullmedia.com/article/dphdipe.html

建站动态

创新互联Python教程：enum—-对枚举的支持

enum —- 对枚举的支持

模块内容

Data Types

支持的 `dunder` 名称

支持的 `_sunder_` 名称

Utilities and Decorators

Notes

其他资讯

网站建设专属方案

网站定制化设计

7X24小时服务

N对管家服务

让你的专属顾问为你服务

建站动态

创新互联Python教程：enum—-对枚举的支持

enum —- 对枚举的支持

模块内容

Data Types

支持的 __dunder__ 名称

支持的 _sunder_ 名称

Utilities and Decorators

Notes

其他资讯

网站建设专属方案

网站定制化设计

7X24小时服务

N对管家服务

让你的专属顾问为你服务

支持的 `dunder` 名称

支持的 `_sunder_` 名称