Automatisches festlegen einer enum-Mitglied Wert auf seinen Namen

Update: 2017-03-01

In Python 3.6 (und Aenum 2.0¹) Flag und IntFlag Klassen Hinzugefügt worden; ein Teil wurde eine neue auto() Helfer macht dies trivial einfach:

>>> class AutoName(Enum):
...     def _generate_next_value_(name, start, count, last_values):
...         return name
...
>>> class Ordinal(AutoName):
...     NORTH = auto()
...     SOUTH = auto()
...     EAST = auto()
...     WEST = auto()
...
>>> list(Ordinal)
[<Ordinal.NORTH: 'NORTH'>, <Ordinal.SOUTH: 'SOUTH'>, <Ordinal.EAST: 'EAST'>, <Ordinal.WEST: 'WEST'>]

Ursprüngliche Antwort

Die Schwierigkeit, mit einem AutoStr Klasse ist, dass der name des enum-Mitglied ist nicht bestanden in den code, der es schafft, so ist es für die Verwendung nicht verfügbar. Andere Falten ist, dass str unveränderlich ist, so können wir nicht ändern, diese Typen von Enumerationen, die, nachdem Sie erstellt wurden (mit einem Klasse decorator, zum Beispiel).

Ist die einfachste Sache zu tun ist, verwenden Sie die Funktionale API:

Animal = Enum('Animal', [(a, a) for a in ('horse', 'dog')], type=str)

gibt uns:

>>> list(Animal)
[<Animal.horse: 'horse'>, <Animal.dog: 'dog'>]

>>> Animal.dog == 'dog'
True

Ist die nächste einfachste Sache zu tun, vorausgesetzt, Sie wollen eine Basis-Klasse für Ihre Zukunft enumeration verwenden, wäre so etwas wie meine DocEnem:

class DocEnum(Enum):
    """
    compares equal to all cased versions of its name
    accepts a doctring for each member
    """
    def __new__(cls, *args):
        """Ignores arguments (will be handled in __init__)"""
        obj = object.__new__(cls)
        obj._value_ = None
        return obj

    def __init__(self, doc=None):
        # first, fix _value_
        self._value_ = self._name_.lower()
        self.__doc__ = doc

    def __eq__(self, other):
        if isinstance(other, basestring):
            return self._value_ == other.lower()
        elif not isinstance(other, self.__class__):
            return NotImplemented
        return self is other

    def __hash__(self):
        # keep DocEnum hashable
        return hash(self._value_)

    def __ne__(self, other):
        return not self == other

und im Einsatz:

class SpecKind(DocEnum):
    REQUIRED = "required value"
    OPTION = "single value per name"
    MULTI = "multiple values per name (list form)"
    FLAG = "boolean value per name"
    KEYWORD = 'unknown options'

Beachten Sie, dass im Gegensatz zu der ersten option DocEnum Mitglieder sind nicht strs.

Wenn Sie es tun möchten die harte Weise: Unterklasse EnumMeta Geige und mit der neuen Enum's Klasse Wörterbuch vor der Mitglieder erstellt werden:

from enum import EnumMeta, Enum, _EnumDict

class StrEnumMeta(EnumMeta):
    def __new__(metacls, cls, bases, oldclassdict):
        """
        Scan through `oldclassdict` and convert any value that is a plain tuple
        into a `str` of the name instead
        """
        newclassdict = _EnumDict()
        for k, v in oldclassdict.items():
            if v == ():
                v = k
            newclassdict[k] = v
        return super().__new__(metacls, cls, bases, newclassdict)

class AutoStrEnum(str, Enum, metaclass=StrEnumMeta):
    "base class for name=value str enums"

class Animal(AutoStrEnum):
    horse = ()
    dog = ()
    whale = ()

print(Animal.horse)
print(Animal.horse == 'horse')
print(Animal.horse.name, Animal.horse.value)

Gibt uns:

Animal.horse
True
horse horse

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