Enum HOWTO

AnEnum is a set of symbolic names bound to unique values. They aresimilar to global variables, but they offer a more usefulrepr(),grouping, type-safety, and a few other features.

They are most useful when you have a variable that can take one of a limitedselection of values. For example, the days of the week:

>>>fromenumimportEnum>>>classWeekday(Enum):...MONDAY=1...TUESDAY=2...WEDNESDAY=3...THURSDAY=4...FRIDAY=5...SATURDAY=6...SUNDAY=7

Or perhaps the RGB primary colors:

>>>fromenumimportEnum>>>classColor(Enum):...RED=1...GREEN=2...BLUE=3

As you can see, creating anEnum is as simple as writing a class thatinherits fromEnum itself.

Note

Case of Enum Members

Because Enums are used to represent constants, and to help avoid issueswith name clashes between mixin-class methods/attributes and enum names,we strongly recommend using UPPER_CASE names for members, and will be usingthat style in our examples.

Depending on the nature of the enum a member’s value may or may not beimportant, but either way that value can be used to get the correspondingmember:

>>>Weekday(3)<Weekday.WEDNESDAY: 3>

As you can see, therepr() of a member shows the enum name, the member name,and the value. Thestr() of a member shows only the enum name and membername:

>>>print(Weekday.THURSDAY)Weekday.THURSDAY

Thetype of an enumeration member is the enum it belongs to:

>>>type(Weekday.MONDAY)<enum 'Weekday'>>>>isinstance(Weekday.FRIDAY,Weekday)True

Enum members have an attribute that contains just theirname:

>>>print(Weekday.TUESDAY.name)TUESDAY

Likewise, they have an attribute for theirvalue:

>>>Weekday.WEDNESDAY.value3

Unlike many languages that treat enumerations solely as name/value pairs,Python Enums can have behavior added. For example,datetime.datehas two methods for returning the weekday:weekday() andisoweekday().The difference is that one of them counts from 0-6 and the other from 1-7.Rather than keep track of that ourselves we can add a method to theWeekdayenum to extract the day from thedate instance and return the matchingenum member:

@classmethoddeffrom_date(cls,date):returncls(date.isoweekday())

The completeWeekday enum now looks like this:

>>>classWeekday(Enum):...MONDAY=1...TUESDAY=2...WEDNESDAY=3...THURSDAY=4...FRIDAY=5...SATURDAY=6...SUNDAY=7...#...@classmethod...deffrom_date(cls,date):...returncls(date.isoweekday())

Now we can find out what today is! Observe:

>>>fromdatetimeimportdate>>>Weekday.from_date(date.today())<Weekday.TUESDAY: 2>

Of course, if you’re reading this on some other day, you’ll see that day instead.

ThisWeekday enum is great if our variable only needs one day, butwhat if we need several? Maybe we’re writing a function to plot chores duringa week, and don’t want to use alist – we could use a different typeofEnum:

>>>fromenumimportFlag>>>classWeekday(Flag):...MONDAY=1...TUESDAY=2...WEDNESDAY=4...THURSDAY=8...FRIDAY=16...SATURDAY=32...SUNDAY=64

We’ve changed two things: we’re inherited fromFlag, and the values areall powers of 2.

Just like the originalWeekday enum above, we can have a single selection:

>>>first_week_day=Weekday.MONDAY>>>first_week_day<Weekday.MONDAY: 1>

ButFlag also allows us to combine several members into a singlevariable:

>>>weekend=Weekday.SATURDAY|Weekday.SUNDAY>>>weekend<Weekday.SATURDAY|SUNDAY: 96>

You can even iterate over aFlag variable:

>>>fordayinweekend:...print(day)Weekday.SATURDAYWeekday.SUNDAY

Okay, let’s get some chores set up:

>>>chores_for_ethan={...'feed the cat':Weekday.MONDAY|Weekday.WEDNESDAY|Weekday.FRIDAY,...'do the dishes':Weekday.TUESDAY|Weekday.THURSDAY,...'answer SO questions':Weekday.SATURDAY,...}

And a function to display the chores for a given day:

>>>defshow_chores(chores,day):...forchore,daysinchores.items():...ifdayindays:...print(chore)...>>>show_chores(chores_for_ethan,Weekday.SATURDAY)answer SO questions

In cases where the actual values of the members do not matter, you can saveyourself some work and useauto() for the values:

>>>fromenumimportauto>>>classWeekday(Flag):...MONDAY=auto()...TUESDAY=auto()...WEDNESDAY=auto()...THURSDAY=auto()...FRIDAY=auto()...SATURDAY=auto()...SUNDAY=auto()...WEEKEND=SATURDAY|SUNDAY

Programmatic access to enumeration members and their attributes

Sometimes it’s useful to access members in enumerations programmatically (i.e.situations whereColor.RED won’t do because the exact color is not knownat program-writing time).Enum allows such access:

>>>Color(1)<Color.RED: 1>>>>Color(3)<Color.BLUE: 3>

If you want to access enum members byname, use item access:

>>>Color['RED']<Color.RED: 1>>>>Color['GREEN']<Color.GREEN: 2>

If you have an enum member and need itsname orvalue:

>>>member=Color.RED>>>member.name'RED'>>>member.value1

Duplicating enum members and values

Having two enum members with the same name is invalid:

>>>classShape(Enum):...SQUARE=2...SQUARE=3...Traceback (most recent call last):...TypeError:'SQUARE' already defined as 2

However, an enum member can have other names associated with it. Given twoentriesA andB with the same value (andA defined first),Bis an alias for the memberA. By-value lookup of the value ofA willreturn the memberA. By-name lookup ofA will return the memberA.By-name lookup ofB will also return the memberA:

>>>classShape(Enum):...SQUARE=2...DIAMOND=1...CIRCLE=3...ALIAS_FOR_SQUARE=2...>>>Shape.SQUARE<Shape.SQUARE: 2>>>>Shape.ALIAS_FOR_SQUARE<Shape.SQUARE: 2>>>>Shape(2)<Shape.SQUARE: 2>

Note

Attempting to create a member with the same name as an alreadydefined attribute (another member, a method, etc.) or attempting to createan attribute with the same name as a member is not allowed.

Ensuring unique enumeration values

By default, enumerations allow multiple names as aliases for the same value.When this behavior isn’t desired, you can use theunique() decorator:

>>>fromenumimportEnum,unique>>>@unique...classMistake(Enum):...ONE=1...TWO=2...THREE=3...FOUR=3...Traceback (most recent call last):...ValueError:duplicate values found in <enum 'Mistake'>: FOUR -> THREE

Using automatic values

If the exact value is unimportant you can useauto:

>>>fromenumimportEnum,auto>>>classColor(Enum):...RED=auto()...BLUE=auto()...GREEN=auto()...>>>[member.valueformemberinColor][1, 2, 3]

The values are chosen by_generate_next_value_(), which can beoverridden:

>>>classAutoName(Enum):...@staticmethod...def_generate_next_value_(name,start,count,last_values):...returnname...>>>classOrdinal(AutoName):...NORTH=auto()...SOUTH=auto()...EAST=auto()...WEST=auto()...>>>[member.valueformemberinOrdinal]['NORTH', 'SOUTH', 'EAST', 'WEST']

Note

The_generate_next_value_() method must be defined before any members.

Iteration

Iterating over the members of an enum does not provide the aliases:

>>>list(Shape)[<Shape.SQUARE: 2>, <Shape.DIAMOND: 1>, <Shape.CIRCLE: 3>]>>>list(Weekday)[<Weekday.MONDAY: 1>, <Weekday.TUESDAY: 2>, <Weekday.WEDNESDAY: 4>, <Weekday.THURSDAY: 8>, <Weekday.FRIDAY: 16>, <Weekday.SATURDAY: 32>, <Weekday.SUNDAY: 64>]

Note that the aliasesShape.ALIAS_FOR_SQUARE andWeekday.WEEKEND aren’t shown.

The special attribute__members__ is a read-only ordered mapping of namesto members. It includes all names defined in the enumeration, including thealiases:

>>>forname,memberinShape.__members__.items():...name,member...('SQUARE', <Shape.SQUARE: 2>)('DIAMOND', <Shape.DIAMOND: 1>)('CIRCLE', <Shape.CIRCLE: 3>)('ALIAS_FOR_SQUARE', <Shape.SQUARE: 2>)

The__members__ attribute can be used for detailed programmatic access tothe enumeration members. For example, finding all the aliases:

>>>[nameforname,memberinShape.__members__.items()ifmember.name!=name]['ALIAS_FOR_SQUARE']

Note

Aliases for flags include values with multiple flags set, such as3,and no flags set, i.e.0.

Comparisons

Enumeration members are compared by identity:

>>>Color.REDisColor.REDTrue>>>Color.REDisColor.BLUEFalse>>>Color.REDisnotColor.BLUETrue

Ordered comparisons between enumeration values arenot supported. Enummembers are not integers (but seeIntEnum below):

>>>Color.RED<Color.BLUETraceback (most recent call last):  File"<stdin>", line1, in<module>TypeError:'<' not supported between instances of 'Color' and 'Color'

Equality comparisons are defined though:

>>>Color.BLUE==Color.REDFalse>>>Color.BLUE!=Color.REDTrue>>>Color.BLUE==Color.BLUETrue

Comparisons against non-enumeration values will always compare not equal(again,IntEnum was explicitly designed to behave differently, seebelow):

>>>Color.BLUE==2False

Warning

It is possible to reload modules – if a reloaded module containsenums, they will be recreated, and the new members may notcompare identical/equal to the original members.

Allowed members and attributes of enumerations

Most of the examples above use integers for enumeration values. Using integersis short and handy (and provided by default by theFunctional API), but notstrictly enforced. In the vast majority of use-cases, one doesn’t care whatthe actual value of an enumeration is. But if the valueis important,enumerations can have arbitrary values.

Enumerations are Python classes, and can have methods and special methods asusual. If we have this enumeration:

>>>classMood(Enum):...FUNKY=1...HAPPY=3......defdescribe(self):...# self is the member here...returnself.name,self.value......def__str__(self):...return'my custom str!{0}'.format(self.value)......@classmethod...deffavorite_mood(cls):...# cls here is the enumeration...returncls.HAPPY...

Then:

>>>Mood.favorite_mood()<Mood.HAPPY: 3>>>>Mood.HAPPY.describe()('HAPPY', 3)>>>str(Mood.FUNKY)'my custom str! 1'

The rules for what is allowed are as follows: names that start and end witha single underscore are reserved by enum and cannot be used; all otherattributes defined within an enumeration will become members of thisenumeration, with the exception of special methods (__str__(),__add__(), etc.), descriptors (methods are also descriptors), andvariable names listed in_ignore_.

Note: if your enumeration defines__new__() and/or__init__(),any value(s) given to the enum member will be passed into those methods.SeePlanet for an example.

Note

The__new__() method, if defined, is used during creation of the Enummembers; it is then replaced by Enum’s__new__() which is used afterclass creation for lookup of existing members. SeeWhen to use __new__() vs. __init__() formore details.

Restricted Enum subclassing

A newEnum class must have one base enum class, up to one concretedata type, and as manyobject-based mixin classes as needed. Theorder of these base classes is:

classEnumName([mix-in,...,][data-type,]base-enum):pass

Also, subclassing an enumeration is allowed only if the enumeration does not defineany members. So this is forbidden:

>>>classMoreColor(Color):...PINK=17...Traceback (most recent call last):...TypeError:<enum 'MoreColor'> cannot extend <enum 'Color'>

But this is allowed:

>>>classFoo(Enum):...defsome_behavior(self):...pass...>>>classBar(Foo):...HAPPY=1...SAD=2...

Allowing subclassing of enums that define members would lead to a violation ofsome important invariants of types and instances. On the other hand, it makessense to allow sharing some common behavior between a group of enumerations.(SeeOrderedEnum for an example.)

Dataclass support

When inheriting from adataclass,the__repr__() omits the inherited class’ name. For example:

>>>fromdataclassesimportdataclass,field>>>@dataclass...classCreatureDataMixin:...size:str...legs:int...tail:bool=field(repr=False,default=True)...>>>classCreature(CreatureDataMixin,Enum):...BEETLE='small',6...DOG='medium',4...>>>Creature.DOG<Creature.DOG: size='medium', legs=4>

Use thedataclass() argumentrepr=Falseto use the standardrepr().

Changed in version 3.12:Only the dataclass fields are shown in the value area, not the dataclass’name.

Note

Addingdataclass() decorator toEnumand its subclasses is not supported. It will not raise any errors,but it will produce very strange results at runtime, such as membersbeing equal to each other:

>>>@dataclass# don't do this: it does not make any sense...classColor(Enum):...RED=1...BLUE=2...>>>Color.REDisColor.BLUEFalse>>>Color.RED==Color.BLUE# problem is here: they should not be equalTrue

Pickling

Enumerations can be pickled and unpickled:

>>>fromtest.test_enumimportFruit>>>frompickleimportdumps,loads>>>Fruit.TOMATOisloads(dumps(Fruit.TOMATO))True

The usual restrictions for pickling apply: picklable enums must be defined inthe top level of a module, since unpickling requires them to be importablefrom that module.

Note

With pickle protocol version 4 it is possible to easily pickle enumsnested in other classes.

It is possible to modify how enum members are pickled/unpickled by defining__reduce_ex__() in the enumeration class. The default method is by-value,but enums with complicated values may want to use by-name:

>>>importenum>>>classMyEnum(enum.Enum):...__reduce_ex__=enum.pickle_by_enum_name

Note

Using by-name for flags is not recommended, as unnamed aliases willnot unpickle.

Functional API

TheEnum class is callable, providing the following functional API:

>>>Animal=Enum('Animal','ANT BEE CAT DOG')>>>Animal<enum 'Animal'>>>>Animal.ANT<Animal.ANT: 1>>>>list(Animal)[<Animal.ANT: 1>, <Animal.BEE: 2>, <Animal.CAT: 3>, <Animal.DOG: 4>]

The semantics of this API resemblenamedtuple. The firstargument of the call toEnum is the name of the enumeration.

The second argument is thesource of enumeration member names. It can be awhitespace-separated string of names, a sequence of names, a sequence of2-tuples with key/value pairs, or a mapping (e.g. dictionary) of names tovalues. The last two options enable assigning arbitrary values toenumerations; the others auto-assign increasing integers starting with 1 (usethestart parameter to specify a different starting value). Anew class derived fromEnum is returned. In other words, the aboveassignment toAnimal is equivalent to:

>>>classAnimal(Enum):...ANT=1...BEE=2...CAT=3...DOG=4...

The reason for defaulting to1 as the starting number and not0 isthat0 isFalse in a boolean sense, but by default enum members allevaluate toTrue.

Pickling enums created with the functional API can be tricky as frame stackimplementation details are used to try and figure out which module theenumeration is being created in (e.g. it will fail if you use a utilityfunction in a separate module, and also may not work on IronPython or Jython).The solution is to specify the module name explicitly as follows:

>>>Animal=Enum('Animal','ANT BEE CAT DOG',module=__name__)

Warning

Ifmodule is not supplied, and Enum cannot determine what it is,the new Enum members will not be unpicklable; to keep errors closer tothe source, pickling will be disabled.

The new pickle protocol 4 also, in some circumstances, relies on__qualname__ being set to the location where pickle will be ableto find the class. For example, if the class was made available in classSomeData in the global scope:

>>>Animal=Enum('Animal','ANT BEE CAT DOG',qualname='SomeData.Animal')

The complete signature is:

Enum(value='NewEnumName',names=<...>,*,module='...',qualname='...',type=<mixed-inclass>,start=1,)

  • value: What the new enum class will record as its name.

  • names: The enum members. This can be a whitespace- or comma-separated string(values will start at 1 unless otherwise specified):

    'RED GREEN BLUE'|'RED,GREEN,BLUE'|'RED, GREEN, BLUE'

    or an iterator of names:

    ['RED','GREEN','BLUE']

    or an iterator of (name, value) pairs:

    [('CYAN',4),('MAGENTA',5),('YELLOW',6)]

    or a mapping:

    {'CHARTREUSE':7,'SEA_GREEN':11,'ROSEMARY':42}

  • module: name of module where new enum class can be found.

  • qualname: where in module new enum class can be found.

  • type: type to mix in to new enum class.

  • start: number to start counting at if only names are passed in.

Changed in version 3.5:Thestart parameter was added.

Derived Enumerations

IntEnum

The first variation ofEnum that is provided is also a subclass ofint. Members of anIntEnum can be compared to integers;by extension, integer enumerations of different types can also be comparedto each other:

>>>fromenumimportIntEnum>>>classShape(IntEnum):...CIRCLE=1...SQUARE=2...>>>classRequest(IntEnum):...POST=1...GET=2...>>>Shape==1False>>>Shape.CIRCLE==1True>>>Shape.CIRCLE==Request.POSTTrue

However, they still can’t be compared to standardEnum enumerations:

>>>classShape(IntEnum):...CIRCLE=1...SQUARE=2...>>>classColor(Enum):...RED=1...GREEN=2...>>>Shape.CIRCLE==Color.REDFalse

IntEnum values behave like integers in other ways you’d expect:

>>>int(Shape.CIRCLE)1>>>['a','b','c'][Shape.CIRCLE]'b'>>>[iforiinrange(Shape.SQUARE)][0, 1]

StrEnum

The second variation ofEnum that is provided is also a subclass ofstr. Members of aStrEnum can be compared to strings;by extension, string enumerations of different types can also be comparedto each other.

Added in version 3.11.

IntFlag

The next variation ofEnum provided,IntFlag, is also basedonint. The difference beingIntFlag members can be combinedusing the bitwise operators (&, |, ^, ~) and the result is still anIntFlag member, if possible. LikeIntEnum,IntFlagmembers are also integers and can be used wherever anint is used.

Note

Any operation on anIntFlag member besides the bit-wise operations willlose theIntFlag membership.

Bit-wise operations that result in invalidIntFlag values will lose theIntFlag membership. SeeFlagBoundary fordetails.

Added in version 3.6.

Changed in version 3.11.

SampleIntFlag class:

>>>fromenumimportIntFlag>>>classPerm(IntFlag):...R=4...W=2...X=1...>>>Perm.R|Perm.W<Perm.R|W: 6>>>>Perm.R+Perm.W6>>>RW=Perm.R|Perm.W>>>Perm.RinRWTrue

It is also possible to name the combinations:

>>>classPerm(IntFlag):...R=4...W=2...X=1...RWX=7...>>>Perm.RWX<Perm.RWX: 7>>>>~Perm.RWX<Perm: 0>>>>Perm(7)<Perm.RWX: 7>

Note

Named combinations are considered aliases. Aliases do not show up duringiteration, but can be returned from by-value lookups.

Changed in version 3.11.

Another important difference betweenIntFlag andEnum is thatif no flags are set (the value is 0), its boolean evaluation isFalse:

>>>Perm.R&Perm.X<Perm: 0>>>>bool(Perm.R&Perm.X)False

BecauseIntFlag members are also subclasses ofint they canbe combined with them (but may loseIntFlag membership:

>>>Perm.X|4<Perm.R|X: 5>>>>Perm.X+89

Note

The negation operator,~, always returns anIntFlag member with apositive value:

>>>(~Perm.X).value==(Perm.R|Perm.W).value==6True

IntFlag members can also be iterated over:

>>>list(RW)[<Perm.R: 4>, <Perm.W: 2>]

Added in version 3.11.

Flag

The last variation isFlag. LikeIntFlag,Flagmembers can be combined using the bitwise operators (&, |, ^, ~). UnlikeIntFlag, they cannot be combined with, nor compared against, anyotherFlag enumeration, norint. While it is possible tospecify the values directly it is recommended to useauto as thevalue and letFlag select an appropriate value.

Added in version 3.6.

LikeIntFlag, if a combination ofFlag members results in noflags being set, the boolean evaluation isFalse:

>>>fromenumimportFlag,auto>>>classColor(Flag):...RED=auto()...BLUE=auto()...GREEN=auto()...>>>Color.RED&Color.GREEN<Color: 0>>>>bool(Color.RED&Color.GREEN)False

Individual flags should have values that are powers of two (1, 2, 4, 8, …),while combinations of flags will not:

>>>classColor(Flag):...RED=auto()...BLUE=auto()...GREEN=auto()...WHITE=RED|BLUE|GREEN...>>>Color.WHITE<Color.WHITE: 7>

Giving a name to the “no flags set” condition does not change its booleanvalue:

>>>classColor(Flag):...BLACK=0...RED=auto()...BLUE=auto()...GREEN=auto()...>>>Color.BLACK<Color.BLACK: 0>>>>bool(Color.BLACK)False

Flag members can also be iterated over:

>>>purple=Color.RED|Color.BLUE>>>list(purple)[<Color.RED: 1>, <Color.BLUE: 2>]

Added in version 3.11.

Note

For the majority of new code,Enum andFlag are stronglyrecommended, sinceIntEnum andIntFlag break somesemantic promises of an enumeration (by being comparable to integers, andthus by transitivity to other unrelated enumerations).IntEnumandIntFlag should be used only in cases whereEnum andFlag will not do; for example, when integer constants are replacedwith enumerations, or for interoperability with other systems.

Others

WhileIntEnum is part of theenum module, it would be verysimple to implement independently:

classIntEnum(int,ReprEnum):# or Enum instead of ReprEnumpass

This demonstrates how similar derived enumerations can be defined; for exampleaFloatEnum that mixes infloat instead ofint.

Some rules:

  1. When subclassingEnum, mix-in types must appear before theEnum class itself in the sequence of bases, as in theIntEnumexample above.

  2. Mix-in types must be subclassable. For example,bool andrange are not subclassable and will throw an error during Enumcreation if used as the mix-in type.

  3. WhileEnum can have members of any type, once you mix in anadditional type, all the members must have values of that type, e.g.int above. This restriction does not apply to mix-ins which onlyadd methods and don’t specify another type.

  4. When another data type is mixed in, thevalue attribute isnot thesame as the enum member itself, although it is equivalent and will compareequal.

  5. Adatatype is a mixin that defines__new__(), or adataclass

  6. %-style formatting:%s and%r call theEnum class’s__str__() and__repr__() respectively; other codes (such as%i or%h for IntEnum) treat the enum member as its mixed-in type.

  7. Formatted string literals,str.format(),andformat() will use the enum’s__str__() method.

Note

BecauseIntEnum,IntFlag, andStrEnum aredesigned to be drop-in replacements for existing constants, their__str__() method has been reset to their data types’__str__() method.

When to use__new__() vs.__init__()

__new__() must be used whenever you want to customize the actual value oftheEnum member. Any other modifications may go in either__new__() or__init__(), with__init__() being preferred.

For example, if you want to pass several items to the constructor, but onlywant one of them to be the value:

>>>classCoordinate(bytes,Enum):..."""...    Coordinate with binary codes that can be indexed by the int code....    """...def__new__(cls,value,label,unit):...obj=bytes.__new__(cls,[value])...obj._value_=value...obj.label=label...obj.unit=unit...returnobj...PX=(0,'P.X','km')...PY=(1,'P.Y','km')...VX=(2,'V.X','km/s')...VY=(3,'V.Y','km/s')...>>>print(Coordinate['PY'])Coordinate.PY>>>print(Coordinate(3))Coordinate.VY

Warning

Do not callsuper().__new__(), as the lookup-only__new__ is the onethat is found; instead, use the data type directly.

Finer Points

Supported__dunder__ names

__members__ is a read-only ordered mapping ofmember_name:memberitems. It is only available on the class.

__new__(), if specified, must create and return the enum members; it isalso a very good idea to set the member’s_value_ appropriately. Onceall the members are created it is no longer used.

Supported_sunder_ names

  • _name_ – name of the member

  • _value_ – value of the member; can be set in__new__

  • _missing_() – a lookup function used when a value is not found;may be overridden

  • _ignore_ – a list of names, either as alist or astr, that will not be transformed into members, and will be removedfrom the final class

  • _generate_next_value_() – used to get an appropriate value foran enum member; may be overridden

  • _add_alias_() – adds a new name as an alias to an existingmember.

  • _add_value_alias_() – adds a new value as an alias to anexisting member. SeeMultiValueEnum for an example.

    Note

    For standardEnum classes the next value chosen is the highestvalue seen incremented by one.

    ForFlag classes the next value chosen will be the next highestpower-of-two.

    Changed in version 3.13:Prior versions would use the last seen value instead of the highest value.

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_

To help keep Python 2 / Python 3 code in sync an_order_ attribute canbe provided. It will be checked against the actual order of the enumerationand raise an error if the two do not match:

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

Note

In Python 2 code the_order_ attribute is necessary as definitionorder is lost before it can be recorded.

_Private__names

Private names are not converted to enum members,but remain normal attributes.

Changed in version 3.11.

Enum member type

Enum members are instances of their enum class, and are normally accessed asEnumClass.member. In certain situations, such as writing custom enumbehavior, being able to access one member directly from another is useful,and is supported; however, in order to avoid name clashes between member namesand attributes/methods from mixed-in classes, upper-case names are stronglyrecommended.

Changed in version 3.5.

Creating members that are mixed with other data types

When subclassing other data types, such asint orstr, withanEnum, all values after the= are passed to that data type’sconstructor. For example:

>>>classMyEnum(IntEnum):# help(int) -> int(x, base=10) -> integer...example='11',16# so x='11' and base=16...>>>MyEnum.example.value# and hex(11) is...17

Boolean value ofEnum classes and members

Enum classes that are mixed with non-Enum types (such asint,str, etc.) are evaluated according to the mixed-intype’s rules; otherwise, all members evaluate asTrue. To make yourown enum’s boolean evaluation depend on the member’s value add the following toyour class:

def__bool__(self):returnbool(self.value)

PlainEnum classes always evaluate asTrue.

Enum classes with methods

If you give your enum subclass extra methods, like thePlanetclass below, those methods will show up in adir() of the member,but not of the class:

>>>dir(Planet)['EARTH', 'JUPITER', 'MARS', 'MERCURY', 'NEPTUNE', 'SATURN', 'URANUS', 'VENUS', '__class__', '__doc__', '__members__', '__module__']>>>dir(Planet.EARTH)['__class__', '__doc__', '__module__', 'mass', 'name', 'radius', 'surface_gravity', 'value']

Combining members ofFlag

Iterating over a combination ofFlag members will only return the members thatare comprised of a single bit:

>>>classColor(Flag):...RED=auto()...GREEN=auto()...BLUE=auto()...MAGENTA=RED|BLUE...YELLOW=RED|GREEN...CYAN=GREEN|BLUE...>>>Color(3)# named combination<Color.YELLOW: 3>>>>Color(7)# not named combination<Color.RED|GREEN|BLUE: 7>

Flag andIntFlag minutia

Using the following snippet for our examples:

>>>classColor(IntFlag):...BLACK=0...RED=1...GREEN=2...BLUE=4...PURPLE=RED|BLUE...WHITE=RED|GREEN|BLUE...

the following are true:

  • single-bit flags are canonical

  • multi-bit and zero-bit flags are aliases

  • only canonical flags are returned during iteration:

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

  • negating a flag or flag set returns a new flag/flag set with thecorresponding positive integer value:

    >>>Color.BLUE<Color.BLUE: 4>>>>~Color.BLUE<Color.RED|GREEN: 3>

  • names of pseudo-flags are constructed from their members’ names:

    >>>(Color.RED|Color.GREEN).name'RED|GREEN'>>>classPerm(IntFlag):...R=4...W=2...X=1...>>>(Perm.R&Perm.W).nameisNone# effectively Perm(0)True

  • multi-bit flags, aka aliases, can be returned from operations:

    >>>Color.RED|Color.BLUE<Color.PURPLE: 5>>>>Color(7)# or Color(-1)<Color.WHITE: 7>>>>Color(0)<Color.BLACK: 0>

  • membership / containment checking: zero-valued flags are always consideredto be contained:

    >>>Color.BLACKinColor.WHITETrue

    otherwise, only if all bits of one flag are in the other flag will Truebe returned:

    >>>Color.PURPLEinColor.WHITETrue>>>Color.GREENinColor.PURPLEFalse

There is a new boundary mechanism that controls how out-of-range / invalidbits are handled:STRICT,CONFORM,EJECT, andKEEP:

  • STRICT –> raises an exception when presented with invalid values

  • CONFORM –> discards any invalid bits

  • EJECT –> lose Flag status and become a normal int with the given value

  • KEEP –> keep the extra bits

    • keeps Flag status and extra bits

    • extra bits do not show up in iteration

    • extra bits do show up in repr() and str()

The default for Flag isSTRICT, the default forIntFlag isEJECT,and the default for_convert_ isKEEP (seessl.Options for anexample of whenKEEP is needed).

How are Enums and Flags different?

Enums have a custom metaclass that affects many aspects of both derivedEnumclasses and their instances (members).

Enum Classes

TheEnumType metaclass is responsible for providing the__contains__(),__dir__(),__iter__() and other methods thatallow one to do things with anEnum class that fail on a typicalclass, such aslist(Color) orsome_enum_varinColor.EnumType isresponsible for ensuring that various other methods on the finalEnumclass are correct (such as__new__(),__getnewargs__(),__str__() and__repr__()).

Flag Classes

Flags have an expanded view of aliasing: to be canonical, the value of a flagneeds to be a power-of-two value, and not a duplicate name. So, in addition to theEnum definition of alias, a flag with no value (a.k.a.0) or with more than onepower-of-two value (e.g.3) is considered an alias.

Enum Members (aka instances)

The most interesting thing about enum members is that they are singletons.EnumType creates them all while it is creating the enum class itself,and then puts a custom__new__() in place to ensure that no new ones areever instantiated by returning only the existing member instances.

Flag Members

Flag members can be iterated over just like theFlag class, and only thecanonical members will be returned. For example:

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

(Note thatBLACK,PURPLE, andWHITE do not show up.)

Inverting a flag member returns the corresponding positive value,rather than a negative value — for example:

>>>~Color.RED<Color.GREEN|BLUE: 6>

Flag members have a length corresponding to the number of power-of-two valuesthey contain. For example:

>>>len(Color.PURPLE)2

Enum Cookbook

WhileEnum,IntEnum,StrEnum,Flag, andIntFlag are expected to cover the majority of use-cases, they cannotcover them all. Here are recipes for some different types of enumerationsthat can be used directly, or as examples for creating one’s own.

Omitting values

In many use-cases, one doesn’t care what the actual value of an enumerationis. There are several ways to define this type of simple enumeration:

  • use instances ofauto for the value

  • use instances ofobject as the value

  • use a descriptive string as the value

  • use a tuple as the value and a custom__new__() to replace thetuple with anint value

Using any of these methods signifies to the user that these values are notimportant, and also enables one to add, remove, or reorder members withouthaving to renumber the remaining members.

Usingauto

Usingauto would look like:

>>>classColor(Enum):...RED=auto()...BLUE=auto()...GREEN=auto()...>>>Color.GREEN<Color.GREEN: 3>

Usingobject

Usingobject would look like:

>>>classColor(Enum):...RED=object()...GREEN=object()...BLUE=object()...>>>Color.GREEN<Color.GREEN: <object object at 0x...>>

This is also a good example of why you might want to write your own__repr__():

>>>classColor(Enum):...RED=object()...GREEN=object()...BLUE=object()...def__repr__(self):...return"<%s.%s>"%(self.__class__.__name__,self._name_)...>>>Color.GREEN<Color.GREEN>

Using a descriptive string

Using a string as the value would look like:

>>>classColor(Enum):...RED='stop'...GREEN='go'...BLUE='too fast!'...>>>Color.GREEN<Color.GREEN: 'go'>

Using a custom__new__()

Using an auto-numbering__new__() would look like:

>>>classAutoNumber(Enum):...def__new__(cls):...value=len(cls.__members__)+1...obj=object.__new__(cls)...obj._value_=value...returnobj...>>>classColor(AutoNumber):...RED=()...GREEN=()...BLUE=()...>>>Color.GREEN<Color.GREEN: 2>

To make a more general purposeAutoNumber, add*args to the signature:

>>>classAutoNumber(Enum):...def__new__(cls,*args):# this is the only change from above...value=len(cls.__members__)+1...obj=object.__new__(cls)...obj._value_=value...returnobj...

Then when you inherit fromAutoNumber you can write your own__init__to handle any extra arguments:

>>>classSwatch(AutoNumber):...def__init__(self,pantone='unknown'):...self.pantone=pantone...AUBURN='3497'...SEA_GREEN='1246'...BLEACHED_CORAL=()# New color, no Pantone code yet!...>>>Swatch.SEA_GREEN<Swatch.SEA_GREEN: 2>>>>Swatch.SEA_GREEN.pantone'1246'>>>Swatch.BLEACHED_CORAL.pantone'unknown'

Note

The__new__() method, if defined, is used during creation of the Enummembers; it is then replaced by Enum’s__new__() which is used afterclass creation for lookup of existing members.

Warning

Do not callsuper().__new__(), as the lookup-only__new__ is the onethat is found; instead, use the data type directly – e.g.:

obj=int.__new__(cls,value)

OrderedEnum

An ordered enumeration that is not based onIntEnum and so maintainsthe normalEnum invariants (such as not being comparable to otherenumerations):

>>>classOrderedEnum(Enum):...def__ge__(self,other):...ifself.__class__isother.__class__:...returnself.value>=other.value...returnNotImplemented...def__gt__(self,other):...ifself.__class__isother.__class__:...returnself.value>other.value...returnNotImplemented...def__le__(self,other):...ifself.__class__isother.__class__:...returnself.value<=other.value...returnNotImplemented...def__lt__(self,other):...ifself.__class__isother.__class__:...returnself.value<other.value...returnNotImplemented...>>>classGrade(OrderedEnum):...A=5...B=4...C=3...D=2...F=1...>>>Grade.C<Grade.ATrue

DuplicateFreeEnum

Raises an error if a duplicate member value is found instead of creating analias:

>>>classDuplicateFreeEnum(Enum):...def__init__(self,*args):...cls=self.__class__...ifany(self.value==e.valueforeincls):...a=self.name...e=cls(self.value).name...raiseValueError(..."aliases not allowed in DuplicateFreeEnum:%r -->%r"...%(a,e))...>>>classColor(DuplicateFreeEnum):...RED=1...GREEN=2...BLUE=3...GRENE=2...Traceback (most recent call last):...ValueError:aliases not allowed in DuplicateFreeEnum:  'GRENE' --> 'GREEN'

Note

This is a useful example for subclassing Enum to add or change otherbehaviors as well as disallowing aliases. If the only desired change isdisallowing aliases, theunique() decorator can be used instead.

MultiValueEnum

Supports having more than one value per member:

>>>classMultiValueEnum(Enum):...def__new__(cls,value,*values):...self=object.__new__(cls)...self._value_=value...forvinvalues:...self._add_value_alias_(v)...returnself...>>>classDType(MultiValueEnum):...float32='f',8...double64='d',9...>>>DType('f')<DType.float32: 'f'>>>>DType(9)<DType.double64: 'd'>

Planet

If__new__() or__init__() is defined, the value of the enum memberwill be passed to those methods:

>>>classPlanet(Enum):...MERCURY=(3.303e+23,2.4397e6)...VENUS=(4.869e+24,6.0518e6)...EARTH=(5.976e+24,6.37814e6)...MARS=(6.421e+23,3.3972e6)...JUPITER=(1.9e+27,7.1492e7)...SATURN=(5.688e+26,6.0268e7)...URANUS=(8.686e+25,2.5559e7)...NEPTUNE=(1.024e+26,2.4746e7)...def__init__(self,mass,radius):...self.mass=mass# in kilograms...self.radius=radius# in meters...@property...defsurface_gravity(self):...# universal gravitational constant  (m3 kg-1 s-2)...G=6.67300E-11...returnG*self.mass/(self.radius*self.radius)...>>>Planet.EARTH.value(5.976e+24, 6378140.0)>>>Planet.EARTH.surface_gravity9.802652743337129

TimePeriod

An example to show the_ignore_ attribute in use:

>>>fromdatetimeimporttimedelta>>>classPeriod(timedelta,Enum):..."different lengths of time"..._ignore_='Period i'...Period=vars()...foriinrange(367):...Period['day_%d'%i]=i...>>>list(Period)[:2][<Period.day_0: datetime.timedelta(0)>, <Period.day_1: datetime.timedelta(days=1)>]>>>list(Period)[-2:][<Period.day_365: datetime.timedelta(days=365)>, <Period.day_366: datetime.timedelta(days=366)>]

Subclassing EnumType

While most enum needs can be met by customizingEnum subclasses,either with class decorators or custom functions,EnumType can besubclassed to provide a different Enum experience.