如何在内部跟踪 Python 枚举值？

Question

我的最终目标实际上是在我的 Enum 类中创建一个辅助方法，该方法始终返回一个 Enum 成员并且从不引发异常，给定任何可能的值，例如

Color.from_value('red')

如果值不是枚举的一部分，辅助方法将返回一个默认值，例如Color.UNKNOWN。

基于这个answer from another related question，我可以通过一些内置成员列出这些值来检查它们。但是，我接下来要做的是跟踪内部成员中的所有值，这样我就不必每次调用辅助方法时都遍历这些值。我尝试做类似以下的事情：

class Color(Enum):
    RED = 'red'
    BLUE = 'blue'
    GREEN = 'green'

    # this doesn't work
    _values = [item.value for item in Color]

正如预期的那样，它不起作用。这可能是 Python 枚举中已经内置的东西吗？

Answer 1

您可以创建方法并检查类中的值：

import enum

class Color(enum.Enum):
    RED = 'red'
    BLUE = 'blue'
    GREEN = 'green'
    UNKNOWN = "unknown"

    @classmethod
    def from_value(cls, value):
      try:
        return {item.value: item for item in cls}[value]
      except KeyError:
        return cls.UNKNOWN

print(Color.from_value("hey"))
print(Color.from_value("red"))

结果：

Color.UNKNOWN
Color.RED

你有一个live example

如果你不想重复，你总是可以有一个值的外部缓存：

class Color(enum.Enum):
    RED = 'red'
    BLUE = 'blue'
    GREEN = 'green'
    UNKNOWN = "unknown"

    @classmethod
    def from_value(cls, value):
      try:
        return _COLORITEMS[value]
      except KeyError:
        return cls.UNKNOWN
_COLORITEMS = {item.value: item for item in Color}

Answer 2

此后我接受了Netwave's answer，但我将其添加为与原始版本的一些变化。我想保留答案以供参考。

import enum

class Color(enum.Enum):
    RED = 'red'
    BLUE = 'blue'
    GREEN = 'green'
    UNKNOWN = "unknown"

    @staticmethod
    def from_value(value):
      try:
        return Color(value)
      except ValueError:
        return cls.UNKNOWN

请注意，在这种方法中，我已将 @classmethod 更改为 @staticmethod，因为我不再需要 cls 参数。此外，我在这里处理ValueError 而不是KeyError，因为这是Color() 在找不到值的情况下引发的。这也适用于多值/元组值枚举。

至于第二种方法：

import enum

class Color(enum.Enum):
    RED = 'red'
    BLUE = 'blue'
    GREEN = 'green'
    UNKNOWN = "unknown"

    @staticmethod
    def from_value(value):
        return Color(value) if value in _COLORITEMS else Color.UNKNOWN

_COLORITEMS = [item.value for item in Color]

在这里，我从 dict 切换到 list 以跟踪值。我没有处理KeyError，而是简单地检查了该值是否在列表中。我本可以使用一个集合，但因为它是一个枚举，所以值保证是唯一的（如果我理解正确的话）。

Answer 3

您可以在内部跟踪值，但这有点麻烦：

尝试 1

_values = [k for k in vars().keys() if not k.startswith('_')]

问题 1

>>> # _values is a member
>>> Color._values
<Color._huh: ['RED', 'BLUE', 'GREEN']>

尝试 2

使用来自this answer的Constant

_values = Constant([k for k in vars().keys() if not k.startswith('_')])

问题 2

它并不是真正恒定的，因为您仍然可以附加到列表中——但这可以通过转换为 tuple 来解决：

_values = Constant(tuple([k for k in vars().keys() if not k.startswith('_')]))

但是，这仍然不能解决UNKNOWN 的问题。

解决方案

使用 Python 3.6 或 aenum 2.0¹，您可以指定一个 _missing_ 方法，该方法将被调用以在引发 ValueError 之前为您的班级提供最后一次机会：

class Constant:  # use Constant(object) if in Python 2
    def __init__(self, value):
        self.value = value
    def __get__(self, *args):
        return self.value
    def __repr__(self):
        return '%s(%r)' % (self.__class__.__name__, self.value)


class Color(Enum):

    RED = 'red'
    BLUE = 'blue'
    GREEN = 'green'
    UNKNOWN = 'unknown'
    _values = Constant(tuple([k for k in vars().keys() if not k.startswith('_')]))

    @classmethod
    def _missing_(cls, name):
        if name.lower() in cls._values:
            return cls(name.lower())
        else:
            return cls.UNKNOWN

或

class Color(Enum):

    RED = 'red'
    BLUE = 'blue'
    GREEN = 'green'
    UNKNOWN = 'unknown'

    @classmethod
    def _missing_(cls, name):
        if name == name.lower():
            # avoid infinite recursion
            return cls.UNKNOWN
        else:
            return cls(name.lower())

注意：只有枚举成员或 None 应该由 _missing_ 返回——如果返回任何其他内容，以后的 Python 版本将引发 TypeError。

---

¹ 披露：我是Python stdlib Enum、enum34 backport 和Advanced Enumeration (aenum) 库的作者。