`enum` — 열거형 지원¶

Added in version 3.4.

소스 코드: Lib/enum.py

열거형은:

고유한 값에 바인딩된 심볼릭 이름(멤버) 집합입니다.
정의 순서대로 해당 위젯의 정규 멤버를 반환하기 위해 반복할 수 있습니다:
멤버를 값으로 반환하기 위해 call 구문을 사용합니다
멤버를 이름으로 반환하기 위해 index 구문을 사용합니다

열거형은 class 구문을 사용하거나 함수 호출 구문을 사용하여 생성됩니다:

>>> from enum import Enum

>>> # 클래스 문법
>>> class Color(Enum):
...     RED = 1
...     GREEN = 2
...     BLUE = 3

>>> # 함수형 문법
>>> Color = Enum('Color', [('RED', 1), ('GREEN', 2), ('BLUE', 3)])

class 문법을 사용하여 Enum을 만들 수 있기는 하지만, Enum은 일반적인 파이썬 클래스가 아닙니다. 자세한 내용은 열거형은 어떻게 다릅니까? 를 참조하십시오.

참고

명명법

Color 클래스는 열거형(enumeration) (또는 enum) 입니다.
Color.RED, Color.GREEN 등의 어트리뷰트는 열거형 멤버(enumeration members)(또는 members)이며 기능상 상수입니다.
열거형 멤버에는 이름(names)과 값(values)이 있습니다 (Color.RED의 이름은 RED, Color.BLUE의 값은 3, 등)

모듈 내용¶

EnumType

Enum 및 그 서브클래스의 type.

Enum

열거형 상수를 만들기 위한 베이스 클래스.

IntEnum

int의 서브 클래스이기도 한 열거형 상수를 만들기 위한 베이스 클래스. (Notes)

StrEnum

str의 서브 클래스이기도 한 열거형 상수를 만들기 위한 베이스 클래스. (Notes)

Flag

Flag 멤버십을 잃지 않고 비트 연산을 사용하여 결합할 수 있는 열거형 상수를 만들기 위한 베이스 클래스.

IntFlag

IntFlag 멤버십을 잃지 않고 비트 연산자를 사용하여 결합할 수 있는 열거형 상수를 만들기 위한 베이스 클래스. IntFlag 멤버도 int의 서브 클래스입니다. (Notes)

ReprEnum

IntEnum, StrEnum, 및 :class:`IntFlag`에 의해 사용되며, 혼합된 유형의 :class:`str() <str>`을 유지합니다.

EnumCheck

주어진 열거형이 다양한 제약 조건을 충족하는지 확인하기 위해 verify`와 함께 사용할 수 있는, ``CONTINUOUS`(), NAMED_FLAGS, 및 UNIQUE 값을 가진 열거형입니다.

FlagBoundary

열거형은 STRICT, CONFORM, EJECT, KEEP 값을 가지며, 열거형에서 유효하지 않은 값 처리 방식에 대해 더욱 세밀한 제어를 가능하게 합니다.

EnumDict

:class:`EnumType`을 상속할 때 사용되는 :class:`dict`의 서브클래스입니다.

auto

인스턴스는 Enum 멤버에 대해 적절한 값으로 대체됩니다. :class:`StrEnum`은 멤버 이름의 소문자 버전으로 기본 설정되는 반면, 다른 Enum은 1로 기본 설정되고 거기서 증가합니다.

@~enum.property

Enum 멤버가 멤버 이름과 충돌하지 않는 속성을 가지도록 허용합니다. value 및 name 속성이 이러한 방식으로 구현됩니다.

@unique

한 값에 하나의 이름 만 연결되도록 하는 Enum 클래스 데코레이터.

@verify

열거에 사용자가 선택할 수 있는 제약 조건을 확인하는 Enum 클래스 데코레이터.

@member

obj 를 멤버로 만듭니다. 데코레이터로 사용될 수 있습니다.

@nonmember

obj 를 멤버로 만들지 않습니다. 데코레이터로 사용될 수 있습니다.

@global_enum

:class:`str() <str>`와 :func:`repr`을 수정하여 열거형(enum)의 멤버들이 클래스에 속하는 대신 모듈에 속하는 것처럼 표시하고, 열거형 멤버들을 전역 네임스페이스로 내보냅니다.

show_flag_values()

플래그에 포함된 모든 2의 거듭제곱 정수 목록을 반환합니다.

enum.bin()

내장된 bin() 과 유사하지만, 음수 값은 2의 보수로 표현되며 최상위 비트는 항상 부호를 나타냅니다 (0 은 양수, 1 은 음수).

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

Added in version 3.13: EnumDict

자료형¶

class enum.EnumType¶

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

EnumType 는 최종 enum 에서 올바른 __repr__(), __str__(), __format__(), 및 __reduce__() 메서드를 설정하는 책임을 지며, enum 멤버를 생성하고, 중복을 올바르게 처리하며, enum 클래스를 반복하는 등의 기능을 제공합니다.

Added in version 3.11: 3.11 이전에는 EnumType 가 EnumMeta 라고 불렸으며, 이는 여전히 별칭으로 사용 가능합니다.

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

이 메서드는 두 가지 방식으로 호출됩니다:

기존 멤버를 조회하기 위해:

cls:

호출되는 열거형 클래스입니다.

value:

조회할 값입니다.
cls 열거형을 사용하여 새 열거형을 생성하려면 (기존 열거형에 멤버가 없는 경우에만):

cls:

호출되는 열거형 클래스입니다.

value:

생성할 새 열거형의 이름입니다.

names:

새 열거형의 멤버 이름/값입니다.

module:

새로운 Enum 이 만들어지는 모듈의 이름.

qualname:

이 Enum 이 모듈에서 실제로 위치한 곳.

type:

새 열거형을 위한 믹스인 유형입니다.

start:

열거형의 첫 번째 정수 값입니다 ( :class:`auto`에 사용됩니다).

boundary:

비트 연산에서 범위 밖의 값을 처리하는 방법 (:class:`Flag`에서만).

__contains__(cls, member)¶

멤버가 cls 에 속하면 True 를 반환합니다:

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

버전 3.12에서 변경: Python 3.12 이전에는 포함 여부 확인 시 Enum 멤버가 아닌 항목을 사용하면 TypeError 가 발생했습니다.

__dir__(cls)¶

cls 의 각 멤버를 정의 순서로 반환합니다:

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

__getitem__(cls, name)¶

cls*와 일치하는 *name 멤버를 반환하거나, :exc:`KeyError`를 발생시킵니다:

>>> Color['BLUE']
<Color.BLUE: 3>

__iter__(cls)¶

cls 의 각 멤버를 정의 순서로 반환합니다:

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

__len__(cls)¶

cls 의 멤버 수를 반환합니다:

>>> len(Color)
3

__members__¶: 열거형의 모든 이름과 해당 멤버를 별칭을 포함하여 매핑하여 반환합니다:

__reversed__(cls)¶

cls 의 각 멤버를 역순 정의 순서로 반환합니다:

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

class enum.Enum¶

Enum*은 모든 *enum 열거형의 기본 클래스입니다.

name¶

Enum 멤버를 정의하는 데 사용된 이름:

>>> Color.BLUE.name
'BLUE'

value¶

Enum 멤버에 주어진 값:

>>> Color.RED.value
1

멤버의 값, __new__()에서 설정할 수 있습니다.

참고

Enum 멤버 값

멤버 값은 아무것이나 될 수 있습니다: int, str 등. 정확한 값이 중요하지 않다면, auto 인스턴스를 사용할 수 있으며 적절한 값이 선택됩니다. 자세한 내용은 auto를 참조하세요.

dict`나 :class:`list 같은 가변/해시 불가능한 값, 또는 가변 :class:`~dataclasses.dataclass`와 같은 값은 사용할 수 있지만, 열거형에 포함된 전체 가변/해시 불가능한 값의 개수에 비해 생성 시 2차 성능 영향을 받게 됩니다.

_name_¶: 멤버의 이름.

_value_¶: 멤버의 값, __new__()에서 설정할 수 있습니다.

_order_¶

더는 사용되지 않습니다, 하위 호환성을 위해 유지됩니다. (클래스 생성 중 제거되는 클래스 어트리뷰트)

_order_ 속성을 제공하여 Python 2 / Python 3 코드가 동기화 상태를 유지하도록 할 수 있습니다. 이는 열거형의 실제 순서와 비교되며, 두 값이 일치하지 않으면 에러가 발생합니다:

>>> class Color(Enum):
...     _order_ = 'RED GREEN BLUE'
...     RED = 1
...     BLUE = 3
...     GREEN = 2
...
Traceback (most recent call last):
...
TypeError: member order does not match _order_:
   ['RED', 'BLUE', 'GREEN']
   ['RED', 'GREEN', 'BLUE']

참고

파이썬 2 코드에서는 정의 순서가 기록되기 전에 손실되기 때문에 _order_ 속성이 필요합니다.

Added in version 3.6.

_ignore_¶

_ignore_ 는 생성 시에만 사용되며, 생성이 완료되면 열거형에서 제거됩니다.

_ignore_ 는 멤버가 되지 않을 이름 목록이며, 이 이름들은 완료된 열거형에서도 제거됩니다. 예시는 TimePeriod 를 참조하세요.

Added in version 3.7.

__dir__(self)¶

['__class__', '__doc__', '__module__', 'name', 'value'] 와 self.__class__ 에 정의된 모든 공개 메서드를 반환합니다:

>>> from enum import Enum
>>> import datetime as dt
>>> class Weekday(Enum):
...     MONDAY = 1
...     TUESDAY = 2
...     WEDNESDAY = 3
...     THURSDAY = 4
...     FRIDAY = 5
...     SATURDAY = 6
...     SUNDAY = 7
...     @classmethod
...     def today(cls):
...         print(f'today is {cls(dt.date.today().isoweekday()).name}')
...
>>> dir(Weekday.SATURDAY)
['__class__', '__doc__', '__eq__', '__hash__', '__module__', '_add_alias_', '_add_value_alias_', '_generate_next_value_', '_missing_', 'name', 'today', 'value']

_generate_next_value_(name, start, count, last_values)¶

name:

정의 중인 멤버의 이름입니다 (예: ‘RED’).

start:

열거형의 시작 값입니다. 기본값은 1입니다.

count:

현재 정의된 멤버의 수이며, 이 멤버는 포함하지 않습니다.

last_values:

이전 값들의 리스트입니다:

auto 에 의해 반환될 다음 값을 결정하는 데 사용되는 staticmethod 입니다.

참고

표준 Enum 클래스의 경우, 선택되는 다음 값은 가장 높은 값을 하나 증가시킨 값입니다.

Flag 클래스의 경우, 선택되는 다음 값은 다음으로 높은 2의 거듭제곱 값입니다.

이 메서드는 오버라이드될 수 있습니다. 예를 들면:

>>> from enum import auto, Enum
>>> 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

Added in version 3.6.

버전 3.13에서 변경: 이전 버전에서는 최고 값 대신 마지막으로 본 값을 사용했습니다.

__init__(self, *args, **kwds)¶

기본적으로 아무것도 하지 않습니다. 멤버 할당에 여러 값이 주어지면, 해당 값들은 __init__ 의 별도의 인자가 됩니다. 예를 들면:

>>> from enum import Enum
>>> class Weekday(Enum):
...     MONDAY = 1, 'Mon'

Weekday.__init__() 은 Weekday.__init__(self, 1, 'Mon') 으로 호출될 것입니다:

__init_subclass__(cls, **kwds)¶: 후속 서브클래스를 추가 구성하는 데 사용되는 classmethod 입니다. 기본적으로 아무것도 하지 않습니다.

_missing_(cls, value)¶

cls 에 없는 값을 검색하는 데 사용되는 classmethod 입니다. 기본적으로 아무것도 하지 않지만, 사용자 정의 검색 동작을 구현하도록 오버라이드할 수 있습니다:

>>> from enum import auto, 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'>

Added in version 3.6.

__new__(cls, *args, **kwds)¶

기본적으로 존재하지 않습니다. 지정되는 경우, 열거형 클래스 정의 또는 믹스인 클래스(예: int)에서 주어진 모든 값들이 전달됩니다. 예를 들면:

>>> from enum import Enum
>>> class MyIntEnum(int, Enum):
...     TWENTYSIX = '1a', 16

int('1a', 16) 호출과 멤버에 대한 값 26 을 초래합니다.

참고

사용자 정의 __new__ 를 작성할 때는 super().__new__ 를 사용하지 마십시오. 대신 적절한 __new__ 를 호출하세요.

__repr__(self)¶

repr() 호출에 사용되는 문자열을 반환합니다. 기본적으로 Enum 이름, 멤버 이름, 값을 반환하지만, 오버라이드할 수 있습니다:

>>> from enum import auto, Enum
>>> 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)¶

str() 호출에 사용되는 문자열을 반환합니다. 기본적으로 Enum 이름과 멤버 이름을 반환하지만, 오버라이드할 수 있습니다:

>>> from enum import auto, Enum
>>> 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)¶

format() 및 f-string 호출에 사용되는 문자열을 반환합니다. 기본적으로 :meth:`__str__`의 반환 값을 반환하지만, 오버라이드할 수 있습니다:

>>> from enum import auto, Enum
>>> 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')

참고

Enum 과 auto 를 함께 사용하면 1 부터 시작하여 증가하는 정수를 얻게 됩니다.

버전 3.12에서 변경: :ref:`enum-dataclass-support`를 추가했습니다.

_add_alias_()¶

기존 멤버에 새로운 이름을 별칭으로 추가합니다:

>>> Color.RED._add_alias_("ERROR")
>>> Color.ERROR
<Color.RED: 1>

이름이 이미 다른 멤버에 할당되어 있으면 :exc:`NameError`를 발생시킵니다:

Added in version 3.13.

_add_value_alias_()¶

기존 멤버에 새로운 값을 별칭으로 추가합니다:

>>> Color.RED._add_value_alias_(42)
>>> Color(42)
<Color.RED: 1>

값이 이미 다른 멤버와 연결되어 있으면 :exc:`ValueError`를 발생시킵니다:

예시는 :ref:`multi-value-enum`을 참고하세요.

Added in version 3.13.

class enum.IntEnum¶

IntEnum*은 :class:`Enum`과 같지만, 멤버들도 정수이므로 정수가 사용될 수 있는 모든 곳에서 사용할 수 있습니다. *IntEnum 멤버로 정수 연산이 수행되면, 결과 값은 열거형 상태를 잃게 됩니다.

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

참고

IntEnum 과 auto 를 함께 사용하면 1 부터 시작하여 증가하는 정수를 얻게 됩니다.

버전 3.11에서 변경: __str__`는 이제 :meth:()!int.__str__`이며, 이는 기존 상수 대체 사용 사례를 더 잘 지원하기 위함입니다. __format__`은 같은 이유로 이미 :meth:()!int.__format__`입니다.

class enum.StrEnum¶

StrEnum*은 :class:`Enum`과 같지만, 멤버가 문자열이기도 하므로 문자열이 사용될 수 있는 대부분의 장소에서 사용할 수 있습니다. *StrEnum 멤버에 대해 수행된 모든 문자열 작업의 결과는 열거형의 일부가 아닙니다.

>>> from enum import StrEnum, auto
>>> class Color(StrEnum):
...     RED = 'r'
...     GREEN = 'g'
...     BLUE = 'b'
...     UNKNOWN = auto()
...
>>> Color.RED
<Color.RED: 'r'>
>>> Color.UNKNOWN
<Color.UNKNOWN: 'unknown'>
>>> str(Color.UNKNOWN)
'unknown'

참고

stdlib에는 str 서브클래스 대신 정확한 str 을 확인하는 곳들이 있습니다 (즉, type(unknown) == str 대신 isinstance(unknown, str)). 이러한 위치에서는 str(MyStrEnum.MY_MEMBER) 을 사용해야 합니다.

참고

:class:`auto`를 :class:`StrEnum`과 함께 사용하면 소문자 멤버 이름이 값으로 반환됩니다.

참고

__str__`는 :meth:()!str.__str__`이며, 이는 기존 상수 대체 사용 사례를 더 잘 지원하기 위함입니다. __format__`도 같은 이유로 :meth:()!str.__format__`입니다.

Added in version 3.11.

class enum.Flag¶

Flag``은 :class:`Enum`과 같지만, 멤버가 비트 연산자 ``& (AND), | (OR), ^ (XOR) 및 ~ (INVERT)를 지원하며, 해당 연산의 결과는 해당 열거형의 멤버(별칭)입니다.

__contains__(self, value)¶

값이 self에 있는지 여부에 따라 True 를 반환합니다:

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

포함된 모든 비별칭 멤버를 반환합니다:

>>> list(Color.RED)
[<Color.RED: 1>]
>>> list(purple)
[<Color.RED: 1>, <Color.BLUE: 4>]

Added in version 3.11.

__len__(self)¶

flag의 멤버 수를 반환합니다:

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

Added in version 3.11.

__bool__(self)¶

flag의 멤버 중 하나라도 존재하는 경우 True, 그렇지 않으면 False 를 반환합니다:

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

__or__(self, other)¶

현재 플래그와 다른 플래그를 비트별 AND 연산한 값을 반환합니다:

>>> Color.RED | Color.GREEN
<Color.RED|GREEN: 3>

__and__(self, other)¶

현재 플래그와 다른 플래그를 비트별 AND 연산한 값을 반환합니다:

>>> purple & white
<Color.RED|BLUE: 5>
>>> purple & Color.GREEN
<Color: 0>

__xor__(self, other)¶

현재 플래그와 다른 플래그를 비트별 XOR 연산한 값을 반환합니다:

>>> purple ^ white
<Color.GREEN: 2>
>>> purple ^ Color.GREEN
<Color.RED|GREEN|BLUE: 7>

__invert__(self)¶

self 에 없고 type(self) 에 있는 모든 플래그를 반환합니다:

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

_numeric_repr_()¶: 모든 나머지 이름 없는 숫자 값을 형식화하는 데 사용되는 함수입니다. 기본값은 값의 repr이며, 일반적인 선택지로는 :func:`hex`와 :func:`oct`가 있습니다.

참고

Flag 와 함께 auto 를 사용하면 값이 1 부터 시작하는 2의 거듭제곱인 정수가 반환됩니다.

버전 3.11에서 변경: 0으로 값 지정된 flag의 repr() 이 변경되었습니다. 이제는 다음과 같습니다:

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

class enum.IntFlag¶

IntFlag 은 Flag 과 같지만, 멤버가 정수이기도 하여 정수가 사용될 수 있는 모든 곳에서 사용할 수 있습니다.

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

IntFlag 멤버와 정수 연산을 수행하면 결과는 IntFlag 가 아닙니다:

>>> Color.RED + 2
3

IntFlag 멤버와 Flag 연산을 수행하고:

결과가 유효한 IntFlag 인 경우: IntFlag 가 반환됩니다
결과가 유효한 IntFlag 가 아닌 경우: 결과는 FlagBoundary 설정에 따라 달라집니다:

이름 없는 0으로 값 지정된 flag의 :func:`repr`이 변경되었습니다. 이제는 다음과 같습니다:

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

참고

IntFlag 와 함께 auto 를 사용하면 값이 1 부터 시작하는 2의 거듭제곱인 정수가 반환됩니다.

:class:`!IntFlag`의 반전은 이제 부정적인 값이 아닌, 주어진 플래그에 없는 모든 플래그의 합집합을 나타내는 양의 값을 반환합니다. 이는 기존 :class:`Flag`의 동작과 일치합니다.

class enum.ReprEnum¶

:class:`!ReprEnum`은 :class:`Enum`의 :meth:`repr() <Enum.__repr__>`를 사용하지만, 혼합된 데이터 형식의 :class:`str() <str>`을 사용합니다:

IntEnum 및 IntFlag`을 위한 :meth:!int.__str__`
StrEnum`을 위한 :meth:!str.__str__`

Enum`의 기본 :meth:`str() / format`을 유지하기 위해 :class:()!ReprEnum`을 상속받습니다.

Added in version 3.11.

class enum.EnumCheck¶

EnumCheck 는 다양한 제약 조건을 보장하는 데 사용되는 verify() 데코레이터가 사용하는 옵션을 포함하며, 실패한 제약 조건은 ValueError 를 발생시킵니다.

UNIQUE¶

각 값이 고유한 이름만 가지도록 보장합니다:

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

가장 낮은 값을 가진 멤버와 가장 높은 값을 가진 멤버 사이에 누락된 값이 없는지 보장합니다:

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

모든 플래그 그룹/마스크가 이름을 가진 플래그만 포함하도록 보장합니다. 이는 값이 :func:`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와 NAMED_FLAGS는 정수 값을 가진 멤버와 함께 작동하도록 설계되었습니다.

Added in version 3.11.

class enum.FlagBoundary¶

FlagBoundary 는 Flag 및 그 서브클래스에서 범위를 벗어난 값을 처리하는 방법을 제어합니다.

STRICT¶

범위를 벗어난 값은 :exc:`ValueError`를 발생시킵니다. 이는 :class:`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¶

범위를 벗어난 값은 유효하지 않은 값들이 제거되어 유효한 Flag 값을 남깁니다:

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

범위를 벗어난 값은 해당 Flag 멤버십을 잃고 :class:`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¶

범위를 벗어난 값은 유지되며, Flag 멤버십도 유지됩니다. 이는 :class:`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.

class enum.EnumDict¶

EnumDict 는 열거형 클래스를 정의하는 이름 공간으로 사용되는 dict 의 서브클래스입니다 (참고: 클래스 이름 공간 준비하기). 이 클래스는 멤버당 여러 값을 갖는 것과 같은 고급 동작을 가진 EnumType 의 서브클래스를 사용할 수 있도록 노출됩니다. 이 클래스는 생성되는 열거형 클래스의 이름과 함께 호출해야 하며, 그렇지 않으면 비공개 이름이나 내부 클래스가 올바르게 처리되지 않을 수 있습니다.

MutableMapping 인터페이스 ( __setitem__() 및 update() )만 재정의된다는 점에 유의하십시오. |= <object.__ior__>`와 같은 다른 :class:()!dict` 연산을 사용하여 검사를 우회할 수 있을 수 있습니다.

member_names¶: 멤버 이름의 리스트.

Added in version 3.13.

지원되는 `dunder` 이름¶

__members__는 member_name:member 항목의 읽기 전용 순서 있는 매핑입니다. 클래스에서만 이용할 수 있습니다.

:meth:`~Enum.__new__`는 지정된 경우 열거형 멤버를 생성하고 반환해야 합니다; 멤버의 :attr:`~Enum._value_`를 적절하게 설정하는 것도 매우 좋습니다. 모든 멤버가 생성되면 더 이상 사용되지 않습니다.

지원되는 `_sunder_` 이름¶

_name_ – 멤버의 이름
_value_ – 멤버의 값; __new__에서 설정할 수 있습니다
_missing_() – 값을 찾을 수 없을 때 사용되는 조회 함수; 재정의할 수 있습니다
_ignore_ – 멤버로 변환되지 않고 최종 클래스에서 제거될 list나 str 형의 이름 목록
_order_ – 더는 사용되지 않습니다, 하위 호환성을 위해 유지됩니다 (클래스 생성 중 제거되는 클래스 어트리뷰트)
_generate_next_value_() – 열거형 멤버에 대한 적절한 값을 얻기 위해 사용합니다; 재정의할 수 있습니다
_add_alias_() – 기존 멤버의 별칭으로 새 이름을 추가합니다.
_add_value_alias_() – 기존 멤버의 별칭으로 새 값을 추가합니다.
_sunder_ 이름은 일반적으로 Enum 클래스의 추가 개발을 위해 예약되어 사용될 수 없지만, 일부는 명시적으로 허용됩니다:
- _repr_* (예: _repr_html_), IPython’s rich display 에서 사용되는 방식

Added in version 3.6: _missing_, _order_, _generate_next_value_

Added in version 3.7: _ignore_

Added in version 3.13: _add_alias_, _add_value_alias_, _repr_*

유틸리티 및 데코레이터¶

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 highest value seen plus one; for Flag and IntFlag it will be the first power-of-two greater than the highest value seen; 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 인스턴스는 할당문의 최상위 레벨에서만, 자체로 또는 튜플의 일부로서만 결정됩니다:

FIRST = auto() 가 작동합니다 (auto()는 1 로 대체됨);
SECOND = auto(), -2``가 작동합니다 (auto는 ``2``로 대체되어 ``2, -2``가 ``SECOND 열거형 멤버를 생성하는 데 사용됨;
THIRD = [auto(), -3]``는 작동하지 않습니다 (``[<auto instance>, -3]``가 ``THIRD 열거형 멤버를 생성하는 데 사용됨)

버전 3.11.1에서 변경: 이전 버전에서는 auto() 가 제대로 작동하려면 할당 라인에 유일한 항목이어야 했습니다.

auto 가 사용하는 값을 사용자 정의하기 위해 _generate_next_value_ 를 재정의할 수 있습니다.

참고

버전 3.13에서는 기본 _generate_next_value_ 가 항상 가장 높은 멤버 값에 1을 더한 값을 반환하며, 멤버 중 하나가 호환되지 않는 유형인 경우 실패합니다.

@enum.property¶: 내장 :deco:`property`와 유사하지만 열거형에 특화된 데코레이터입니다. 이 데코레이터는 멤버 속성이 멤버 자체와 같은 이름을 갖도록 허용합니다.

참고

property*와 멤버는 별도의 클래스에 정의되어야 합니다. 예를 들어, *value 및 name 속성은 Enum 클래스에 정의되며, Enum 서브클래스는 value 및 name 이름을 가진 멤버를 정의할 수 있습니다.

Added in version 3.11.

@enum.unique¶

열거형 용 class 데코레이터입니다. 열거형의 __members__를 검색하여, 별칭을 수집합니다; 발견되면 ValueError가 세부 정보와 함께 발생합니다:

>>> 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¶: 열거형에 특화된 class 데코레이터입니다. :class:`EnumCheck`의 멤버는 데코레이션된 열거형에 적용할 제약 조건을 지정하는 데 사용됩니다.

Added in version 3.11.

@enum.member¶: 열거형에서 사용되는 데코레이터: 해당 대상이 멤버가 됩니다.

Added in version 3.11.

@enum.nonmember¶: 열거형에서 사용되는 데코레이터: 해당 대상은 멤버가 되지 않습니다.

Added in version 3.11.

@enum.global_enum¶: 열거형의 str() 및 repr`을 변경하여 멤버가 클래스 대신 모듈에 속하는 것처럼 표시하는 데 사용되는 데코레이터입니다. 열거형 멤버가 모듈 전역 이름 공간으로 내보내질 때만 사용해야 합니다 (예: :class:`re.RegexFlag() 참조).

Added in version 3.11.

enum.show_flag_values(value)¶: 플래그 value 에 포함된 모든 2의 거듭제곱 정수 목록을 반환합니다.

Added in version 3.11.

enum.bin(num, max_bits=None)¶

내장된 bin() 과 유사하지만, 음수 값은 2의 보수로 표현되며 최상위 비트는 항상 부호를 나타냅니다 (0 은 양수, 1 은 음수).

>>> import enum
>>> enum.bin(10)
'0b0 1010'
>>> enum.bin(~10)   # ~10 is -11
'0b1 0101'

Added in version 3.11.

참고 사항¶

IntEnum, StrEnum, 및 IntFlag

이 세 가지 열거형 유형은 기존 정수 기반 및 문자열 기반 값의 대체품으로 설계되었습니다. 따라서 다음과 같은 추가 제한 사항이 있습니다:

__str__ 은 이름이 아닌 값을 사용합니다

`__format__`은 `__str__`을 사용하기 때문에 열거형 멤버의 이름 대신 값을 사용합니다.

이러한 제한이 필요하지 않다면, int 또는 str 타입을 마믹(mixin)하여 자체 기본 클래스를 만들 수 있습니다:
>>> from enum import Enum
>>> class MyIntEnum(int, Enum):
...     pass
또는 열거형에서 적절한 str() 등을 재할당할 수 있습니다:
>>> from enum import Enum, IntEnum
>>> class MyIntEnum(IntEnum):
...     __str__ = Enum.__str__

enum — 열거형 지원¶

모듈 내용¶

자료형¶

지원되는 __dunder__ 이름¶

지원되는 _sunder_ 이름¶

유틸리티 및 데코레이터¶

참고 사항¶

분실물 보관소

`enum` — 열거형 지원¶

지원되는 `dunder` 이름¶

지원되는 `_sunder_` 이름¶