支持 Python 枚举中的未知值

Question

我想扩展 Python 枚举以支持未定义的值。

我的用例：我想从 Enums 中受益（例如，能够用说话的名字来寻址/比较已知条目），但我也希望它支持未知值。如果值后面没有名称，str 应该简单地打印值的 str 表示，比较应该失败。

让我给你一个简短的例子，我想要什么：

from enum import Enum

class Foo(Enum):
    A = 1
    B = 2
    C = 3

    def __str__(self):
        return self.name


print(Foo(1)) # prints 'A'
print(Foo(2)) # print 'B'
print(Foo(3)) # prints 'C'
print(Foo(1) == Foo.A) # prints 'true'

print(Foo(4)) # I'd expect '4'
print(Foo(123)) # I'd expect '123'
print(Foo(123) == Foo.A) # I'd expect False

当然最后几行失败了。

有没有办法扩展 Enums，或者是否有另一种简单的 Python 方式？ （请不要使用第三方库。）

Answer 1

要使这项工作在 Python 的多个值（尤其是 Python 2）上工作，您将需要一个外部库：aenum¹。

from aenum import Enum, extend_enum

class Foo(Enum):
    _order_ = 'A B C'   # because Python 2 does not keep order
    A = 1
    B = 2
    C = 3

    def __str__(self):
        return self.name

    @classmethod
    def _missing_(cls, value):
        extend_enum(cls, str(value), (value, ))
        return list(cls)[-1]

这会将未知值作为枚举成员动态添加并返回。

---

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

Answer 2

这是另一个适用于 Python 3.6、3.7 和 3.8 的答案。

它涉及到奇怪的元类黑客，所以要小心。

import enum

class TestMeta(enum.EnumMeta):
    def __call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1):
        if names is not None:
            # the enum is being constructed via the functional syntax
            return super().__call__(value, names=names, module=module, qualname=qualname, type=type, start=start)

        try:
            # attempt to get an enum member
            return super().__call__(value, names=names, module=module, qualname=qualname, type=type, start=start)
        except ValueError:
            # no such member exists, but we don't care
            return value

class Test(enum.Enum, metaclass=TestMeta):
    A = 5
    B = 6    

print(Test(5), Test(6), Test(7))

此版本works in Python 2.7，但需要enum 的第三方库（参见 cmets）：

class TestMeta(enum.EnumMeta):
    def __call__(cls, value, names=None, module=None, type=None, start=1):
        if names is not None:
            return enum.EnumMeta.__call__(cls, value, names, module, type, start)

        try:    
            return enum.EnumMeta.__call__(cls, value, names, module, type, start)
        except ValueError:
            return value

Answer 3

可以按照enum.Flag._create_pseudo_member_ 中的示例尝试在运行时使用新成员扩展枚举：

from enum import Enum

class Foo(Enum):
    A = 1
    B = 2
    C = 3

    def __str__(self):
        return self.name

    @classmethod
    def _missing_(cls, value):
        if cls._member_type_ is object:
            # construct a new singleton enum member
            new_member = object.__new__(cls)
            # include the value representation in _name_ because the Enum hash implementation relies on _name_
            new_member._name_ = '%r' % value
            new_member._value_ = value
            # use setdefault in case another thread already created a composite with this value
            new_member = cls._value2member_map_.setdefault(value, new_member)
            return new_member

这种简单的实现将打破在类定义中将Enum 与其他类型混合的可能性，但这当然可以在enum.EnumMeta.__new__ 中的机制之后修复。

正如@chepner 已经评论的那样，这违反了承诺

一旦定义了枚举项，Enum 类就是最终的

（也可以在 enum.EnumMeta.__new__ 中找到）并且预计会破坏某些 Enum 方法的行为，例如 __len__。

Answer 4

对于您的用例，更自然的解决方案是：

• 获取输入中存在的数值的完整列表（通过解析）
• 使用这些值和已知标识符自动生成带有 Functional API 的 Enum 类

例如：

known_values = {'a':1,'b':2,'c':1}    # only one of 'a' and 'c' will be used
                                      # 'a' guaranteed in 3.7+, implementation-specific before
                                      # (https://stackoverflow.com/q/39980323)
extracted_values = (1,2,3,4,5)

known_values_reverse = {}
for k,v in known_values.items():
    if v not in known_values_reverse:
        known_values_reverse[v]=k
    del k,v    #if placed outside the loop, will error if known_values is empty

for v in extracted_values:
    if v not in known_values_reverse:
        known_values_reverse[v]=str(v)
    del v

AutoFooEnum = enum.Enum(value='AutoFooEnum',names=(k,v for v,k in known_values_reverse.items()))

生成输出时，您需要使用AutoFooEnum(value).name 输出文本 ID（如果有）或数字。

当然，您将无法在代码中使用 AutoFooEnum.<id> 引用编号成员，因为数字不是有效标识符。但看起来你不需要那个。

Answer 5

怎么样？

from enum import Enum


class CraftTypes(Enum):
    wood_work = 0
    welding = 1
    mechanics = 2
    unknown = 3
    # 3 and above is unknown


    @classmethod
    def _missing_(cls, number):
        return cls(cls.unknown)

简单和pythonic...