Why You Should Use More Enums In Python

Iterating Over the Members of an Enum¶

Enumerations have a special attribute called __members__, which is a read-only ordered mapping of names and members. Utilising __members__ allows you to iterate over an enum and print the members as well as their corresponding names.

# iterate.py

from enum import Enum


class Colour(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3


for name, member in Colour.__members__.items():
    print(name, member)

$ python iterate.py
RED Colour.RED
GREEN Colour.GREEN
BLUE Colour.BLUE

You might ask yourself why we did not something like:

for member in Colour:
    print(member.name, member)

For the example at hand, both approaches produce the same result. However, if you have an enumeration that has aliases, too, only the approach using __members__ will print the aliases as well. Checkout the following example:

# iterate_alias.py

from enum import Enum


class Colour(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3
    ALIAS_RED = 1


for name, member in Colour.__members__.items():
    print(name, member)

print("="*20)

for member in Colour:
    print(member.name, member)

$ python iterate_alias.py
RED Colour.RED
GREEN Colour.GREEN
BLUE Colour.BLUE
ALIAS_RED Colour.RED
====================
RED Colour.RED
GREEN Colour.GREEN
BLUE Colour.BLUE

Automatic Values¶

In the previous example, we assigned integers to the symbolic names RED, GREEN, and BLUE. If the exact values are not important, you can use the enum.auto() function. The function calls _generate_next_value_() internally and generates the values for you.

# auto.py

from enum import auto
from enum import Enum


class Colour(Enum):
    RED = auto()
    GREEN = auto()
    BLUE = auto()


c = Colour.RED
print(c.value)

It chooses a suited value for each enum member, which will (most of the time) be the integers we used before.

$ python auto.py
1

However, the _generate_next_value_() function can be overwritten to generate new values the way you like:

# overwritten_next_values.py

from enum import auto
from enum import Enum


class AutoName(Enum):
    def _generate_next_value_(name, start, count, last_values):
        if len(last_values) > 0:
            return last_values[-1] * 2
        return 2


class Colour(AutoName):
    RED = auto()
    GREEN = auto()
    BLUE = auto()


c = Colour.RED
g = Colour.GREEN
b = Colour.BLUE
print(c.value)
print(g.value)
print(b.value)

$ python overwritte_next_values.py
2
4
8

Extending an Enum¶

Being Python classes, enums can have any (special) methods just like all other classes. Consider the following example.

# extending.py

from enum import Enum


class Colour(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

    def __str__(self):
        return self.name

    def colorize(self):
        return f"Let's paint everything in {self.name.lower()}"


c = Colour.RED
print(c)
print(c.colorize())

We extended the Colour enum by a new method colorize() printing a string generated based on the member's value. Furthermore, we overwrite the __str__() dunder method to return the member's name if called.

$ python extending.py
RED
Let's paint everything in red

IntEnum¶

We already know that we can compare enum members using Python's identity operator. However, the Enum class does not provide ordered comparisons even though integers are used as values for the enumeration members. Let's have a look at the following example.

# comparison.py

from enum import Enum


class Colour(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3


r = Colour.RED
b = Colour.GREEN
print(r < b)

Executing the script at hand results in a TypeError.

$ python comparison.py
Traceback (most recent call last):
  File "/home/florian/workspace/python/why-you-should-use-more-enums-in-python-article-snippets/comparison.py", line 14, in <module>
    print(r < b)
TypeError: '<' not supported between instances of 'Colour' and 'Colour'

The only thing you can do is making use of equality comparisons like == and !=. Additionally, comparing enum members with any non-enumeration value is not supported.

However, the derived enumeration IntEnum does provide ordered comparisons as it is also a subclass of int. In order to make our example work, we need to import the IntEnum class instead of Enum and derive Colour from it. We do not need to change anything else.

# comparison.py

from enum import IntEnum


class Colour(IntEnum):
    ...

$ python comparison.py
True

IntFlag¶

The IntFlag class is pretty similar to the IntEnum class with the exception that is also supports bitwise operations. With supporting bitwise operations I mean that it is possible to combine two enum members resulting in an IntFlag member, too. All other operations on an IntFlag member will result in the loss of the IntFlag membership.

Let's have a look at an example. Assume that we grant permissions to users so that they can read, write and/or execute a certain file. We create an enumeration Permission with the members R (read permission), W (write permission), and X (execute permission) respectively.

If we have a user, who should have read and write permissions for a certain file, we can combine both using the | operator.

# permissions.py

from enum import IntFlag


class Permission(IntFlag):
    R = 4
    W = 2
    X = 1


RW = Permission.R | Permission.W
print(RW)
print(Permission.R + Permission.W)
print(Permission.R in RW)

$ python permissions.py
Permissions.R|W
6
True

Flag¶

The Flag class does also provide support for bitwise operations but does not inherit from int. In fact, it is like Enum but with support for the bitwise operations.

If we take the Colour enum from the beginning, we could easily mix the colour white based on the other three colours.

# colour_flag.py

from enum import auto
from enum import Flag


class Colour(Flag):
    RED = auto()
    GREEN = auto()
    BLUE = auto()
    WHITE = RED | GREEN | BLUE


print(Colour.WHITE.name, Colour.WHITE.value)

$ python colour_flag.py
WHITE 7