"enum" --- 열거형 지원
**********************

Added in version 3.4.

**소스 코드:** 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

======================================================================

열거형은:

* is a set of symbolic names (members) bound to unique values

* can be iterated over to return its canonical (i.e. non-alias)
  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 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"

      The "type" for Enum and its subclasses.

   "Enum"

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

   "IntEnum"

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

   "StrEnum"

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

   "Flag"

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

   "IntFlag"

      "IntFlag" 멤버십을 잃지 않고 비트 연산자를 사용하여 결합할 수 있
      는 열거형 상수를 만들기 위한 베이스 클래스. "IntFlag" 멤버도
      "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.

   "EnumDict"

      A subclass of "dict" for use when subclassing "EnumType".

   "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.  The "value" and "name" attributes are
      implemented this way.

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

   "enum.bin()"

      Like built-in "bin()", except negative values are represented in
      two's complement, and the leading bit always indicates sign ("0"
      implies positive, "1" implies negative).

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"

======================================================================


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.

   Added in version 3.11: Before 3.11 "EnumType" was called
   "EnumMeta", which is still available as an alias.

   __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 (only if the
        existing enum does not have any members):

           cls:
              The enum class being called.

           value:
              The name of the new Enum to create.

           names:
              The names/values of the members for the new Enum.

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

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

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

   __contains__(cls, member)

      Returns "True" if member belongs to the "cls":

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

      버전 3.12에서 변경: Before Python 3.12, a "TypeError" is 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__']

   __getitem__(cls, name)

      Returns the Enum member in *cls* matching *name*, or raises a
      "KeyError":

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

   __iter__(cls)

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

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

   __len__(cls)

      Returns the number of member in *cls*:

         >>> len(Color)
         3

   __members__

      Returns a mapping of every enum name to its member, including
      aliases

   __reversed__(cls)

      Returns each member in *cls* in reverse definition order:

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

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

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

      참고:

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

      멤버의 이름.

   _value_

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

   _order_

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

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

   __dir__(self)

      Returns "['__class__', '__doc__', '__module__', 'name',
      'value']" and any public methods defined on *self.__class__*:

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

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

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

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

      참고:

        When writing a custom "__new__", do not use "super().__new__"
        -- call the appropriate "__new__" instead.

   __repr__(self)

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

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

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

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

      Returns the string used for *format()* and *f-string* calls.  By
      default, returns "__str__()" return value, but can be
      overridden:

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

   참고:

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

   버전 3.12에서 변경: Added Dataclass support

   _add_alias_()

      Adds a new name as an alias to an existing member:

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

      Raises a "NameError" if the name is already assigned to a
      different member.

      Added in version 3.13.

   _add_value_alias_()

      Adds a new value as an alias to an existing member:

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

      Raises a "ValueError" if the value is already linked with a
      different member.

      Added in version 3.13.

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

   참고:

     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.

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

   참고:

     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(MyStrEnum.MY_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.

   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 operations are (aliases of) 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 non-alias members:

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

      Added in version 3.11.

   __len__(self):

      Returns number of members in flag:

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

      Added in version 3.11.

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

   __and__(self, other)

      Returns current flag binary and'ed with other:

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

   __xor__(self, other)

      Returns current flag binary xor'ed with other:

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

   __invert__(self):

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

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

   _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)
   <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: 0>
   >>> Color.RED | 2
   <Color.RED|GREEN: 3>

   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)
      <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.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* 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 <enum 'Color'>: 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.

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

      Out-of-range values have invalid values removed, leaving a valid
      "Flag" value:

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

class enum.EnumDict

   *EnumDict* is a subclass of "dict" that is used as the namespace
   for defining enum classes (see 클래스 이름 공간 준비하기). It is
   exposed to allow subclasses of "EnumType" with advanced behavior
   like having multiple values per member. It should be called with
   the name of the enum class being created, otherwise private names
   and internal classes will not be handled correctly.

   Note that only the "MutableMapping" interface ("__setitem__()" and
   "update()") is overridden. It may be possible to bypass the checks
   using other "dict" operations like "|=".

   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_()" -- 열거형 멤버에 대한 적절한 값을 얻기 위
  해 사용합니다; 재정의할 수 있습니다

  참고:

    For standard "Enum" classes the next value chosen is the highest
    value seen incremented by one.For "Flag" classes the next value
    chosen will be the next highest power-of-two.

* "_add_alias_()" -- adds a new name as an alias to an existing
  member.

* "_add_value_alias_()" -- adds a new value as an alias to an existing
  member.

* While "_sunder_" names are generally reserved for the further
  development of the "Enum" class and can not be used, some are
  explicitly allowed:

  * "_repr_*" (e.g. "_repr_html_"), as used in 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_*"

======================================================================


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 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, either by itself or as part of a tuple:

   * "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)

   버전 3.11.1에서 변경: In prior versions, "auto()" had to be the
   only thing on the assignment line to work properly.

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

   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

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

   Added in version 3.11.

@enum.member

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

   Added in version 3.11.

@enum.nonmember

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

   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.

enum.bin(num, max_bits=None)

   Like built-in "bin()", except negative values are represented in
   two's complement, and the leading bit always indicates sign ("0"
   implies positive, "1" implies negative).

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

   Added in version 3.10.

======================================================================


참고 사항
=========

"IntEnum", "StrEnum", 및 "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 Enum, IntEnum
      >>> class MyIntEnum(IntEnum):
      ...     __str__ = Enum.__str__
