enum --- 列挙型のサポート

バージョン 3.4 で追加.

ソースコード: Lib/enum.py


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 the 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 the class syntax to create Enums, Enums are not normal Python classes. See How are Enums different? for more details.

注釈

用語

  • クラス Color列挙型 (または Enum) です

  • 属性 Color.RED, Color.GREEN などは 列挙型のメンバー (または Enum メンバー) で、機能的には定数です。

  • 列挙型のメンバーは 名前 を持ちます (Color.RED の名前は REDColor.BLUE の値は 3 など。)

モジュールコンテンツ

EnumType

The type for Enum and its subclasses.

Enum

Base class for creating enumerated constants.

IntEnum

int のサブクラスでもある列挙型定数を作成する基底クラスです。

StrEnum

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

Flag

列挙型定数を作成する基底クラスで、ビット演算を使って組み合わせられ、その結果も IntFlag メンバーになります。

IntFlag

列挙型定数を作成する基底クラスで、ビット演算子を使って組み合わせられ、その結果も IntFlag メンバーになります。 IntFlagint のサブクラスでもあります。

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.

global_enum()

Enum class decorator to apply the appropriate global __repr__, and export its members into the global name space.

property()

Allows Enum members to have attributes without conflicting with other members' names.

unique()

一つの名前だけがひとつの値に束縛されていることを保証する Enum クラスのデコレーターです。

バージョン 3.6 で追加: Flag, IntFlag, auto

バージョン 3.10 で追加: StrEnum

Data Types

class enum.EnumType

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

__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__', '__doc__', '__members__', '__module__']
__getattr__(cls, name)

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

>>> Color.GREEN
Color.GREEN
__getitem__(cls, name)

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

>>> Color['BLUE']
Color.BLUE
__iter__(cls)

Returns each member in cls in definition order:

>>> list(Color)
[Color.RED, Color.GREEN, Color.BLUE]
__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))
[Color.BLUE, Color.GREEN, Color.RED]
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

注釈

列挙型のメンバー値

メンバー値は何であっても構いません: int, str などなど。 正確な値が重要でない場合は、 auto インスタンスを使っておくと、適切な値が選ばれます。 auto とそれ以外の値を混ぜて使う場合は注意する必要があります。

_ignore_

_ignore_ is only used during creation and is removed from the enumeration once that 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.

    value

    The value to lookup.

  • to use the cls enum to create a new enum:

    cls

    The enum class being called.

    value

    The name of the new Enum to create.

    名前

    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).naem)
>>> dir(Weekday.SATURDAY)
['__class__', '__doc__', '__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
_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')
Build.DEBUG
__repr__(self)

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

>>> class OldStyle(Enum):
...     RETRO = auto()
...     OLD_SCHOOl = auto()
...     YESTERYEAR = auto()
...     def __repr__(self):
...         cls_name = self.__class__.__name__
...         return f'<{cls_name}.{self.name}: {self.value}>'
>>> OldStyle.RETRO
<OldStyle.RETRO: 1>
__str__(self)

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

>>> class OldStyle(Enum):
...     RETRO = auto()
...     OLD_SCHOOl = auto()
...     YESTERYEAR = auto()
...     def __str__(self):
...         cls_name = self.__class__.__name__
...         return f'{cls_name}.{self.name}'
>>> OldStyle.RETRO
OldStyle.RETRO

注釈

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

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(str, unknown)), and in those locations you will need to use str(StrEnum.member).

注釈

Using auto with StrEnum results in values of the member name, lower-cased.

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)
[Color.RED]
>>> list(purple)
[Color.RED, Color.BLUE]
__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
Color.RED|Color.GREEN
__and__(self, other)

Returns current flag binary and'ed with other:

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

Returns current flag binary xor'ed with other:

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

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

>>> ~white
0x0
>>> ~purple
Color.GREEN
>>> ~Color.RED
Color.GREEN|Color.BLUE

注釈

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

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
0x0
>>> Color.RED | 2
Color.RED|Color.GREEN

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

注釈

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

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: 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
>>> class ConformFlag(Flag, boundary=CONFORM):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
>>> ConformFlag(2**2 + 2**4)
ConformFlag.BLUE
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)
KeepFlag.BLUE|0x10

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

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

@enum.global_enum

A class decorator specifically for enumerations. It replaces the __repr__() method with one that shows module_name.*member_name*. It also injects the members, and their aliases, into the the global namespace they were defined in.

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

@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