How to get all values from python enum class?

You can do the following:

[e.value for e in Color]

So the Enum has a __members__ dict.
The solution that @ozgur proposed is really the best, but you can do this, which does the same thing, with more work

[color.value for color_name, color in Color.__members__.items()]

The __members__ dictionary could come in handy if you wanted to insert stuff dynamically in it… in some crazy situation.

[EDIT]
Apparently __members__ is not a dictionary, but a map proxy. Which means you can’t easily add items to it.

You can however do weird stuff like MyEnum.__dict__['_member_map_']['new_key'] = 'new_value', and then you can use the new key like MyEnum.new_key…. but this is just an implementation detail, and should not be played with. Black magic is payed for with huge maintenance costs.

To use Enum with any type of value, try this:
Updated with some improvements… Thanks @Jeff, by your tip!

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 'GREEN'
    BLUE = ('blue', '#0000ff')

    @staticmethod
    def list():
        return list(map(lambda c: c.value, Color))

print(Color.list())

As result:

[1, 'GREEN', ('blue', '#0000ff')]

class enum.Enum is a class that solves all your enumeration needs, so you just need to inherit from it, and add your own fields. Then from then on, all you need to do is to just call it’s attributes: name & value:

from enum import Enum

class Letter(Enum):
   A = 1
   B = 2
   C = 3

print({i.name: i.value for i in Letter})
# prints {'A': 1, 'B': 2, 'C': 3}

Based on the answer by @Jeff, refactored to use a classmethod so that you can reuse the same code for any of your enums:

from enum import Enum

class ExtendedEnum(Enum):

    @classmethod
    def list(cls):
        return list(map(lambda c: c.value, cls))

class OperationType(ExtendedEnum):
    CREATE = 'CREATE'
    STATUS = 'STATUS'
    EXPAND = 'EXPAND'
    DELETE = 'DELETE'

print(OperationType.list())

Produces:

['CREATE', 'STATUS', 'EXPAND', 'DELETE']

Use _member_names_ for a quick easy result if it is just the names, i.e.

Color._member_names_

Also, you have _member_map_ which returns an ordered dictionary of the elements. This function returns a collections.OrderedDict, so you have Color._member_map_.items() and Color._member_map_.values() to play with. E.g.

return list(map(lambda x: x.value, Color._member_map_.values()))

will return all the valid values of Color

Using a classmethod with __members__:

class RoleNames(str, Enum):
    AGENT = "agent"
    USER = "user"
    PRIMARY_USER = "primary_user"
    SUPER_USER = "super_user"
    
    @classmethod
    def list_roles(cls):
        role_names = [member.value for role, member in cls.__members__.items()]
        return role_names

>>> role_names = RoleNames.list_roles()
>>> print(role_names)

or if you have multiple Enum classes and want to abstract the classmethod:

class BaseEnum(Enum):
    @classmethod
    def list_roles(cls):
        role_names = [member.value for role, member in cls.__members__.items()]
        return role_names


class RoleNames(str, BaseEnum):    
    AGENT = "agent"
    USER = "user"
    PRIMARY_USER = "primary_user"
    SUPER_USER = "super_user"
    

class PermissionNames(str, BaseEnum):
    READ = "updated_at"
    WRITE = "sort_by"
    READ_WRITE = "sort_order"

Given an enum based on the standard python3 Enum/IntEnum classes:

from enum import IntEnum

class LogLevel(IntEnum):
    DEBUG = 0
    INFO = 1
    WARNING = 2
    ERROR = 3

one can do the following to get a list of enum constants:

>>> print(list(LogLevel))
[<LogLevel.DEBUG: 0>, <LogLevel.INFO: 1>, <LogLevel.WARNING: 2>, <LogLevel.ERROR: 3>]

I find it more expressive to work on enum constants instead of ints. If the enum is inheriting from IntEnum, all enum constants are also ints and can used as such everywhere:

>>> level = LogLevel.DEBUG

>>> level == 0
True

>>> level == 1
False

>>> level == LogLevel.INFO
False

>>> level == LogLevel.DEBUG
True

>>> "%d" % level
'0'

>>> "%s" % level
'LogLevel.DEBUG'

One way is to get the keys of the _value2member_map_ property:

class Color(Enum):
    RED = 1
    BLUE = 2

list(Color._value2member_map_.keys())
# [1, 2]

You can have a SuperEnum like:

from enum import Enum

class SuperEnum(Enum):    
    @classmethod
    def to_dict(cls):
        """Returns a dictionary representation of the enum."""
        return {e.name: e.value for e in cls}
    
    @classmethod
    def keys(cls):
        """Returns a list of all the enum keys."""
        return cls._member_names_
    
    @classmethod
    def values(cls):
        """Returns a list of all the enum values."""
        return list(cls._value2member_map_.keys())

and use it like:

class Roles(SuperEnum):
    ADMIN = 1
    USER = 2
    GUEST = 3

so you can:

Roles.to_dict() # {'ADMIN': 1, 'USER': 2, 'GUEST': 3}
Roles.keys() # ['ADMIN', 'USER', 'GUEST']
Roles.values() # [1, 2, 3]

Just use:

[e.value for e in Color]

Produces:

[1, 2]

And to get the names, use:

[e.name for e in Color]

Produces:

[‘RED’, ‘BLUE’]

Here are some examples to easily convert Enum to a list/array of int, str, or Enum AND be able to sort.

import numpy as np

class Color(int,Enum):
    YELLOW = 3
    RED = 1
    BLUE = 2
    
print('1):',list(Color))
print('2):',np.array(list(Color))) ## int64 (8 bytes)
print('3):',sorted(np.array(Color, dtype=str)))
print('4):',np.array(sorted(Color), dtype=object))
print('5):',np.array(sorted(Color), dtype=np.int8)) # 1 byte
print('6):',np.array(sorted(Color, key=lambda x: -x.value), dtype=np.int8))
print('7):',np.array(sorted(Color, key=lambda x: str(x)), dtype=np.int8))

class Color(tuple,Enum):
    YELLOW = (3,3)
    RED = (1,1)
    BLUE = (2,2)
    
print('8):',np.array(sorted(Color)))
print('9):',list(map(tuple,sorted(Color, key=lambda x: -x[1]))))

Output:

1): [<Color.YELLOW: 3>, <Color.RED: 1>, <Color.BLUE: 2>]
2): [3 1 2]
3): ['Color.BLUE', 'Color.RED', 'Color.YELLOW']
4): [<Color.RED: 1> <Color.BLUE: 2> <Color.YELLOW: 3>]
5): [1 2 3]
6): [3 2 1]
7): [2 1 3]
8): [[1 1]
 [2 2]
 [3 3]]
9): [(3, 3), (2, 2), (1, 1)]