MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Python常量与枚举场景选择指南解读

2021-10-243.9k 阅读

Python 常量与枚举基础概念

Python 常量

在 Python 中，严格意义上并没有像其他一些编程语言那样的常量定义机制。常量通常是指在程序运行过程中其值不能被改变的量。在 Python 中，约定俗成的常量定义方式是使用全大写字母和下划线来命名变量，例如：

PI = 3.14159
MAX_CONNECTIONS = 100

这种方式只是一种约定，Python 解释器并不会阻止你去修改这些变量的值。比如：

PI = 3.14159
print(PI)
PI = 3.14
print(PI)

上述代码中，虽然我们按照常量的命名约定定义了 PI，但仍然可以对其重新赋值。

Python 枚举

枚举（Enum）是一种特殊的类，用于定义一组命名的常量。在 Python 中，从 3.4 版本开始，标准库 enum 模块提供了对枚举类型的支持。 要使用枚举，首先需要导入 enum 模块，例如：

from enum import Enum


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


print(Color.RED)

在上述代码中，我们定义了一个 Color 枚举类，它有三个成员：RED、GREEN 和 BLUE，每个成员都有一个关联的值。枚举成员是唯一的，并且不能被重新赋值。例如：

from enum import Enum


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


# 以下操作会报错
# Color.RED = 4

如果尝试对枚举成员重新赋值，会抛出 AttributeError 异常。

常量的应用场景

数学和物理常量

在涉及数学计算或者物理模拟等场景中，经常会用到一些固定的常量。例如，在计算圆的面积或者周长时，需要用到圆周率 PI。

PI = 3.14159


def circle_area(radius):
    return PI * radius * radius


def circle_circumference(radius):
    return 2 * PI * radius


radius = 5
print(f"半径为 {radius} 的圆的面积是: {circle_area(radius)}")
print(f"半径为 {radius} 的圆的周长是: {circle_circumference(radius)}")

在这个例子中，PI 作为一个常量，在整个计算圆的相关属性的模块中保持不变，方便代码的编写和维护。如果没有使用常量，而是在每个计算函数中直接写 3.14159，那么当需要提高 PI 的精度时，就需要在所有相关代码处进行修改，容易出错且不易维护。

配置参数

在开发应用程序时，常常会有一些配置参数，这些参数在程序运行过程中一般不会改变。例如，数据库连接的最大数量、文件上传的最大大小等。

MAX_CONNECTIONS = 100
MAX_UPLOAD_SIZE = 1024 * 1024 * 5  # 5MB


def connect_to_database():
    # 模拟数据库连接逻辑
    if connection_count < MAX_CONNECTIONS:
        # 连接数据库
        pass
    else:
        raise Exception("达到最大连接数")


def handle_upload(file):
    if len(file) <= MAX_UPLOAD_SIZE:
        # 处理文件上传
        pass
    else:
        raise Exception("文件大小超过限制")

通过将这些配置参数定义为常量，当需要调整配置时，只需要在常量定义处修改，而不需要在所有使用这些配置的地方逐个修改，提高了代码的可维护性。

状态码

在网络编程或者系统开发中，常常会定义一些状态码来表示不同的状态。例如，在 HTTP 协议中，有各种状态码如 200 表示成功，404 表示页面未找到等。在 Python 应用程序中，也可以使用常量来定义自己的状态码。

SUCCESS_CODE = 0
ERROR_CODE = -1


def process_task():
    try:
        # 执行任务逻辑
        return SUCCESS_CODE
    except Exception:
        return ERROR_CODE


result = process_task()
if result == SUCCESS_CODE:
    print("任务执行成功")
else:
    print("任务执行失败")

使用常量来表示状态码，使代码更加易读，并且当状态码的含义发生变化时，只需要修改常量的定义，而不需要在所有判断状态码的地方修改代码。

枚举的应用场景

表示有限状态集合

在很多应用场景中，对象或者系统会处于有限个状态之一。例如，一个订单可能有 “待支付”、“已支付”、“已发货”、“已完成” 等状态。使用枚举可以清晰地表示这些状态。

from enum import Enum


class OrderStatus(Enum):
    PENDING_PAYMENT = 1
    PAID = 2
    SHIPPED = 3
    COMPLETED = 4


order_status = OrderStatus.PAID
if order_status == OrderStatus.PAID:
    print("订单已支付，可以发货")

通过枚举，代码的可读性大大提高，并且可以避免使用魔法数字（例如直接使用 1、2 等数字来表示状态）带来的混淆。

分类和标记

在数据处理或者业务逻辑中，常常需要对数据进行分类或者标记。例如，在一个电商系统中，商品可以分为 “电子产品”、“服装”、“食品” 等类别。

from enum import Enum


class ProductCategory(Enum):
    ELECTRONICS = 1
    CLOTHING = 2
    FOOD = 3


product = {
    "name": "iPhone",
    "category": ProductCategory.ELECTRONICS
}
if product["category"] == ProductCategory.ELECTRONICS:
    print(f"{product['name']} 属于电子产品类别")

枚举可以方便地对数据进行分类和标记，并且在进行条件判断时更加直观和安全。

作为可迭代对象

枚举类是可迭代的，这在一些需要遍历所有枚举成员的场景中非常有用。例如，在生成文档或者进行状态统计时，可能需要获取所有的枚举成员。

from enum import Enum


class Weekday(Enum):
    MONDAY = 1
    TUESDAY = 2
    WEDNESDAY = 3
    THURSDAY = 4
    FRIDAY = 5
    SATURDAY = 6
    SUNDAY = 7


for day in Weekday:
    print(day.name, day.value)

上述代码遍历了 Weekday 枚举类的所有成员，并打印出成员的名称和值。这种可迭代性使得枚举在一些需要对所有可能状态进行操作的场景中非常便捷。

常量与枚举的选择考量

数据类型和可变性

常量本质上就是普通的变量，只是按照约定使用全大写字母命名，其数据类型可以是 Python 支持的任何类型，并且在运行时可以被修改（虽然不推荐这样做）。而枚举成员是固定的，不能被重新赋值，并且枚举类有自己独特的类型。 如果数据在运行过程中有可能被修改，那么使用常量更为合适，尽管违反了常量的约定，但从技术实现上是可行的。如果数据是一组固定的、不可变的值，并且需要进行类型安全的比较和操作，那么枚举更合适。 例如，在一个游戏开发中，游戏难度等级可能会根据玩家的选择或者游戏进程进行调整，这时可以使用常量来表示难度等级：

EASY = 1
MEDIUM = 2
HARD = 3


difficulty = EASY
# 根据玩家操作可能调整难度
if player_action == "increase_difficulty":
    if difficulty == EASY:
        difficulty = MEDIUM
    elif difficulty == MEDIUM:
        difficulty = HARD

而在表示游戏中的角色职业时，职业一般是固定的几种，不会在运行时改变，使用枚举更为合适：

from enum import Enum


class CharacterClass(Enum):
    WARRIOR = 1
    MAGE = 2
    ROGUE = 3


character = {
    "name": "Alice",
    "class": CharacterClass.MAGE
}

代码可读性和维护性

常量在简单的数值表示或者配置参数场景下，代码可读性较好，尤其是在模块内使用时。但是当涉及到多个模块或者较大规模的代码库时，如果常量的含义不明确，可能会导致维护困难。 枚举通过定义清晰的命名空间和成员，大大提高了代码的可读性，特别是在表示有限状态集合或者分类标记时。在大型项目中，枚举的可维护性更强，因为枚举成员的唯一性和不可变性减少了出错的可能性。 例如，在一个小型脚本中，使用常量表示文件类型：

TYPE_PDF = 1
TYPE_TXT = 2
TYPE_IMAGE = 3


file_type = TYPE_PDF
if file_type == TYPE_PDF:
    print("这是一个 PDF 文件")

在一个大型文件管理系统中，使用枚举表示文件类型则更加清晰和易于维护：

from enum import Enum


class FileType(Enum):
    PDF = 1
    TXT = 2
    IMAGE = 3


file = {
    "name": "report.pdf",
    "type": FileType.PDF
}
if file["type"] == FileType.PDF:
    print(f"{file['name']} 是一个 PDF 文件")

功能需求的复杂性

如果只是简单地需要一个固定值，并且不需要额外的功能，那么常量就足够了。然而，如果需要对一组相关的值进行操作，比如遍历、比较、序列化等，枚举提供了更多的功能。 枚举类提供了一些内置的方法，如 __members__ 属性可以获取所有枚举成员的字典，name 属性获取成员的名称，value 属性获取成员的值等。这些功能在处理复杂业务逻辑时非常有用。 例如，在一个任务调度系统中，如果只是简单地定义任务的优先级，使用常量就可以：

PRIORITY_LOW = 1
PRIORITY_MEDIUM = 2
PRIORITY_HIGH = 3


task = {
    "name": "数据备份",
    "priority": PRIORITY_MEDIUM
}

但如果需要对任务优先级进行更复杂的操作，比如根据优先级排序任务，并且需要在不同模块之间传递和比较优先级，使用枚举会更好：

from enum import Enum, auto


class TaskPriority(Enum):
    LOW = auto()
    MEDIUM = auto()
    HIGH = auto()


tasks = [
    {"name": "数据备份", "priority": TaskPriority.MEDIUM},
    {"name": "系统监控", "priority": TaskPriority.HIGH},
    {"name": "日志清理", "priority": TaskPriority.LOW}
]
tasks.sort(key=lambda t: t["priority"].value)
for task in tasks:
    print(f"任务: {task['name']}, 优先级: {task['priority'].name}")

在这个例子中，枚举的 auto() 方法自动为成员分配值，并且通过 value 属性方便地进行排序操作。

与其他库或框架的兼容性

在某些情况下，选择常量还是枚举可能会受到与其他库或框架兼容性的影响。有些库可能更期望接收普通的常量值，而有些库可能对枚举类型有更好的支持。 例如，在使用 SQLAlchemy 进行数据库操作时，对于存储固定值的字段，如果使用枚举类型，SQLAlchemy 有专门的 Enum 类型可以与之对应，方便进行数据库的映射和操作：

from sqlalchemy import Column, Integer
from sqlalchemy.orm import declarative_base
from sqlalchemy.types import Enum as SAEnum
from enum import Enum


class OrderStatus(Enum):
    PENDING_PAYMENT = 'pending_payment'
    PAID = 'paid'
    SHIPPED ='shipped'
    COMPLETED = 'completed'


Base = declarative_base()


class Order(Base):
    __tablename__ = 'orders'
    id = Column(Integer, primary_key=True)
    status = Column(SAEnum(OrderStatus))

而如果使用普通常量，可能需要手动处理与数据库存储和查询的映射关系。

结合使用常量和枚举

在实际开发中，常量和枚举并不是互斥的，很多时候可以结合使用以达到更好的效果。 例如，在一个图形绘制库中，可能会定义一些常量来表示通用的颜色值，同时使用枚举来表示不同的图形类型。

from enum import Enum


# 常量表示颜色
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)


class ShapeType(Enum):
    CIRCLE = 1
    RECTANGLE = 2
    TRIANGLE = 3


def draw_shape(shape_type, color):
    if shape_type == ShapeType.CIRCLE:
        print(f"绘制一个颜色为 {color} 的圆形")
    elif shape_type == ShapeType.RECTANGLE:
        print(f"绘制一个颜色为 {color} 的矩形")
    elif shape_type == ShapeType.TRIANGLE:
        print(f"绘制一个颜色为 {color} 的三角形")


draw_shape(ShapeType.CIRCLE, RED)

在这个例子中，常量用于表示颜色值，因为颜色值可能会在不同的图形绘制函数中通用，并且可能会根据用户设置等情况进行调整。而枚举用于表示图形类型，因为图形类型是固定的几种，并且需要进行类型安全的比较和操作。

又比如，在一个网络通信协议的实现中，可能会使用常量来表示一些通用的配置参数，如最大连接数、超时时间等，同时使用枚举来表示协议中的各种命令类型。

from enum import Enum


# 常量
MAX_CONNECTIONS = 100
TIMEOUT = 10


class CommandType(Enum):
    REQUEST = 1
    RESPONSE = 2
    ERROR = 3


def handle_command(command_type, data):
    if command_type == CommandType.REQUEST:
        print(f"处理请求命令，数据: {data}")
    elif command_type == CommandType.RESPONSE:
        print(f"处理响应命令，数据: {data}")
    elif command_type == CommandType.ERROR:
        print(f"处理错误命令，数据: {data}")


handle_command(CommandType.REQUEST, "获取用户信息")

通过结合使用常量和枚举，可以充分发挥它们各自的优势，使代码更加清晰、可维护和功能强大。

在选择使用常量还是枚举时，需要综合考虑数据的可变性、代码的可读性和维护性、功能需求的复杂性以及与其他库或框架的兼容性等因素。合理地使用常量和枚举，能够提升 Python 程序的质量和开发效率。同时，在实际项目中，根据具体的业务场景和需求，灵活地结合使用常量和枚举，能够更好地满足项目的要求。无论是小型脚本还是大型项目，正确选择和使用常量与枚举都是编写高质量 Python 代码的重要环节。通过深入理解它们的特点和应用场景，开发者可以编写出更加健壮、清晰和易于维护的代码。在不同的模块和功能中，根据具体情况权衡使用常量和枚举，能够使代码结构更加合理，提高整个项目的可扩展性和稳定性。在代码的演进过程中，也要注意随着需求的变化，适时调整常量和枚举的使用方式，以确保代码始终保持良好的状态。