`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, 및 IntFlag 가 믹스인된 타입의 str() 를 유지하는 데 사용됩니다.

EnumCheck

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

FlagBoundary

열거형에서 유효하지 않은 값을 처리하는 방식을 더 세밀하게 제어할 수 있도록 하는 STRICT, CONFORM, EJECT, 및 KEEP 값을 가진 열거형입니다.

EnumDict

EnumType 을 서브클래스할 때 사용하는 dict 의 서브클래스입니다.

auto

인스턴스는 Enum 멤버에 적합한 값으로 대체됩니다. StrEnum 은 기본적으로 멤버 이름의 소문자 버전으로 설정되며, 다른 Enum들은 기본적으로 1로 설정되고 그 이후부터 값이 증가합니다.

@~enum.property

Enum 멤버가 멤버 이름과 충돌하지 않으면서 속성을 가질 수 있게 합니다. value 및 name 속성이 이 방식으로 구현되었습니다.

@unique

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

@verify

열거형에 대한 사용자가 선택 가능한 제약 조건을 확인하는 Enum 클래스 데코레이터입니다.

@member

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

@nonmember

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

@global_enum

열거형의 멤버가 클래스가 아닌 모듈에 속하는 것으로 표시되도록 열거형의 str() 및 repr() 을 수정하고, 열거형 멤버를 전역 네임스페이스로 내보냅니다.

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__() 메서드를 설정하고, 열거형 멤버 생성, 중복 처리, 열거형 클래스 순회 제공, 이름 또는 값을 통한 멤버 표현의 표준 방식 제공 등을 담당합니다.

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:

The first integer value for the Enum (used by auto).

boundary:

비트 연산 시 범위 밖의 값을 처리하는 방법입니다(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 이전에는 포함 여부 확인 시 열거형 멤버가 아닌 것이 사용되면 TypeError 가 발생했습니다.

__dir__(cls)¶

['__class__', '__doc__', '__members__', '__module__'] 와 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)¶

name 과 일치하는 cls 의 열거형 멤버를 반환하거나, 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, list 또는 가변적인 dataclass 와 같은 가변/해시 불가 값이 사용될 수는 있지만, 이 경우 열거형 내 전체 가변/해시 불가 값의 수에 비례하여 생성 시 성능이 이차 함수적으로 저하됩니다.

_name_¶: 멤버의 이름.

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

_order_¶

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

Python 2 / Python 3 코드를 동기화 상태로 유지하기 위해 _order_ 속성을 제공할 수 있습니다. 이 속성은 실제 열거형 순서와 비교되며, 일치하지 않으면 오류를 발생시킵니다:

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

참고

Python 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 클래스의 경우, 선택되는 다음 값은 발견된 가장 높은 값에 1을 더한 것입니다.

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 호출에 사용되는 문자열을 반환합니다. 기본적으로는 __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에서 변경: Dataclass 지원 이(가) 추가되었습니다.

_add_alias_()¶

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

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

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

Added in version 3.13.

_add_value_alias_()¶

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

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

해당 값이 이미 다른 멤버와 연결되어 있으면 ValueError 를 발생시킵니다.

예제는 MultiValueEnum 을 참조하십시오.

Added in version 3.13.

class enum.IntEnum¶

IntEnum 은 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 은 Enum 과 동일하지만, 멤버가 문자열이기도 하므로 문자를 사용할 수 있는 대부분의 위치에서 사용될 수 있습니다. StrEnum 멤버에 대해 또는 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'

참고

표준 라이브러리에는 str 의 하위 클래스가 아닌 정확한 str 을 확인하는 곳이 있습니다 (즉, isinstance(unknown, str) 대신 type(unknown) == str 을 사용하는 경우). 이러한 위치에서는 str(MyStrEnum.MY_MEMBER) 를 사용해야 합니다.

참고

StrEnum 에서 auto 를 사용하면 소문자로 변환된 멤버 이름이 값으로 설정됩니다.

참고

__str__`은 *기존 상수의 교체* 활용 사례를 더 잘 지원하기 위해 :meth:()!str.__str__`입니다. __format__`도 동일한 이유로 :meth:()!str.__format__`입니다.

Added in version 3.11.

class enum.Flag¶

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

플래그 내의 멤버 수를 반환합니다:

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

Added in version 3.11.

__bool__(self)¶

플래그에 어떤 멤버라도 포함되어 있으면 True, 그렇지 않으면 False 를 반환합니다:

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

__or__(self, other)¶

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

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

type(self) 에 존재하지만 self 에는 포함되지 않은 모든 플래그를 반환합니다:

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

_numeric_repr_()¶: 남은 이름 없는 숫자 값을 포맷하는 데 사용되는 함수입니다. 기본값은 해당 값의 repr이며, 일반적으로는 hex() 또는 oct() 를 선택합니다.

참고

Flag 에서 auto 를 사용하면 1 부터 시작하여 2의 거듭제곱인 정수가 생성됩니다.

버전 3.11에서 변경: 값이 0인 플래그의 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인 플래그의 repr() 이 변경되었습니다. 현재는 다음과 같습니다:

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

참고

IntFlag 에서 auto 를 사용하면 1 부터 시작하여 2의 거듭제곱인 정수가 생성됩니다.

IntFlag 의 반전(Inversion) 결과가 이제 음수 대신 주어진 플래그에 포함되지 않은 모든 플래그의 합집합인 양수 값을 반환합니다. 이는 기존 Flag 의 동작과 일치합니다.

class enum.ReprEnum¶

ReprEnum 은 Enum 의 repr() 를 사용하지만, 혼합된 데이터 타입의 str() 을 사용합니다.

IntEnum 및 IntFlag`에 대한 :meth:!int.__str__`
StrEnum`에 대한 :meth:!str.__str__`

Enum 기본값인 str() 대신 혼합된 데이터 타입의 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¶

플래그 그룹이나 마스크가 이름이 있는 플래그만 포함하도록 보장합니다. 이는 값이 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¶

범위를 벗어난 값은 ValueError 를 발생시킵니다. 이는 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 멤버십을 잃고 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 멤버십도 유지됩니다. 이는 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 항목의 읽기 전용 순서 있는 매핑입니다. 클래스에서만 이용할 수 있습니다.

지정될 경우, __new__() 은 열거형 멤버를 생성하고 반환해야 하며, 멤버의 _value_ 를 적절하게 설정하는 것도 좋습니다. 모든 멤버가 생성된 후에는 더 이상 사용되지 않습니다.

지원되는 `_sunder_` 이름¶

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

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 인스턴스>, -3]``이 ``THIRD 열거형 멤버를 생성하는 데 사용됨)

버전 3.11.1에서 변경: 이전 버전에서는 auto() 가 정상적으로 작동하려면 할당 줄에 유일한 요소여야 했습니다.

_generate_next_value_ 를 재정의하여 auto 에 사용되는 값을 사용자 정의할 수 있습니다.

참고

버전 3.13부터 기본 _generate_next_value_ 는 항상 가장 높은 멤버 값에 1을 더한 값을 반환하며, 어떤 멤버가 호환되지 않는 타입인 경우 실패합니다.

@enum.property¶: 내장된 @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 데코레이터입니다. 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() 을 변경하는 데코레이터입니다. 열거형 멤버를 모듈의 전역 네임스페이스로 내보낼 때만 사용해야 합니다(예제는 re.RegexFlag 참조).

Added in version 3.11.

enum.show_flag_values(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 타입을 혼합하여 고유의 베이스 클래스를 생성하거나:
>>> 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_` 이름¶