如何让Python Enum在可多次执行的交互式工作中更安全？

Great question! That quirk with Enums in interactive environments (like IPython or Jupyter notebooks) is super annoying—re-running your script creates a brand new Enum class, so old instances (like socks) and new ones (like shoes) end up being from different classes entirely, hence the False equality check. While the lru_cache factory function works, it's not the most elegant solution since it forces you to use a factory instead of standard Enum class syntax.

Here are a few cleaner, more Pythonic approaches to solve this:

1. Custom Metaclass to Reuse Existing Enum Classes #

We can create a custom metaclass that checks if the Enum class already exists in the module before creating a new one. This way, re-running the code will just return the original class instead of generating a new one.

from enum import EnumMeta, Enum

class InteractiveSafeEnumMeta(EnumMeta):
    def __new__(metacls, clsname, bases, classdict):
        # Grab the current module where the Enum is being defined
        import sys
        current_module = sys.modules[classdict['__module__']]
        
        # Check if the class already exists in the module
        if hasattr(current_module, clsname):
            existing_cls = getattr(current_module, clsname)
            # Verify it's our safe Enum type to avoid accidental reuse
            if isinstance(existing_cls, metacls):
                return existing_cls
        
        # If no existing class, create a new one like normal
        return super().__new__(metacls, clsname, bases, classdict)

# Define your Enum just like a regular one, using the safe metaclass
class SafeColor(Enum, metaclass=InteractiveSafeEnumMeta):
    RED = 1
    GREEN = 2
    BLUE = 3

Now, when you re-run your code:

socks = SafeColor.RED
# Re-run the entire script
shoes = SafeColor.RED
print(socks == shoes)  # Output: True

This approach keeps your Enum definition syntax identical to standard Enums, which is great for readability and consistency.

2. Decorator for Module-Level Enum Caching #

If custom metaclasses feel too heavy, a simple decorator can achieve the same goal by caching the Enum class in its module:

from enum import Enum
import sys

def interactive_safe_enum(cls):
    module = sys.modules[cls.__module__]
    # If the class already exists in the module, return the existing one
    if hasattr(module, cls.__name__):
        return getattr(module, cls.__name__)
    # Otherwise, store the new class in the module and return it
    setattr(module, cls.__name__, cls)
    return cls

# Apply the decorator to your Enum
@interactive_safe_enum
class SafeColor(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

This is lightweight and easy to understand—every time you re-run the code, the decorator checks if SafeColor already exists in the module and reuses it instead of creating a new class.

3. Explicit Module Check (Simplest Approach) #

For a no-frills solution, you can manually check for the existing Enum class in your module before defining it:

from enum import Enum
import sys

current_module = sys.modules[__name__]
# Reuse the existing class if it exists, otherwise define it
if hasattr(current_module, 'SafeColor'):
    SafeColor = current_module.SafeColor
else:
    class SafeColor(Enum):
        RED = 1
        GREEN = 2
        BLUE = 3

This is the most straightforward method, perfect for quick scripts or when you don't want to add extra abstractions.

Why These Are Better Than the lru_cache Factory #

• Familiar Syntax: All these methods let you define Enums using standard class syntax, unlike the factory function which changes how you create your Enum.
• Scalable: The metaclass and decorator approaches can be reused across multiple Enum classes in your project.
• Pythonic: They leverage Python's module system and metaclass mechanics in a natural way, rather than relying on a function cache.

All of these solutions work by ensuring that every time you re-run your code, you're using the exact same Enum class object—so instances created before and after re-running will always be equal.

内容的提问来源于stack exchange，提问作者kuzzooroo