Python 中的枚举枚举？

Question

是否可以在 Python 中有枚举的枚举？ 例如，我想拥有

enumA
    enumB
        elementA
        elementB
    enumC
        elementC
        elementD

对我来说，能够将elementA称为enumA.enumB.elementA ，或者将elementD称为enumA.enumC.elementD 。

这可能吗？ 如果是这样，怎么做？

编辑：当以天真的方式实施时：

from enum import Enum

class EnumA(Enum):
    class EnumB(Enum):
        member = 0

print(EnumA)
print(EnumA.EnumB.member)

它给：

<enum 'EnumA'>
Traceback (most recent call last):
  File "Maps.py", line 15, in <module>
    print(EnumA.EnumB.member)
AttributeError: 'EnumA' object has no attribute 'member'

Answer 1

您无法使用enum stdlib模块执行此操作。 如果你试试：

class A(Enum):
    class B(Enum):
        a = 1
        b = 2
    class C(Enum):
        c = 1
        d = 2

A.B.a

...你会得到一个例外：

AttributeError: 'A' object has no attribute 'a'

这是因为枚举值A类似的实例行为A ，不喜欢自己的值类型的实例。 就像保持int值的普通枚举一样，值没有int方法， B也不会有Enum方法。 相比：

class D(Enum):
    a = 1
    b = 2

D.a.bit_length()

---

当然，您可以显式访问基础值（ int或B类）：

D.a.value.bit_length()
A.B.value.a

......但我怀疑这就是你想要的。

---

所以，你可以使用同样的伎俩IntEnum使用，继承两者Enum和int使其枚举值是 int值，如所描述的其他的文档的部分？

不，因为你将什么类型的子类？ 不是Enum ; 这已经是你的类型了。 你不能使用type （任意类的类型）。 什么都行不通。

因此，您必须使用具有不同设计的不同Enum实现来实现此功能。 幸运的是，PyPI和ActiveState上有大约69105个不同的可供选择。

---

例如，当我在构建类似于Swift枚举的东西时（它比ML / makeobj / Java等等更接近ML ADT），有人建议我看看makeobj 。 我忘了这样做，但现在我做了，并且：

class A(makeobj.Obj):
    class B(makeobj.Obj):
        a, b = makeobj.keys(2)
    class C(makeobj.Obj):
        c, d = makeobj.keys(2)

print(A.B, A.B.b, A.B.b.name, A.B.b.value)

这给你：

<Object: B -> [a:0, b:1]> <Value: B.b = 1> b 1

如果它查看它的__qualname__而不是它的__name__来创建str / repr值可能会很好，但是看起来它看起来像你想要的一切。 它还有其他很酷的功能（不完全是我想要的，但很有趣......）。

Answer 2

注意以下内容很有意思，可能很有用，但正如@abarnert所指出的，结果A Enum没有Enum成员 - 即list(A)返回一个空列表。

---

没有评论Enum of Enums是否是一个好主意（我还没有决定;），这可以做到......并且只有少量的魔法。

您可以使用此答案中的Constant类：

class Constant:
    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)

或者您可以使用新的aenum库及其内置的skip desriptor装饰器（我将展示）。

无论如何，通过将subEnum类包装在描述符中，它们可以避免成为成员本身。

您的示例如下所示：

from aenum import Enum, skip

class enumA(Enum):
    @skip
    class enumB(Enum):
        elementA = 'a'
        elementB = 'b'
    @skip
    class enumC(Enum):
        elementC = 'c'
        elementD = 'd'

然后你可以访问它们：

print(enumA)
print(enumA.enumB)
print(enumA.enumC.elementD)

这给你：

<enum 'enumA'>
<enum 'enumB'>
enumC.elementD

使用Constant和skip之间的区别是深奥的：在enumA的__dict__ 'enumB'将返回一个Constant对象（如果使用Constant ）或<enum 'enumB'>如果使用了skip ; 正常访问将始终返回<enum 'enumB'> 。

在Python 3.5+中，你甚至可以（un）pickle嵌套的枚举：

print(pickle.loads(pickle.dumps(enumA.enumC.elementD)) is enumA.enumC.elementD)
# True

请注意，subEnum在其显示中不包含父Enum; 如果这很重要，我会建议增强EnumMeta以识别Constant描述符并修改其包含的类' __repr__ - 但我会将其作为练习留给读者。 ;）

Answer 3

我在这个基本枚举中创建了一个实现de __ getattr __的枚举

def __getattr__(self, item):
    if item != '_value_':
        return getattr(self.value, item).value
    raise AttributeError

就我而言，我有一个枚举枚举的枚举

class enumBase(Enum):
    class innerEnum(Enum):
        class innerInnerEnum(Enum):
           A

和

enumBase.innerEnum.innerInnerEnum.A

作品

Answer 4

您可以使用namedtuples来执行以下操作：

>>> from collections import namedtuple
>>> Foo = namedtuple('Foo', ['bar', 'barz'])
>>> Bar = namedtuple('Bar', ['element_a', 'element_b'])
>>> Barz = namedtuple('Barz', ['element_c', 'element_d'])
>>> bar = Bar('a', 'b')
>>> barz = Barz('c', 'd')
>>> foo = Foo(bar, barz)
>>> foo
Foo(bar=Bar(element_a='a', element_b='b'), barz=Barz(element_c='c', element_d='d'))
>>> foo.bar.element_a
'a'
>>> foo.barz.element_d
'd'

这不是一个枚举，但也许解决了你的问题

Answer 5

基于attrs的解决方案。 这也允许实现属性验证器和attrs的其他好东西：

import enum

import attr


class CoilsTypes(enum.Enum):
    heating: str = "heating"


class FansTypes(enum.Enum):
    plug: str = "plug"


class HrsTypes(enum.Enum):
    plate: str = "plate"
    rotory_wheel: str = "rotory wheel"


class FiltersTypes(enum.Enum):
    bag: str = "bag"
    pleated: str = "pleated"


@attr.dataclass(frozen=True)
class ComponentTypes:
    coils: CoilsTypes = CoilsTypes
    fans: FansTypes = FansTypes
    hrs: HrsTypes = HrsTypes
    filter: FiltersTypes = FiltersTypes


cmp = ComponentTypes()
res = cmp.hrs.plate

Answer 6

如果你不关心继承，这里有一个我以前用过的解决方案：

class Animal:
    class Cat(enum.Enum):
        TIGER = "TIGER"
        CHEETAH = "CHEETAH"
        LION = "LION"

    class Dog(enum.Enum):
        WOLF = "WOLF"
        FOX = "FOX"

    def __new__(cls, name):
        for member in cls.__dict__.values():
            if isinstance(member, enum.EnumMeta) and name in member.__members__:
                return member(name)
        raise ValueError(f"'{name}' is not a valid {cls.__name__}")

它通过覆盖Animal的__new__方法来找到合适的子枚举并返回它的一个实例。

用法：

Animal.Dog.WOLF                    #=> <Dog.WOLF: 'WOLF'>
Animal("WOLF")                     #=> <Dog.WOLF: 'WOLF'>
Animal("WOLF") is Animal.Dog.WOLF  #=> True
Animal("WOLF") is Animal.Dog.FOX   #=> False
Animal("WOLF") in Animal.Dog       #=> True
Animal("WOLF") in Animal.Cat       #=> False
Animal("OWL")                      #=> ValueError: 'OWL' is not a valid Animal

然而，值得注意的是：

isinstance(Animal.Dog, Animal)     #=> False

只要您不关心此解决方案是否能很好地工作。 不幸的是，似乎无法在内部类的定义中引用外部类，因此没有简单的方法可以让Dog扩展Animal 。

Answer 7

尝试这个：

 # python3.7 import enum class A(enum.Enum): def __get__(self, instance, owner): return self.value class B(enum.IntEnum): a = 1 b = 2 class C(enum.IntEnum): c = 1 d = 2 # this is optional (it just adds 'A.' before the B and C enum names) B.__name__ = B.__qualname__ C.__name__ = C.__qualname__ print(A.C.d) # prints: A.C.d print(ABbvalue) # prints: 2