1. 枚举的定义与使用

1.1 枚举定义

和定义类一样，枚举使用class关键字定义。枚举元素的类型为枚举类型本身（即每个元素都是枚举类型的实例），每个元素有两个固定属性（name 和 value），name 属性区分不同的枚举元素（即不能重复）。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import enum                 # 导入枚举模块
class Color(enum.Enum):     # 定义一个名为 Color 的枚举（继承 enum.Enum）
    red = 1                 # 定义枚举元素: name 为 "red", value 为 1
    green = 2
    blue = 3
    red_alias = 1

1.2 枚举元素的访问

print(Color.red)            # 引用枚举元素, 输出: Color.red
print(Color["red"])         # 通过 name 引用枚举元素, 输出: Color.red
print(Color(1))             # 通过 value 检索元素（返回最先匹配的元素）, 输出: Color.red
print(type(Color.red))      # 元素的类型为枚举类型 Color, 输出: <enum 'Color'>
print(type(Color))          # 枚举类型的类型为类 enum.EnumMeta, 输出: <class 'enum.EnumMeta'>
print(Color.red.name)       # 输出: "red"
print(Color.red.value)      # 输出: 1

1.3 枚举元素的比较

枚举元素支持等值比较，不支持大小的比较。

# 枚举元素的 == 和 != 比较的是其 value 值, value 值相等则枚举元素相等
print(Color.red == Color.red_alias)             # 输出: True
print(Color.red != Color.green)                 # 输出: True
# 枚举元素的 is 和 is not 比较的是也是其 value 值（相当于 == 和 !=）
print(Color.red is Color.red_alias)             # 输出: True
print(Color.red is not Color.green)             # 输出: True

1.4 枚举元素的遍历

枚举元素的遍历，普通的遍历 value 相同的元素只输出 1 次。

for c in Color:
    print(c)        # 逐次输出: Color.red
                    # Color.green
                    # Color.blue

枚举类型有一个特殊属性__members__，表示枚举类型的所有元素的name->value映射列表。

# 遍历 Color.__members__, 迭代变量的值为 name
for name in Color.__members__:
    print(name, Color[name])    # 逐次输出: "red" Color.red
                                # "green" Color.green
                                # "blue" Color.blue
                                # "red_alias" Color.red_alias
# 遍历 Color.__members__.items(), 迭代变量的值为 name, Color
for name, c in Color.__members__.items():
    print(name, c)              # 逐次输出: "red" Color.red
                                # "green" Color.green
                                # "blue" Color.blue
                                # "red_alias" Color.red_alias

2. @enum.unique 装饰器

默认情况下，枚举的不同元素的 value 值允许相同，如果多个 value 值相同的成员，则后面的成员将被视为第一个成员的别名。

如果需要确保运行时枚举元素的 value 值唯一，可以使用@enum.unique装饰器修饰枚举类型。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import enum                 # 导入枚举模块
@enum.unique                # 使用 @enum.unique 修饰枚举类型, 如果存在 value 值相同的元素, 运行时将报错
class Color(enum.Enum):     # 定义一个名为 Color 的枚举（继承 enum.Enum）
    red = 1                 # 定义枚举元素: name 为 "red", value 为 1
    green = 2
    blue = 3

3. 枚举类型中添加方法

枚举类型不但能添加类型元素，还能和普通类一样添加方法。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import enum
@enum.unique
class Color(enum.Enum):
    """ 一个枚举类 """
    red = 1
    """ 枚举元素 red """
    green = 2
    blue = 3
    def fun(self):
        """ 枚举对象的方法, self 表示枚举对象（元素） """
        print("Enum:", self.name, "->", self.value)
    @staticmethod
    def static_fun():
        """ 枚举类的静态方法 """
        print("static_fun")
    @classmethod
    def class_fun(cls):
        """ 枚举类的类方法, cls 表示枚举类型 Color """
        print("class_fun:", cls)
Color.red.fun()         # 通过枚举对象（元素）调用对象方法, 输出: Enum: red -> 1
Color.static_fun()      # 通过枚举类型直接调用静态方法, 输出: static_fun
Color.class_fun()       # 通过枚举类型直接调用类方法, 输出: class_fun: <enum 'Color'>

4. 动态创建枚举类型

一般定义枚举类型通过class关键字在代码中定义，通过enum.Enum(...)构造方法也可以在运行时动态创建和一个枚举类型。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import enum
# 定义一个枚举类型
# 第 1 个字符串参数表示枚举类型名称（等号左边的 Color 仅为变量名称, 可以是任意合法标识符）
# 第 2 个元组参数表示所有枚举元素的名称(name), 其中元素的 value 值默认为从 1 开始的整数
Color = enum.Enum("Color", ("red", "green", "blue"))
# 遍历
for c in Color:
    print(c, ":", c.name, "->", c.value)    # 输出: Color.red : red -> 1
                                            # Color.green : green -> 2
                                            # Color.blue : blue -> 3
print(Color.red)            # 输出: Color.red
print(Color["red"])         # 输出: Color.red
print(Color(1))             # 输出: Color.red
print(type(Color.red))      # 输出: <enum 'Color'>
print(Color)                # 输出: <enum 'Color'>
print(type(Color))          # 输出: <class 'enum.EnumMeta'>