XQA
Back to Python
2026-03-028 min read

Python - Enums

Learn Python - Enums step by step with clear examples and exercises.

Title: Python - Enums: A full guide for Practical Programming

Why This Matters

Enums, or enumerations, are a powerful tool in Python that allows you to create user-defined data types consisting of a set of named values. They help improve code readability and maintainability by providing a clear, consistent naming convention for related constants. Understanding enums is crucial for writing cleaner, more efficient code, especially in large projects where maintaining consistency across multiple files can be challenging.

Enums offer several advantages:

  • Improved code readability due to the use of meaningful names for related constants.
  • Reduced chances of errors caused by misusing or misspelling constant names.
  • Easier maintenance, as changes to a set of related constants can be made in one place without affecting other parts of the code.

Prerequisites

Before diving into the world of Python enums, it's essential to have a good understanding of:

  1. Basic Python syntax and data types (strings, integers, lists, etc.)
  2. Functions and methods
  3. Classes and objects
  4. Understanding the difference between built-in constants and user-defined constants
  5. Familiarity with control flow structures such as if, elif, and else statements
  6. Knowledge of Python's built-in data types like tuples, sets, and dictionaries
  7. Comprehension of classes and inheritance
  8. Understanding the concept of scope in Python
  9. Familiarity with exception handling
  10. Experience working with modules and packages

Core Concept

Enums in Python are created using the enum.Enum class from the standard library's enum module. To use enums, you first need to import the enum module:

import enum

Next, you can define your own enumeration by creating a class that inherits from the built-in enum.Enum class:

class TrafficLightColors(enum.Enum):
RED = 1
YELLOW = 2
GREEN = 3

In this example, we've created an enum called TrafficLightColors with three named values: RED, YELLOW, and GREEN. Each value is assigned a unique integer value starting from 1 by default.

You can access the values of an enum using their names like any other variable:

print(TrafficLightColors.RED) # Output: TrafficLightColors.RED
print(TrafficLightColors.YELLOW) # Output: TrafficLightColors.YELLOW

Enums can also be used in switch-like statements with the match statement introduced in Python 3.10:

def handle_traffic_light(color):
match color:
case TrafficLightColors.RED:
print("Stop!")
case TrafficLightColors.YELLOW:
print("Prepare to stop.")
case TrafficLightColors.GREEN:
print("Go!")

Enum Methods

The enum.Enum class provides several useful methods for working with enums, including:

  • values(): Returns a list of all enum members (constants).
  • value2member_map(): Creates a dictionary mapping integer values to their corresponding enum members.
  • members(): Returns an iterable of tuples containing both the name and value of each enum member.
  • name: Returns the name of the enum class.
  • value: Returns the integer value associated with the enum member.

Enum Types

Python enums can be either regular or auto enumerated, depending on whether you provide explicit integer values for the members. By default, enums are auto-enumerated, meaning they are assigned unique integer values starting from 1. However, you can create a regular enum by explicitly setting the integer values of the members:

class Weekdays(enum.Enum):
MONDAY = 0
TUESDAY = 1
WEDNESDAY = 2
THURSDAY = 3
FRIDAY = 4
SATURDAY = 5
SUNDAY = 6

In this example, we've created a regular enum called Weekdays, where each member has an explicit integer value.

Ordered vs. Unordered Enums

Enums can be either ordered or unordered, depending on whether the order of the members matters for your application. In the examples above, both TrafficLightColors and Weekdays are ordered enums because their integer values have significance. However, you can also create unordered enums by not providing explicit integer values:

class TrafficSignals(enum.Enum):
STOP = "Stop"
YIELD = "Yield"
CAUTION = "Caution"

In this example, the TrafficSignals enum is unordered because its members do not have explicit integer values.

Worked Example

Let's create an enum for a set of file modes (e.g., 'READ', 'WRITE', 'APPEND') and use it in a function that opens a file with the specified mode:

import enum
import os

class FileMode(enum.Enum):
READ = "r"
WRITE = "w"
APPEND = "a"

def open_file(mode, filename):
try:
file = open(filename, mode)
return file
except Exception as e:
print("Error opening file:", e)
return None

In this example, we've created an enum called FileMode with three named values representing different file modes. The open_file() function takes a FileMode enum and a filename as arguments, opens the file using the specified mode, and returns the file object if successful or None otherwise.

Common Mistakes

  1. Forgetting to import the enum module before defining an enum.
  2. Assuming that enums are case-sensitive when accessing their values. In Python, enum names are not case-sensitive, but you should still follow a consistent naming convention for better readability.
  3. Not understanding the difference between enumeration members and their integer values. While it's convenient to use the integer values in some cases, it's essential to remember that they can change if new enum members are added or existing ones are reordered.
  4. Using enums in places where they are not necessary, such as for simple constants like True and False.
  5. Not taking advantage of enums when working with switch-like statements using the match statement.
  6. Failing to consider the order of enum members when defining an ordered enum (i.e., one where the integer values matter).
  7. Assuming that enums are mutable, leading to unexpected behavior when trying to modify them after they have been defined.
  8. Not handling exceptions when working with files and enums.

Common Mistakes - Subheadings

  • Forgetting to import the enum module
  • Assuming enum names are case-sensitive
  • Not understanding the difference between enumeration members and their integer values
  • Using enums inappropriately for simple constants
  • Overlooking the order of enum members when defining an ordered enum
  • Treating enums as mutable objects
  • Failing to handle exceptions when working with files and enums

Practice Questions

  1. Create an enum for a set of file modes (e.g., 'READ', 'WRITE', 'APPEND'). Use it in a function that opens a file with the specified mode and reads its contents.
  2. Write a function that takes an enum representing a traffic light color and returns the appropriate action to take (stop, prepare to stop, or go).
  3. Create an enum for a deck of cards in a card game called "Blackjack." Use it to simulate dealing two initial hands to two players.
  4. Modify the Rummy example to include wild cards that can represent any suit. Add new enum members for the wild cards and update the create_deck() function accordingly.
  5. Create an ordered enum representing the days of the week, starting with Monday. Write a function that takes an enum representing a day of the week and returns the next day in the order (e.g., if the input is 'Sunday', the output should be 'Monday').
  6. Write a function that takes an ordered enum representing a set of priorities (e.g., 'LOW', 'MEDIUM', 'HIGH') and returns the next priority level when given a current priority. If the current priority is already the highest, the function should return None.
  7. Create an enum for a set of animal species (e.g., 'LION', 'TIGER', 'LEOPARD'). Write a function that takes an animal species and returns its habitat (e.g., 'SAVANNA' for lions).
  8. Modify the TrafficLightColors enum to include a new value for 'BLINKING_RED'. Update the handle_traffic_light() function to handle this new case, displaying a message to drivers to proceed with caution.
  9. Create an enum for a set of programming languages (e.g., 'PYTHON', 'JAVA', 'C++'). Write a function that takes a programming language and returns its primary use case (e.g., 'WEB_DEVELOPMENT' for Python).
  10. Modify the FileMode enum to include a new value for 'BINARY'. Update the open_file() function to handle binary files by setting the file mode appropriately.

FAQ

Can I create enums without using the enum module?

  • No, enums in Python require the use of the built-in enum module from the standard library.

Are enum names case-sensitive when accessing them?

  • No, enum names are not case-sensitive in Python, but it's still a good idea to follow a consistent naming convention for better readability.

Can I change the integer values assigned to enum members?

  • Yes, you can explicitly set the integer values of enum members by providing them when defining the enum class. However, changing the integer values after the enum is defined will have unpredictable results.

Can I use enums in switch-like statements with the match statement?

  • Yes, enums can be used in switch-like statements with the match statement, which was introduced in Python 3.10.

Should I always use enums for simple constants like True and False?

  • No, it's not necessary to create enums for simple constants since they are already built-in constants in Python. However, using enums can help improve code readability when dealing with more complex sets of related constants.

How do I define an ordered enum?

  • To define an ordered enum, you can provide the enumeration members in the desired order when defining the class, or explicitly set their integer values to ensure the correct order.

Are enums mutable objects?

  • No, enums are immutable objects in Python. Once defined, their members cannot be modified.

How do I define a regular enum?

  • To define a regular enum, you can explicitly set the integer values of the members when creating the class.

What is the difference between an ordered and unordered enum?

  • An ordered enum has explicit integer values associated with its members, while an unordered enum does not. The order of unordered enum members is arbitrary.

Can I use enums to create custom exceptions in Python?

  • Yes, you can define custom exceptions using enums by creating a new class that inherits from enum.Enum and overriding the built-in __init__() method to raise an exception when the enum member is created.
Python - Enums | Python | XQA Learn