Modify Enum to Automatically Return Values

What will you learn?

In this tutorial, you will learn how to enhance the behavior of an Enum in Python by customizing it to automatically return values without explicitly specifying them.

Introduction to the Problem and Solution

Enums in Python offer a way to define named constant values. Typically, accessing an Enum member requires explicit notation like Color.RED. However, by modifying the Enum class itself, we can enable automatic value retrieval when accessing members without specifying them directly.

To achieve this customization, we override the __getattr__ method of the Enum class. This method comes into play when an attribute lookup fails for instances of that class, allowing us to implement automatic value return functionality.


from enum import Enum

class AutoValueEnum(Enum):
    def __getattr__(self, name):
        if name in self._member_names_:
            return self[name].value
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")

# Example Usage
class Color(AutoValueEnum):
    RED = 1
    GREEN = 2

# Accessing members with automatic value retrieval
print(Color.RED)   # Output: 1
print(Color.GREEN) # Output: 2

# Credits: Check out more Python tips at [](

# Copyright PHD


By subclassing Enum and overriding the __getattr__ method, we intercept attribute lookups on instances of our custom Enum class. If the requested attribute matches one of the defined members, its corresponding value is returned automatically. Otherwise, an AttributeError is raised.

In our example code snippet: – We define a new base class AutoValueEnum that inherits from Enum. – The __getattr__ method is overridden inside this class to enable automatic value retrieval. – We demonstrate this customization through a new Enum called Color, associating each color constant with an integer value. – When accessing members like Color.RED, their respective values (1 for RED and 2 for GREEN) are automatically returned.

This technique enhances Enums in Python by providing seamless automatic value retrieval while preserving their key features like immutability and human-readable names.

  1. How does overriding __getattr__ enable automatic value retrieval?

  2. Customizing the __getattr__ method allows us to intercept attribute lookups and implement logic for automatic value return based on attribute names.

  3. Can I modify existing Enums similarly?

  4. Yes, you can customize existing Enums by subclassing them and overriding methods like __getattr__. Exercise caution regarding potential conflicts or unintended consequences when altering standard library classes.

  5. What happens if I access a non-existent member using this approach?

  6. Attempting to access a non-existent member without proper specification within your customized enum implementation will result in an AttributeError being raised as per default behavior.

  7. Is there a performance impact associated with this modification?

  8. Overriding methods such as __getattr__ incurs slight additional overhead compared to regular attribute access due to runtime method resolution. However, any performance impact should be minimal for most use cases involving Enums with limited members.

  9. Can I combine other functionalities with automatic value retrieval in my custom Enums?

  10. Absolutely! You can extend your custom enums further by adding additional features or behaviors tailored to your specific needs while retaining automatic value retrieval as part of their functionality.


Customizing enum behavior enables us to tailor their functionality according to specific requirements beyond standard usage patterns. By utilizing techniques such as overriding methods like __getattr__, we enhance enums with advanced capabilities while maintaining their core advantages. For more insights into mastering Python concepts and best practices, explore

Leave a Comment