Python枚举封装案例如何封装枚举数据

wen python案例 2026-06-28 235

本文目录导读：

基础枚举封装
带自定义属性的枚举
业务逻辑封装
枚举数据管理器
高级业务封装
数据库友好的枚举封装
完整的枚举管理器

我来为你展示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())

这些封装方法展示了：