Associating string representations with an Enum that uses integer values?

Another solution I came up with is, since both the integers and the strings are meaningful, was to make the Enum values (int, str) tuples, as follows.

from enum import Enum

class Fingers(Enum):
    THUMB = (1, 'thumb')
    INDEX = (2, 'index')
    MIDDLE = (3, 'middle')
    RING = (4, 'ring')
    PINKY = (5, 'pinky')

    def __str__(self):
        return self.value[1]

    @classmethod
    def from_string(cls, s):
        for finger in cls:
            if finger.value[1] == s:
                return finger
        raise ValueError(cls.__name__ + ' has no value matching "' + s + '"')

However, this means that a Fingers object’s repr will display the tuple rather than just the int, and the complete tuple must be used to create Fingers objects, not just the int. I.e. You can do f = Fingers((1, 'thumb')), but not f = Fingers(1).

>>> Fingers.THUMB
<Fingers.THUMB: (1, 'thumb')>
>>> Fingers((1,'thumb'))
<Fingers.THUMB: (1, 'thumb')>
>>> Fingers(1)
Traceback (most recent call last):
  File "<pyshell#25>", line 1, in <module>
    Fingers(1)
  File "C:PythonPython35libenum.py", line 241, in __call__
    return cls.__new__(cls, value)
  File "C:PythonPython35libenum.py", line 476, in __new__
    raise ValueError("%r is not a valid %s" % (value, cls.__name__))
ValueError: 1 is not a valid Fingers

An even more complex workaround for that involves subclassing Enum‘s metaclass to implement a custom __call__. (At least overriding __repr__ is much simpler!)

from enum import Enum, EnumMeta

class IntStrTupleEnumMeta(EnumMeta):
    def __call__(cls, value, names=None, *args, **kwargs):
        if names is None and isinstance(value, int):
            for e in cls:
                if e.value[0] == value:
                    return e

        return super().__call__(value, names, **kwargs)

class IntStrTupleEnum(Enum, metaclass=IntStrTupleEnumMeta):
    pass

class Fingers(IntStrTupleEnum):
    THUMB = (1, 'thumb')
    INDEX = (2, 'index')
    MIDDLE = (3, 'middle')
    RING = (4, 'ring')
    PINKY = (5, 'pinky')

    def __str__(self):
        return self.value[1]

    @classmethod
    def from_string(cls, s):
        for finger in cls:
            if finger.value[1] == s:
                return finger
        raise ValueError(cls.__name__ + ' has no value matching "' + s + '"')

    def __repr__(self):
        return '<%s.%s %s>' % (self.__class__.__name__, self.name, self.value[0])

One difference between this implementation and a plain int Enum is that values with the same integer value but a different string (e.g. INDEX = (2, 'index') and POINTER = (2, 'pointer')) would not evaluate as the same Finger object, whereas with a plain int Enum, Finger.POINTER is Finger.INDEX would evaluate to True.

Maybe I am missing the point here, but if you define

class Fingers(Enum):
    THUMB = 1
    INDEX = 2
    MIDDLE = 3
    RING = 4
    PINKY = 5

then in Python 3.6 you can do

print (Fingers.THUMB.name.lower())

which I think is what you want.

I had same issue where I wanted display strings for a GUI ComboBox (in PyGTK).
I dun’t know about the Pythonicity (is that even a word?) of the solution but I used this:

from enum import IntEnum
class Finger(IntEnum):
    THUMB = 1
    INDEX = 2
    MIDDLE = 3
    RING = 4
    PINKY = 5

    @classmethod
    def names(cls):
        return ["Thumb", "Index", "Middle", "Ring", "Pinky"]

    @classmethod
    def tostr(cls, value):
        return cls.names()[value - cls.THUMB]

    @classmethod
    def toint(cls, s):
        return cls.names().index(s) + cls.THUMB

Using them from your code:

>>> print(Finger.INDEX)
Finger.INDEX
>>> print(Finger.tostr(Finger.THUMB))
Thumb
>>> print(Finger.toint("Ring"))
4

Although this is not what OP has asked, but still this is one good option when you do not care if the value is int or not. You can use the value as the human readable string.

Source: https://docs.python.org/3/library/enum.html

Omitting values
In many use-cases one doesn’t care what the actual value of an enumeration is. There are several ways to define this type of simple enumeration:

• use auto() for the value
• use instances of object as the value
• use a descriptive str as the value
• use a tuple as the value and a custom new() to replace the tuple
  with an int value

Using any of these techniques signifies to the user that these values are not important, and also enables one to add, remove, or reorder members without having to renumber the remaining members.

Whichever method you choose, you should provide a repr() that also hides the (unimportant) value:

class NoValue(Enum):
     def __repr__(self):
         return '<%s.%s>' % (self.__class__.__name__, self.name)

Using a descriptive string
Using a string as the value would look like:

class Color(NoValue):
     RED = 'stop'
     GREEN = 'go'
     BLUE = 'too fast!'

Color.BLUE
<Color.BLUE>
Color.BLUE.value
'too fast!'

The python docs have a somewhat abstract example here, from which I was able to come up with this solution

I have added an explanation inline, as comments.

# we could also do class Finger(IntEnum) it's equivalent.
class Finger(int, Enum):
    def __new__(cls, value, label):
        # Initialise an instance of the Finger enum class 
        obj = int.__new__(cls, value)
        # Calling print(type(obj)) returns <enum 'Finger'>
        # If we don't set the _value_ in the Enum class, an error will be raised.
        obj._value_ = value
        # Here we add an attribute to the finger class on the fly.
        # One may want to use setattr to be more explicit; note the python docs don't do this
        obj.label = label
        return obj

    THUMB = (1, 'thumb')
    INDEX = (2, 'index')
    MIDDLE = (3, 'middle')
    RING = (4, 'ring')
    PINKY = (5, 'pinky')

    @classmethod
    def from_str(cls, input_str):
        for finger in cls:
            if finger.label == input_str:
                return finger
        raise ValueError(f"{cls.__name__} has no value matching {input_str}")

So let’s test it.

In [99]: Finger(1)
Out[99]: <Finger.THUMB: 1>

In [100]: Finger.from_str("thumb")
Out[100]: <Finger.THUMB: 1>

In [101]: Finger.THUMB
Out[101]: <Finger.THUMB: 1>

In [102]: Finger.THUMB.label
Out[102]: 'thumb'

The last test here is quite important, the __str__ method is automatically created depending on the inheritance class Finger(int, Enum).

If this was instead class Finger(str, Enum) and obj = int.__new__(cls, value) became obj = str.__new__(cls, value) all the checks above would work but the call to __str__ would’ve raised an error.

In [103]: f"Finger.THUMB"
Out[103]: '1'

An example of it being used in python3 standard library http.HTTPStatus

Just implement it like the .value property:

from enum import Enum

class SomeEnum(Enum):
    FOO = 0
    BAR = 1

print(SomeEnum.FOO.value)
# prints 0

Now just implement your own str_value property for a string:

class SomeEnum(Enum):
    FOO = 0
    BAR = 1

    @property
    def str_value(self):
        if self.value == 0:
            return "this is foo"

        return "this is bar"
    
print(SomeEnum.BAR.str_value)
# prints "this is bar"