如何从python枚举类中获得所有值?

我使用Enum4库创建一个枚举类如下:

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

我想将[1, 2]打印为一个列表。我怎样才能做到这一点呢?

242520 次浏览
小开
最佳答案

你可以使用IntEnum:

from enum import IntEnum


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




print(int(Color.RED))   # prints 1

获取整型数组的列表:

enum_list = list(map(int, Color))
print(enum_list) # prints [1, 2]
小开

您可以执行以下操作:

[e.value for e in Color]
小开
所以Enum有一个__members__字典。 @ozgur提出的解决方案确实是最好的，但你可以这样做，它做同样的事情，需要更多的工作

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

__members__字典可以派上用场，如果你想在其中动态地插入东西…在一些疯狂的情况下。

<强>[编辑] 显然__members__不是一个字典，而是一个映射代理。这意味着你不能轻易地添加项目。

然而，你可以做一些奇怪的事情，比如MyEnum.__dict__['_member_map_']['new_key'] = 'new_value'，然后你可以使用像MyEnum.new_key....这样的新键但这只是一个实现细节，不应该玩弄。黑魔法需要大量的维护费用。

小开

要对任何类型的值使用Enum，请尝试:
更新了一些改进…谢谢@杰夫，谢谢你的小费!< / p > 

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

结果:

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

类enum.Enum是一个解决你所有枚举需求的类，所以你只需要继承它，并添加你自己的字段。然后从那时起，你所需要做的就是调用它的属性: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}
小开

基于@Jeff的回答，重构为使用classmethod，以便您可以对任何枚举重用相同的代码:

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

生产:

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

如果只是名称，则使用_member_names_来快速简便地得到结果。

Color._member_names_

还有_member_map_，它返回元素的有序字典。这个函数返回collections.OrderedDict，所以你可以使用Color._member_map_.items()和Color._member_map_.values()。如。

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

将返回颜色的所有有效值

小开

使用classmethod和__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)

或者如果你有多个Enum类，并且想要抽象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"
小开

给定一个基于标准python3 enum /IntEnum类的枚举:

from enum import IntEnum


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

可以执行以下操作来获取枚举常量列表:

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

我发现使用枚举常量比使用int型更有表现力。如果枚举从IntEnum继承，则所有枚举常量也是int型，并且可以在任何地方使用:

>>> level = LogLevel.DEBUG


>>> level == 0
True


>>> level == 1
False


>>> level == LogLevel.INFO
False


>>> level == LogLevel.DEBUG
True


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


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

一种方法是获取_value2member_map_属性的键值:

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


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

你可以有这样的SuperEnum:

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

像这样使用它:

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

所以你可以:

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

只使用:

[e.value for e in Color]

生产:

[1,2]

要获得名称，请使用:

[e.name for e in Color]

生产:

(“红”、“蓝”)

小开

这里有一些例子，可以轻松地将Enum转换为int, str或Enum的列表/数组，并能够排序。

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

输出:

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

提交答案