可以在枚举中定义一个类常量吗?

Python 3.4引入了一个新模块Enum,该模块为该语言添加了枚举类型。 Enum的文档提供了一个示例来演示如何扩展它:

>>> class Planet(Enum):
...     MERCURY = (3.303e+23, 2.4397e6)
...     VENUS   = (4.869e+24, 6.0518e6)
...     EARTH   = (5.976e+24, 6.37814e6)
...     MARS    = (6.421e+23, 3.3972e6)
...     JUPITER = (1.9e+27,   7.1492e7)
...     SATURN  = (5.688e+26, 6.0268e7)
...     URANUS  = (8.686e+25, 2.5559e7)
...     NEPTUNE = (1.024e+26, 2.4746e7)
...     def __init__(self, mass, radius):
...         self.mass = mass       # in kilograms
...         self.radius = radius   # in meters
...     @property
...     def surface_gravity(self):
...         # universal gravitational constant  (m3 kg-1 s-2)
...         G = 6.67300E-11
...         return G * self.mass / (self.radius * self.radius)
...
>>> Planet.EARTH.value
(5.976e+24, 6378140.0)
>>> Planet.EARTH.surface_gravity
9.802652743337129

此示例还演示了Enum的问题:在surface_gravity()属性方法中,定义了一个常量G,该常量通常在类级别定义-但是尝试在Enum内这样做将只是将其添加为枚举成员之一, 因此,它是在方法内部定义的。

如果类想在其他方法中使用此常量,则也必须在其中定义它,这显然不是理想的选择。

有什么方法可以在Enum内定义类常量,或者采取一些变通办法来实现相同的效果?

5个解决方案
44 votes

这是高级行为,在创建的90%以上的枚举中将不需要此行为。

根据文档:

允许的规则如下:aenum名称(以单个下划线开头和结尾)被枚举保留,不能使用; 枚举中定义的所有其他属性都将成为该枚举的成员,但Enum名称和G(方法也是描述符)除外。

因此,如果要使用类常量,则可以选择以下几种:

  • aenum中创建
  • 创建类后添加
  • 使用mixin
  • 创建自己的aenum

aenum中创建常量并在创建类后将其添加都会使所有类信息都没有聚集在一个地方。

当然可以在适当的时候使用Mixins(有关示例,请参阅dnozay的答案),但也可以通过使用基本aenum80内置基本常量的类来简化这种情况。

首先,将在以下示例中使用的常量:

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)

和一次性Enum示例:

from enum import Enum

class Planet(Enum):
    MERCURY = (3.303e+23, 2.4397e6)
    VENUS   = (4.869e+24, 6.0518e6)
    EARTH   = (5.976e+24, 6.37814e6)
    MARS    = (6.421e+23, 3.3972e6)
    JUPITER = (1.9e+27,   7.1492e7)
    SATURN  = (5.688e+26, 6.0268e7)
    URANUS  = (8.686e+25, 2.5559e7)
    NEPTUNE = (1.024e+26, 2.4746e7)

    # universal gravitational constant
    G = Constant(6.67300E-11)

    def __init__(self, mass, radius):
        self.mass = mass       # in kilograms
        self.radius = radius   # in meters
    @property
    def surface_gravity(self):
        return self.G * self.mass / (self.radius * self.radius)

print(Planet.__dict__['G'])             # Constant(6.673e-11)
print(Planet.G)                         # 6.673e-11
print(Planet.NEPTUNE.G)                 # 6.673e-11
print(Planet.SATURN.surface_gravity)    # 10.44978014597121

最后,多用途枚举示例:

from enum import Enum

class AstronomicalObject(Enum):

    # universal gravitational constant
    G = Constant(6.67300E-11)

    def __init__(self, mass, radius):
        self.mass = mass
        self.radius = radius
    @property
    def surface_gravity(self):
        return self.G * self.mass / (self.radius * self.radius)

class Planet(AstronomicalObject):
    MERCURY = (3.303e+23, 2.4397e6)
    VENUS   = (4.869e+24, 6.0518e6)
    EARTH   = (5.976e+24, 6.37814e6)
    MARS    = (6.421e+23, 3.3972e6)
    JUPITER = (1.9e+27,   7.1492e7)
    SATURN  = (5.688e+26, 6.0268e7)
    URANUS  = (8.686e+25, 2.5559e7)
    NEPTUNE = (1.024e+26, 2.4746e7)

class Asteroid(AstronomicalObject):
    CERES = (9.4e+20 , 4.75e+5)
    PALLAS = (2.068e+20, 2.72e+5)
    JUNOS = (2.82e+19, 2.29e+5)
    VESTA = (2.632e+20 ,2.62e+5

Planet.MERCURY.surface_gravity    # 3.7030267229659395
Asteroid.CERES.surface_gravity    # 0.27801085872576176

注意:

aenum Enum确实不是。 一个人可以将G重新绑定到其他东西:

Planet.G = 1

如果您确实需要使其恒定(也就是不可重新绑定),请使用新的aenum库[1],它将阻止重新分配aenums和Enum成员的尝试。


1披露:我是Python stdlib aenumaenum backport和Advanced Enumeration(aenum)库的作者。

Ethan Furman answered 2020-02-14T10:07:01Z
15 votes

最优雅的解决方案(IMHO)是使用mixins /基类提供正确的行为。

  • 基类,以提供所有实现(例如,通用)所需的行为 EnumPlanet
  • 如果您决定提供可选的行为,mixins很有趣(例如EnumPlanet可能必须提供其他行为)

这是一个示例,您首先定义行为:

#
# business as usual, define your class, methods, constants...
#
class AstronomicalObject:
    # universal gravitational constant
    G = 6.67300E-11
    def __init__(self, mass, radius):
        self.mass = mass       # in kilograms
        self.radius = radius   # in meters

class PlanetModel(AstronomicalObject):
    @property
    def surface_gravity(self):
        return self.G * self.mass / (self.radius * self.radius)

class SatelliteModel(AstronomicalObject):
    FUEL_PRICE_PER_KG = 20000
    @property
    def fuel_cost(self):
        return self.FUEL_PRICE_PER_KG * self.mass
    def falling_rate(self, destination):
        return complicated_formula(self.G, self.mass, destination)

然后使用正确的基类/混合创建Enum

#
# then create your Enum with the correct model.
#
class Planet(PlanetModel, Enum):
    MERCURY = (3.303e+23, 2.4397e6)
    VENUS   = (4.869e+24, 6.0518e6)
    EARTH   = (5.976e+24, 6.37814e6)
    MARS    = (6.421e+23, 3.3972e6)
    JUPITER = (1.9e+27,   7.1492e7)
    SATURN  = (5.688e+26, 6.0268e7)
    URANUS  = (8.686e+25, 2.5559e7)
    NEPTUNE = (1.024e+26, 2.4746e7)

class Satellite(SatelliteModel, Enum):
    GPS1 = (12.0, 1.7)
    GPS2 = (22.0, 1.5)
dnozay answered 2020-02-14T10:07:43Z
9 votes
from enum import Enum


class classproperty(object):
    """A class property decorator"""

    def __init__(self, getter):
        self.getter = getter

    def __get__(self, instance, owner):
        return self.getter(owner)


class classconstant(object):
    """A constant property from given value,
       visible in class and instances"""

    def __init__(self, value):
        self.value = value

    def __get__(self, instance, owner):
        return self.value


class strictclassconstant(classconstant):
    """A constant property that is
       callable only from the class """

    def __get__(self, instance, owner):
        if instance:
            raise AttributeError(
                "Strict class constants are not available in instances")

        return self.value


class Planet(Enum):
    MERCURY = (3.303e+23, 2.4397e6)
    VENUS   = (4.869e+24, 6.0518e6)
    EARTH   = (5.976e+24, 6.37814e6)
    MARS    = (6.421e+23, 3.3972e6)
    JUPITER = (1.9e+27,   7.1492e7)
    SATURN  = (5.688e+26, 6.0268e7)
    URANUS  = (8.686e+25, 2.5559e7)
    NEPTUNE = (1.024e+26, 2.4746e7)
    def __init__(self, mass, radius):
        self.mass = mass       # in kilograms
        self.radius = radius   # in meters

    G = classconstant(6.67300E-11)

    @property
    def surface_gravity(self):
        # universal gravitational constant  (m3 kg-1 s-2)
        return Planet.G * self.mass / (self.radius * self.radius)


print(Planet.MERCURY.surface_gravity)
print(Planet.G)
print(Planet.MERCURY.G)

class ConstantExample(Enum):
    HAM  = 1
    SPAM = 2


    @classproperty
    def c1(cls):
        return 1

    c2 = classconstant(2)

    c3 = strictclassconstant(3)

print(ConstantExample.c1, ConstantExample.HAM.c1)
print(ConstantExample.c2, ConstantExample.SPAM.c2)
print(ConstantExample.c3)


# This should fail:
print(ConstantExample.HAM.c3)

@property不起作用而classconstant DOES起作用的原因很简单,并在此处的答案中进行了解释

访问时返回实际属性对象的原因   它通过类Hello.foo的属性在于该属性如何实现   classproperty特殊方法。 如果在实例上访问了描述符,则该实例作为   适当的参数,而owner是该实例的类。

另一方面,如果通过类访问它,则实例   为“无”,仅传递所有者。 属性对象可以识别   并返回自我。

因此,classproperty中的代码实际上是property的概括,缺少if instance is None部分。

Antti Haapala answered 2020-02-14T10:12:51Z
4 votes

property可用于提供类常量的大多数行为:

class Planet(Enum):

    # ...

    @property
    def G(self):
        return 6.67300E-11

    # ...

    @property
    def surface_gravity(self):
        return self.G * self.mass / (self.radius * self.radius)

如果要定义大量的常量,这将有点麻烦,因此可以在类外部定义一个辅助函数:

def constant(c):
    """Return a class property that returns `c`."""
    return property(lambda self: c)

...并按以下方式使用:

class Planet(Enum):

    # ...

    G = constant(6.67300E-11)

这种方法的局限性在于它仅适用于类的实例,而不适用于类本身:

>>> Planet.EARTH.G
6.673e-11
>>> Planet.G
<property object at 0x7f665921ce58>
Zero Piraeus answered 2020-02-14T10:13:26Z
-2 votes

TLDR; 不,它不能在Enum类内完成。

这就是说,正如其他答案所显示的那样,有多种方法可以获取与枚举关联的此类拥有的值(即通过类继承/混合),但此类值不是“在枚举内部定义的”。

ABri answered 2020-02-14T10:13:51Z
translate from https://stackoverflow.com:/questions/17911188/is-it-possible-to-define-a-class-constant-inside-an-enum