Ist es möglich, eine Klasse zu definieren Konstante innerhalb einer Enum?

Python 3.4 bringt ein neues Modul enum, die fügt eine der Aufzählungstyp um die Sprache. Die Dokumentation für enum.Enum bietet ein Beispiel zu zeigen, wie es kann erweitert werden:

>>> 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

Diesem Beispiel wird außerdem veranschaulicht ein problem mit Enum: in der surface_gravity() Eigenschaft Methode, eine Konstante G definiert, die normalerweise definiert werden, die auf Klassen-Ebene - aber Versuch zu tun, so innerhalb von ein Enum würde einfach hinzufügen, dass es als eines der Mitglieder der enum, so dass anstelle es definiert wurden, die innerhalb der Methode.

Wenn die Klasse wollte diese Konstante verwenden, die in anderen Methoden, es müsste definiert werden, die es als gut, was natürlich nicht ideal ist.

Gibt es eine Möglichkeit, eine Klasse zu definieren Konstanten, die innerhalb einer Enum oder einige Abhilfe, um den gleichen Effekt erzielen?

Was ist das problem mit einem Modul-Ebene konstant?
manchmal eine Konstante ist spezifisch für eine Klasse.
Ich weiß, das Beispiel ist aus dem offiziellen Google docs, aber ist es wirklich eine gute Idee? Dies könnte ein has-a Beziehung statt is-a.

InformationsquelleAutor Zero Piraeus | 2013-07-28

Dies ist die erweiterte Verhalten, die nicht benötigt werden in 90+% der Aufzählungen erstellt.

Laut der docs:

Die Regeln, was erlaubt ist, sind wie folgt: _sunder_ Namen (beginnend und endend mit einem einzigen Unterstrich) sind reserviert für enum und kann nicht verwendet werden; alle anderen Attribute definiert innerhalb einer enumeration werden Mitglieder dieser Aufzählung, mit der Ausnahme von __dunder__ Namen und descriptors (Methoden werden auch Deskriptoren).

Wenn Sie So wollen, eine klassenkonstante haben Sie mehrere Möglichkeiten:

es schaffen, in __init__
hinzufügen nachdem die Klasse erstellt wurde
verwenden Sie ein mixin
erstellen Sie Ihre eigenen descriptor

Erstellen die Konstante in __init__ und hinzufügen nachdem die Klasse erstellt wurde, die beide darunter leiden, dass nicht alle die Klasse info an einem Ort versammelt.

Mixins in Verbindung kann sicherlich verwendet werden, wenn entsprechende (sehen dnozay Antwort für ein gutes Beispiel), aber in diesem Fall kann auch vereinfacht werden, indem mit einer base Enum Klasse mit den tatsächlichen Konstanten eingebaut.

Erste, die Konstante, die verwendet werden in den folgenden Beispielen:

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)

Und die single-use-Enum-Beispiel:

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

Und, schließlich, die multi-use-Enum-Beispiel:

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

Hinweis:

Den Constant G wirklich nicht. Man könnte rebind G um etwas anderes:

Planet.G = 1

Wenn Sie es wirklich brauchen, um konstant sein (aka nicht rebindable), dann verwenden Sie die neue aenum Bibliothek [1], die blockieren, weisen Sie constants sowie Enum Mitglieder.

¹ Offenlegung: ich bin der Autor des Python stdlib Enum, die enum34 backport, und die Erweiterte Aufzählung (aenum) Bibliothek.

Ist es ein Vorteil oder ein Nachteil für Ihre Constant Klasse über die classconstant() Funktion zurückgeben ein Verschluss @AnttiHaapala vorgeschlagen? Ich merke, dass Planet.__dict__['G'] hat eine etwas schönere repr in Ihrer version; gibt es sonst noch etwas?
Es ist einfacher und leichter zu Lesen, daher mehr pythonic 😉 . Wenn Sie möchten ein schönes __repr__, hinzufügen. Ich hatte es gerade getan.
Hmm ja, ich bin am überlegen wie, was sollte ich denken, wenn mit einem Verschluss.
Ich verstehe, was du meinst; aber für mich eine kanonische Antwort bedeutet beste/standard/autorisierend das ist unterschiedlich erschöpfend/vollständig.
Ich meine nicht zu beleidigen. Sowohl meine ursprüngliche Lösung und dein haben Ihren Platz. Weil das so ist, ist die kanonische Antwort dürfte, zählen die beiden von Ihnen.

InformationsquelleAutor Ethan Furman

Die eleganteste Lösung (IMHO) ist die Verwendung von Mixins in Verbindung /base-Klasse zu bieten das richtige Verhalten.

Basis-Klasse, das Verhalten, das nötig ist, damit alle die Umsetzung, die ist üblich, z.B. Satellite und Planet.
Mixins in Verbindung sind interessant wenn Sie sich entschließen, optionales Verhalten (z.B. Satellite und Planet eventuell ein anderes Verhalten)

Hier ist ein Beispiel, wo definieren Sie zunächst Ihr Verhalten:

#
# 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)

Dann erstellen Sie Ihre Enum mit der richtigen base-classes /Mixins in Verbindung.

#
# 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)

Sie haben einen kleinen Fehler: G = Constant(6.67300E-11) sollte G = 6.67300E-11.
fixed, danke für den Fang, die.
Ich überarbeitete meine Antwort darauf zu verkaufen für die mixin-Beispiel. Bitte nicht immer löschen Ihre Antwort. 😉

InformationsquelleAutor dnozay

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)

Der Grund, warum @ - Eigenschaft funktioniert NICHT und classconstant funktioniert ist ganz einfach, und erklärt, in der Antwort hier

Dem Grund, dass die tatsächliche property-Objekt wird zurückgegeben, wenn Sie Zugang
über eine Klasse Hallo.foo liegt darin, wie die Eigenschaft implementiert die
__get__(self, instance, owner) spezielle Methode. Wenn ein Deskriptor ist der Zugriff auf eine Instanz, dann wird die Instanz übergeben wird, als die
geeignete argument, der Eigentümer ist die Klasse der Instanz.

Auf der anderen Seite, wenn der Zugriff über die Klasse, dann Instanz
ist Keine, und nur Besitzer übergeben wird. Das property-Objekt erkennt dies
und gibt selbst.

Damit, den code in classproperty ist eigentlich eine Verallgemeinerung von property sind, fehlt die if instance is None Teil.

Etwas wurde geändert von python 2; in python 2 irgendwann, wenn get throws AttributeError, auf der Außenseite ist es gezeigt, einfach als "Bar-Objekt hat kein Attribut foo", aber nicht der Fall zu sein scheint, auf Python 3 nicht mehr.

InformationsquelleAutor Antti Haapala

Einen Eigenschaft kann verwendet werden, um die meisten, die das Verhalten einer Klasse Konstante:

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)

Das wäre ein wenig aufwendig, wenn Sie wollten, um zu definieren, eine große Anzahl von Konstanten, so könnte man definieren, eine helper-Funktion außerhalb der Klasse:

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

... und verwenden Sie es wie folgt:

class Planet(Enum):

    # ...

    G = constant(6.67300E-11)

Einer Einschränkung dieses Ansatzes ist, dass es funktioniert nur für Instanzen der Klasse und nicht die Klasse selbst:

>>> Planet.EARTH.G
6.673e-11
>>> Planet.G
<property object at 0x7f665921ce58>

InformationsquelleAutor Zero Piraeus

-2

TLDR; NEIN, es kann nicht getan werden, innerhalb einer Enum-Klasse.

Sagte dieser, wie die anderen Antworten zeigten, es gibt Möglichkeiten zu bekommen, wie Klasse Eigentum verbundenen Werte einer Enum (D. H. über Vererbung /Mixins in Verbindung), aber solche Werte sind nicht "definiert .. innerhalb einer Enum".

InformationsquelleAutor ABri

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.