本文目录导读：
我来为你展示Python枚举（Enum）的封装方法，包含多个实用案例：
基础枚举封装
from enum import Enum
class Color(Enum):
RED = 1
GREEN = 2
BLUE = 3
# 使用示例
print(Color.RED) # Color.RED
print(Color.RED.value) # 1
print(Color.RED.name) # 'RED'
带自定义属性的枚举
from enum import Enum
class Status(Enum):
PENDING = ("待处理", 0, "等待处理中")
PROCESSING = ("处理中", 1, "正在处理")
COMPLETED = ("已完成", 2, "处理完成")
FAILED = ("失败", -1, "处理失败")
def __init__(self, chinese_name, code, description):
self.chinese_name = chinese_name
self.code = code
self.description = description
@classmethod
def get_by_code(cls, code):
"""根据代码获取枚举"""
for member in cls:
if member.code == code:
return member
return None
@classmethod
def choices(cls):
"""返回选择项列表，适用于Django等框架"""
return [(member.name, member.chinese_name) for member in cls]
# 使用示例
status = Status.PENDING
print(f"状态：{status.chinese_name}，描述：{status.description}")
# 状态：待处理，描述：等待处理中
# 根据code获取
status = Status.get_by_code(1)
print(status) # Status.PROCESSING
业务逻辑封装
from enum import Enum
from datetime import datetime, timedelta
class OrderStatus(Enum):
"""订单状态枚举"""
CREATED = (0, "已创建", lambda: timedelta(hours=24))
PAID = (1, "已支付", lambda: timedelta(days=7))
SHIPPED = (2, "已发货", lambda: timedelta(days=30))
COMPLETED = (3, "已完成", lambda: timedelta(days=90))
CANCELLED = (-1, "已取消", lambda: timedelta(days=0))
def __init__(self, code, name, timeout_func):
self.code = code
self.name_cn = name
self._timeout_func = timeout_func
def can_cancel(self):
"""判断是否可以取消订单"""
return self in [OrderStatus.CREATED, OrderStatus.PAID]
def get_timeout(self):
"""获取超时时间"""
return self._timeout_func()
@classmethod
def get_next_status(cls, current):
"""获取下一个状态"""
status_flow = {
cls.CREATED: cls.PAID,
cls.PAID: cls.SHIPPED,
cls.SHIPPED: cls.COMPLETED
}
return status_flow.get(current)
@classmethod
def get_active_statuses(cls):
"""获取激活状态的订单"""
return [cls.PAID, cls.SHIPPED, cls.CREATED]
# 使用示例
order = OrderStatus.PAID
print(f"订单状态：{order.name_cn}")
print(f"是否可以取消：{order.can_cancel()}")
print(f"超时时间：{order.get_timeout()}")
枚举数据管理器
from enum import Enum
from typing import Dict, List, Optional
class Priority(Enum):
"""优先级枚举"""
LOW = (1, "低优先级")
MEDIUM = (2, "中优先级")
HIGH = (3, "高优先级")
URGENT = (4, "紧急")
def __init__(self, level: int, description: str):
self.level = level
self.description = description
def get_color(self) -> str:
"""获取优先级对应的颜色"""
colors = {
self.LOW: "#808080",
self.MEDIUM: "#FFA500",
self.HIGH: "#FF0000",
self.URGENT: "#800000"
}
return colors.get(self, "#000000")
class EnumManager:
"""枚举数据管理器"""
def __init__(self, enum_class):
self.enum_class = enum_class
self._cache = {}
def get_all(self) -> List:
"""获取所有枚举"""
return list(self.enum_class)
def get_by_value(self, value) -> Optional[Enum]:
"""根据值获取枚举项"""
try:
return self.enum_class(value)
except ValueError:
return None
def get_by_name(self, name: str) -> Optional[Enum]:
"""根据名称获取枚举项"""
try:
return self.enum_class[name]
except KeyError:
return None
def to_dict(self) -> List[Dict]:
"""转换为字典列表"""
return [
{
"name": member.name,
"value": member.value,
"description": getattr(member, 'description', member.name)
}
for member in self.enum_class
]
def choices(self) -> List[tuple]:
"""获取选择项"""
return [(member.name, member.value) for member in self.enum_class]
# 使用示例
priority_manager = EnumManager(Priority)
# 获取所有优先级
for priority in priority_manager.get_all():
print(f"{priority.name}: {priority.description} (颜色: {priority.get_color()})")
# 根据值获取
priority = priority_manager.get_by_value(3)
print(f"高优先级：{priority.description}")
# 转换为字典
data = priority_manager.to_dict()
print(f"枚举数据：{data}")
高级业务封装
from enum import Enum
from functools import lru_cache
class PaymentMethod(Enum):
"""支付方式枚举"""
WECHAT = ("微信支付", "wechat", ["CNY"])
ALIPAY = ("支付宝", "alipay", ["CNY"])
VISA = ("VISA", "visa_card", ["USD", "EUR"])
MASTERCARD = ("MasterCard", "master_card", ["USD", "EUR", "GBP"])
def __init__(self, display_name: str, api_code: str, currencies: list):
self.display_name = display_name
self.api_code = api_code
self.currencies = currencies
@classmethod
@lru_cache(maxsize=1)
def get_all_methods(cls):
"""获取所有支付方式（带缓存）"""
return list(cls)
@classmethod
def get_available_methods(cls, currency: str) -> list:
"""获取指定货币可用的支付方式"""
return [
method for method in cls
if currency in method.currencies
]
def create_payment_url(self, order_id: str, amount: float) -> str:
"""创建支付URL"""
# 实际项目中这里会有复杂的逻辑
return f"https://payment.example.com/{self.api_code}/{order_id}/{amount}"
def validate_payment(self, payment_data: dict) -> bool:
"""验证支付数据"""
return True # 实际项目中会有完整的验证逻辑
# 使用示例
# 获取人民币可用的支付方式
available = PaymentMethod.get_available_methods("CNY")
for method in available:
print(f"可用支付方式：{method.display_name}")
# 创建支付链接
payment = PaymentMethod.WECHAT
url = payment.create_payment_url("ORDER123", 99.99)
print(f"支付链接：{url}")
数据库友好的枚举封装
from enum import Enum
from dataclasses import dataclass
from typing import Optional
class Gender(Enum):
"""性别枚举"""
MALE = 1
FEMALE = 2
OTHER = 3
def get_display(self):
return {
self.MALE: "男",
self.FEMALE: "女",
self.OTHER: "其他"
}.get(self, "未知")
class UserRole(Enum):
"""用户角色枚举"""
ADMIN = ("admin", "管理员", 0)
EDITOR = ("editor", "编辑", 1)
VIEWER = ("viewer", "查看者", 2)
def __init__(self, role_code: str, display_name: str, priority: int):
self.role_code = role_code
self.display_name = display_name
self.priority = priority
def has_permission(self, action: str) -> bool:
"""检查权限"""
permissions = {
self.ADMIN: ["create", "read", "update", "delete"],
self.EDITOR: ["create", "read", "update"],
self.VIEWER: ["read"]
}
return action in permissions.get(self, [])
@dataclass
class UserInfo:
"""用户信息数据类"""
username: str
gender: Gender
role: UserRole
@property
def display_info(self) -> str:
"""用户显示信息"""
return f"{self.username}({self.gender.get_display()}) - {self.role.display_name}"
# 使用示例
user = UserInfo("张三", Gender.MALE, UserRole.EDITOR)
print(user.display_info)
print(f"是否有删除权限：{user.role.has_permission('delete')}")
完整的枚举管理器
from enum import Enum, auto
from typing import Any, Dict, List, Optional, Type
import json
class BaseEnum(Enum):
"""基础枚举类"""
@classmethod
def values(cls) -> list:
"""获取所有值"""
return [member.value for member in cls]
@classmethod
def names(cls) -> list:
"""获取所有名称"""
return [member.name for member in cls]
@classmethod
def from_value(cls, value: Any) -> Optional['BaseEnum']:
"""根据值获取枚举实例"""
try:
return cls(value)
except (ValueError, TypeError):
return None
@classmethod
def from_name(cls, name: str) -> Optional['BaseEnum']:
"""根据名称获取枚举实例"""
try:
return cls[name]
except KeyError:
return None
class EnhancedEnumManager:
"""增强的枚举管理器"""
def __init__(self):
self._enums: Dict[str, Type[BaseEnum]] = {}
def register(self, name: str, enum_class: Type[BaseEnum]):
"""注册枚举类"""
self._enums[name] = enum_class
def get_enum(self, name: str) -> Optional[Type[BaseEnum]]:
"""获取枚举类"""
return self._enums.get(name)
def serialize_all(self) -> Dict[str, list]:
"""序列化所有枚举"""
result = {}
for name, enum_class in self._enums.items():
result[name] = [
{
"name": member.name,
"value": member.value
}
for member in enum_class
]
return result
def to_json(self) -> str:
"""转换为JSON"""
return json.dumps(self.serialize_all(), ensure_ascii=False, indent=2)
# 使用增强枚举
class OperationStatus(BaseEnum):
SUCCESS = "success"
FAILED = "failed"
PENDING = "pending"
# 管理器使用
manager = EnhancedEnumManager()
manager.register("status", OperationStatus)
# 序列化
print(manager.to_json())
这些封装方法展示了：
- 基础使用：枚举的基本定义和调用
- 属性扩展：给枚举添加额外属性和方法
- 业务逻辑：封装业务规则和方法
- 管理器模式：统一管理枚举数据
- 数据库友好：适合ORM和数据显示
- 序列化支持：方便数据交换和存储
选择哪种封装方式取决于你的具体需求,建议：
- 简单场景使用基础封装
- 需要业务逻辑时添加方法
- 复杂系统使用管理器模式
