Associate string representations with an Enum that uses integer values?

I'm trying to create an enum that has integer values, but that can also return a display-friendly string for each value. I thought I could just define dict display values ​​for strings and then implement a __str__

static constructor with a string argument as well, but there is a problem with that ...

(In other circumstances, I could just make the underlying datatype for this Enum a string, not an integer, but this is used as a mapping for the enum database table, so integer and string make sense, the first being the primary key.)

from enum import Enum

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

    _display_strings = {
        THUMB: "thumb",
        INDEX: "index",
        MIDDLE: "middle",
        RING: "ring",
        PINKY: "pinky"
        }

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

    @classmethod
    def from_string(cls, str1):
        for val, str2 in cls._display_strings.items():
            if str1 == str2:
                return cls(val)
        raise ValueError(cls.__name__ + ' has no value matching "' + str1 + '"')

      

        
        
        
      

    

When converting to a string, I get the following error:

>>> str(Fingers.RING)
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    str(Fingers.RING)
  File "D:/src/Hacks/PythonEnums/fingers1.py", line 19, in __str__
    return self._display_strings[self.value]
TypeError: 'Fingers' object is not subscriptable

      

        
        
        
      

    

It looks like the problem is that Enum will use all the class variables as enum values, which makes them return objects of type Enum rather than their base type.

Here are some workarounds:

1. Referring to Fingers._display_strings.value
   
   how Fingers._display_strings.value
   
   . (However, then Fingers.__display_strings
   
   it becomes a valid enum value!)
2. Make a dict of a module variable instead of a class variable.
3. Duplicating the dict (possibly breaking it down into a series of statements as well if
   
   ) in the __str__
   
   and functions from_string
   
   .
4. Instead of making the dict a class variable, define a static method _get_display_strings
   
   to return the dict so that it doesn't become an enum value.

Note that in the above source code and 1.

workaround, basic integer values ​​are used as dict keys. Other options all require that the DICT (or, if

tests) be defined somewhere other than directly in the class itself, and therefore it must qualify these values ​​with the class name. So you can use, for example, Fingers.THUMB

to get an enum object, or Fingers.THUMB.value

to get a basic integer value, but not simple THUMB

. If you are using an underlying integer value as the dict key, then you should also use it to search for a word, indexing it with, for example, [Fingers.THUMB.value]

and not just [Fingers.THUMB]

.

So the question is, what is the best or most Pythonic way to implement string mapping for an Enum while still keeping the underlying integer value?