python - 是否可以覆盖枚举中的 __new__ 以将字符串解析为实例？

Question

我想将字符串解析为 python 枚举。通常人们会实现一个解析方法来这样做。几天前，我发现了能够根据给定参数返回不同实例的 __new__ 方法。

这是我的代码，它不会工作:

import enum
class Types(enum.Enum):
  Unknown = 0
  Source = 1
  NetList = 2

  def __new__(cls, value):
    if (value == "src"):  return Types.Source
#    elif (value == "nl"): return Types.NetList
#    else:                 raise Exception()

  def __str__(self):
    if (self == Types.Unknown):     return "??"
    elif (self == Types.Source):    return "src"
    elif (self == Types.NetList):   return "nl"

当我执行我的 Python 脚本时，我收到这条消息:

[...]
  class Types(enum.Enum):
File "C:\Program Files\Python\Python 3.4.0\lib\enum.py", line 154, in __new__
  enum_member._value_ = member_type(*args)
TypeError: object() takes no parameters

如何返回枚举值的正确实例？

编辑 1:

此枚举用于 URI 解析，特别是用于解析模式。所以我的 URI 看起来像这样

nl:PoC.common.config
<schema>:<namespace>[.<subnamespace>*].entity

所以在一个简单的 string.split 操作之后，我会将 URI 的第一部分传递给枚举创建。

type = Types(splitList[0])

type 现在应该包含具有 3 个可能值(Unknown、Source、NetList)的枚举类型的值

如果我允许在枚举的成员列表中使用别名，则无法无别名地迭代枚举的值。

Answer 1

enum.Enum 类型的 __new__ 方法用于创建枚举 values 的新实例，因此 Types.Unknown、Types.Source 等单例实例。枚举调用(例如 Types('nl') 由 EnumMeta.__call__ 处理，您可以将其子类化。

使用名称别名适合您的用例

重写 __call__ 对于这种情况来说可能有点矫枉过正。相反，您可以轻松使用 name aliases :

class Types(enum.Enum):
    Unknown = 0

    Source = 1
    src = 1

    NetList = 2
    nl = 2

此处 Types.nl 是一个别名，将返回与 Types.Netlist 相同的对象。那你access members by names (使用 Types[..] 索引访问)；所以 Types['nl'] 工作并返回 Types.Netlist。

您断言不可能迭代枚举的值 alias free 不正确。迭代 explicitly doesn't include aliases :

Iterating over the members of an enum does not provide the aliases

别名是 Enum.__members__ 有序字典的一部分，如果您仍然需要访问它们的话。

演示:

>>> import enum
>>> class Types(enum.Enum):
...     Unknown = 0
...     Source = 1
...     src = 1
...     NetList = 2
...     nl = 2
...     def __str__(self):
...         if self is Types.Unknown: return '??'
...         if self is Types.Source:  return 'src'
...         if self is Types.Netlist: return 'nl'
... 
>>> list(Types)
[<Types.Unknown: 0>, <Types.Source: 1>, <Types.NetList: 2>]
>>> list(Types.__members__)
['Unknown', 'Source', 'src', 'NetList', 'nl']
>>> Types.Source
<Types.Source: 1>
>>> str(Types.Source)
'src'
>>> Types.src
<Types.Source: 1>
>>> str(Types.src)
'src'
>>> Types['src']
<Types.Source: 1>
>>> Types.Source is Types.src
True

这里唯一缺少的是将未知模式转换为 Types.Unknown；我会为此使用异常处理:

try:
    scheme = Types[scheme]
except KeyError:
    scheme = Types.Unknown

覆盖__call__

如果您想将字符串视为值，并使用调用而不是项目访问，这就是您覆盖元类的 __call__ 方法的方式:

class TypesEnumMeta(enum.EnumMeta):
    def __call__(cls, value, *args, **kw):
        if isinstance(value, str):
            # map strings to enum values, defaults to Unknown
            value = {'nl': 2, 'src': 1}.get(value, 0)
        return super().__call__(value, *args, **kw)

class Types(enum.Enum, metaclass=TypesEnumMeta):
    Unknown = 0
    Source = 1
    NetList = 2

演示:

>>> class TypesEnumMeta(enum.EnumMeta):
...     def __call__(cls, value, *args, **kw):
...         if isinstance(value, str):
...             value = {'nl': 2, 'src': 1}.get(value, 0)
...         return super().__call__(value, *args, **kw)
... 
>>> class Types(enum.Enum, metaclass=TypesEnumMeta):
...     Unknown = 0
...     Source = 1
...     NetList = 2
... 
>>> Types('nl')
<Types.NetList: 2>
>>> Types('?????')
<Types.Unknown: 0>

请注意，我们在这里将字符串值转换为整数，并将其余部分留给原始 Enum 逻辑。

完全支持值别名

因此，enum.Enum 支持 name 别名，您似乎需要 value 别名。覆盖 __call__ 可以提供一个传真，但我们可以通过将值别名的定义放入枚举类本身来做得更好。例如，如果指定重复的名称 给您值别名怎么办？

您还必须提供 enum._EnumDict 的子类，因为正是该类防止名称被重复使用。我们假设 第一个 枚举值是默认值:

class ValueAliasEnumDict(enum._EnumDict):
     def __init__(self):
        super().__init__()
        self._value_aliases = {}

     def __setitem__(self, key, value):
        if key in self:
            # register a value alias
            self._value_aliases[value] = self[key]
        else:
            super().__setitem__(key, value)

class ValueAliasEnumMeta(enum.EnumMeta):
    @classmethod
    def __prepare__(metacls, cls, bases):
        return ValueAliasEnumDict()

    def __new__(metacls, cls, bases, classdict):
        enum_class = super().__new__(metacls, cls, bases, classdict)
        enum_class._value_aliases_ = classdict._value_aliases
        return enum_class

    def __call__(cls, value, *args, **kw):
        if value not in cls. _value2member_map_:
            value = cls._value_aliases_.get(value, next(iter(Types)).value)
        return super().__call__(value, *args, **kw)

然后，您可以在枚举类中定义别名和默认值:

class Types(enum.Enum, metaclass=ValueAliasEnumMeta):
    Unknown = 0

    Source = 1
    Source = 'src'

    NetList = 2
    NetList = 'nl'

演示:

>>> class Types(enum.Enum, metaclass=ValueAliasEnumMeta):
...     Unknown = 0
...     Source = 1
...     Source = 'src'
...     NetList = 2
...     NetList = 'nl'
... 
>>> Types.Source
<Types.Source: 1>
>>> Types('src')
<Types.Source: 1>
>>> Types('?????')
<Types.Unknown: 0>