小贝子编程

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



我想将字符串解析为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 FilesPythonPython 3.4.0libenum.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])

类型现在应包含枚举的值 具有 3 个可能值的类型(未知、源、网表(

如果我允许枚举成员列表中的别名，则无法免费迭代枚举的值别名。

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

使用

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

对于这种情况来说，压倒__call__也许是矫枉过正。相反，您可以轻松使用名称别名：

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

这里Types.nl是一个别名，将返回与Types.Netlist相同的对象。然后，您可以按名称访问成员(使用Types[..]索引访问(;所以Types['nl']工作并返回Types.Netlist.

您断言无法迭代枚举的值别名自由是不正确的。迭代明确不包含别名：

遍历枚举的成员不提供别名

别名是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支持名称别名，您似乎需要值别名。覆盖__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>

是的，如果你小心的话，你可以重写enum子类的__new__()方法来实现解析方法，但为了避免在两个地方指定整数编码，你需要在类之后单独定义方法，以便你可以引用枚举定义的符号名称。

我的意思是：

import enum
class Types(enum.Enum):
    Unknown = 0
    Source = 1
    NetList = 2
    def __str__(self):
        if (self == Types.Unknown):     return "??"
        elif (self == Types.Source):    return "src"
        elif (self == Types.NetList):   return "nl"
        else:                           raise TypeError(self)
def _Types_parser(cls, value):
    if not isinstance(value, str):
        # forward call to Types' superclass (enum.Enum)
        return super(Types, cls).__new__(cls, value)
    else:
        # map strings to enum values, default to Unknown
        return { 'nl': Types.NetList,
                'ntl': Types.NetList,  # alias
                'src': Types.Source,}.get(value, Types.Unknown)
setattr(Types, '__new__', _Types_parser)

if __name__ == '__main__':
    print("Types('nl') ->",  Types('nl'))   # Types('nl') -> nl
    print("Types('ntl') ->", Types('ntl'))  # Types('ntl') -> nl
    print("Types('wtf') ->", Types('wtf'))  # Types('wtf') -> ??
    print("Types(1) ->",     Types(1))      # Types(1) -> src

更新

下面是一个更表驱动的版本，它消除了一些重复的编码，否则会涉及：

from collections import OrderedDict
import enum
class Types(enum.Enum):
    Unknown = 0
    Source = 1
    NetList = 2
    __str__ = lambda self: Types._value_to_str.get(self)
# Define after Types class.
Types.__new__ = lambda cls, value: (cls._str_to_value.get(value, Types.Unknown)
                                        if isinstance(value, str) else
                                    super(Types, cls).__new__(cls, value))
# Define look-up table and its inverse.
Types._str_to_value = OrderedDict((( '??', Types.Unknown),
                                   ('src', Types.Source),
                                   ('ntl', Types.NetList),  # alias
                                   ( 'nl', Types.NetList),))
Types._value_to_str = {val: key for key, val in Types._str_to_value.items()}

if __name__ == '__main__':
    print("Types('nl')  ->", Types('nl'))   # Types('nl')  -> nl
    print("Types('ntl') ->", Types('ntl'))  # Types('ntl') -> nl
    print("Types('wtf') ->", Types('wtf'))  # Types('wtf') -> ??
    print("Types(1)     ->", Types(1))      # Types(1)     -> src
    print(list(Types))  # -> [<Types.Unknown: 0>, <Types.Source: 1>, <Types.NetList: 2>]
    import pickle  # Demostrate picklability
    print(pickle.loads(pickle.dumps(Types.NetList)) == Types.NetList)  # -> True

请注意，在 Python 3.7+ 中，常规字典是有序的，因此不需要在上面的代码中使用 OrderedDict，可以简化为：

# Define look-up table and its inverse.
Types._str_to_value = {'??': Types.Unknown,
                       'src': Types.Source,
                       'ntl': Types.NetList,  # alias
                       'nl': Types.NetList}
Types._value_to_str = {val: key for key, val in Types._str_to_value.items()}

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

总之，是的。 正如 martineau 所说明的那样，您可以在类实例化后替换 __new__ 方法(他的原始代码(：

class Types(enum.Enum):
    Unknown = 0
    Source = 1
    NetList = 2
    def __str__(self):
        if (self == Types.Unknown):     return "??"
        elif (self == Types.Source):    return "src"
        elif (self == Types.NetList):   return "nl"
        else:                           raise TypeError(self) # completely unnecessary
def _Types_parser(cls, value):
    if not isinstance(value, str):
        raise TypeError(value)
    else:
        # map strings to enum values, default to Unknown
        return { 'nl': Types.NetList,
                'ntl': Types.NetList,  # alias
                'src': Types.Source,}.get(value, Types.Unknown)
setattr(Types, '__new__', _Types_parser)

而且正如他的演示代码所说明的那样，如果你不是非常小心，你会破坏其他东西，比如酸洗，甚至是基本的按值成员查找：

--> print("Types(1) ->", Types(1))  # doesn't work
Traceback (most recent call last):
  ...
TypeError: 1
--> import pickle
--> pickle.loads(pickle.dumps(Types.NetList))
Traceback (most recent call last):
  ...
TypeError: 2

Martijn展示了一种增强EnumMeta以获得我们想要的东西的聪明方法：

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):
    ...

但这会使我们有重复的代码，并且针对 Enum 类型工作。

对用例的基本 Enum 支持唯一缺乏的是能够让一个成员成为默认值，但即使是这样，也可以通过创建新的类方法在普通的 Enum 子类中优雅地处理。

您想要的类是：

class Types(enum.Enum):
    Unknown = 0
    Source = 1
    src = 1
    NetList = 2
    nl = 2
    def __str__(self):
        if self is Types.Unknown:
            return "??"
        elif self is Types.Source:
            return "src"
        elif self is Types.NetList:
            return "nl"
    @classmethod
    def get(cls, name):
        try:
            return cls[name]
        except KeyError:
            return cls.Unknown

并在行动中：

--> for obj in Types:
...   print(obj)
... 
??
src
nl
--> Types.get('PoC')
<Types.Unknown: 0>

如果你真的需要值别名，即使这样也可以在不诉诸元类黑客的情况下处理：

class Types(Enum):
    Unknown = 0, 
    Source  = 1, 'src'
    NetList = 2, 'nl'
    def __new__(cls, int_value, *value_aliases):
        obj = object.__new__(cls)
        obj._value_ = int_value
        for alias in value_aliases:
            cls._value2member_map_[alias] = obj
        return obj
print(list(Types))
print(Types(1))
print(Types('src'))

这给了我们：

[<Types.Unknown: 0>, <Types.Source: 1>, <Types.NetList: 2>]
Types.Source
Types.Source
我认为到目前为止

最简单的解决方案是使用 Enum 类的功能 API，它在选择名称时提供了更多的自由，因为我们将它们指定为字符串：

from enum import Enum
Types = Enum(
    value='Types',
    names=[
        ('??', 0),
        ('Unknown', 0),
        ('src', 1),
        ('Source', 1),
        ('nl', 2),
        ('NetList', 2),
    ]
)

这将创建一个带有名称别名的枚举。请注意names列表中条目的顺序。第一个将被选为默认值(也返回name(，其他的被视为别名，但两者都可以使用：

>>> Types.src
<Types.src: 1>
>>> Types.Source
<Types.src: 1>

要使用 name 属性作为str(Types.src)的返回值，我们替换 Enum 中的默认版本：

>>> Types.__str__ = lambda self: self.name
>>> Types.__format__ = lambda self, _: self.name
>>> str(Types.Unknown)
'??'
>>> '{}'.format(Types.Source)
'src'
>>> Types['src']
<Types.src: 1>

请注意，我们还替换了 str.format() 调用的 __format__ 方法。

我没有足够的代表来评论接受的答案，但在带有 enum34 包的 Python 2.7 中，运行时会出现以下错误：

"unbound 方法 (( 必须使用实例 MyEnum 作为第一个参数调用(取而代之的是 EnumMeta 实例(">

我能够通过更改来纠正此问题：

# define after Types class
Types.__new__ = lambda cls, value: (cls._str_to_value.get(value, Types.Unknown)
                                    if isinstance(value, str) else
                                    super(Types, cls).__new__(cls, value))

对于以下内容，使用 staticmethod(( 将 lambda 包装在：

# define after Types class
Types.__new__ = staticmethod(
    lambda cls, value: (cls._str_to_value.get(value, Types.Unknown)
                        if isinstance(value, str) else
                        super(Types, cls).__new__(cls, value)))

此代码在 Python 2.7 和 3.6 中都经过了正确测试。

相关内容

最新更新


热门标签：

javascript python java c# php android html jquery c++ css ios sql mysql arrays asp.net json python-3.x ruby-on-rails .net sql-server django objective-c excel regex ruby linux ajax iphone xml vba spring asp.net-mvc database wordpress string postgresql wpf windows xcode bash git oracle list vb.net multithreading eclipse algorithm macos powershell visual-studio image forms numpy scala function api selenium