Python Django开发题库系统：从数据库设计到随机组卷实现

from django.db import models
from django.core.validators import MinValueValidator, MaxValueValidator


class Subject(models.Model):
    """学科与分类模型"""
    name = models.CharField(max_length=64, verbose_name="学科名称")
    code = models.CharField(max_length=32, unique=True, verbose_name="学科代码")
    is_active = models.BooleanField(default=True, verbose_name="是否启用")

    class Meta:
        verbose_name = "学科"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class QuestionType(models.TextChoices):
    SINGLE = 'SINGLE', '单选题'
    MULTI = 'MULTI', '多选题'
    JUDGE = 'JUDGE', '判断题'
    BLANK = 'BLANK', '填空题'
    ESSAY = 'ESSAY', '简答题'


class Question(models.Model):
    """题目主表"""
    subject = models.ForeignKey(Subject, on_delete=models.CASCADE, related_name='questions', verbose_name="所属学科")
    q_type = models.CharField(max_length=16, choices=QuestionType.choices, verbose_name="题型")
    difficulty = models.PositiveSmallIntegerField(
        validators=[MinValueValidator(1), MaxValueValidator(5)],
        default=3,
        verbose_name="难度等级(1简单-5困难)"
    )
    title = models.TextField(verbose_name="题干内容")
    analysis = models.TextField(blank=True, default='', verbose_name="题目解析")
    default_score = models.DecimalField(max_digits=5, decimal_places=1, default=5.0, verbose_name="默认参考分值")
    is_active = models.BooleanField(default=True, verbose_name="可用状态")
    created_at = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")

    class Meta:
        verbose_name = "题目"
        verbose_name_plural = verbose_name
        indexes = [
            # 建立多字段联合索引，为组卷时的核心条件过滤提供毫秒级支撑
            models.Index(fields=['subject', 'q_type', 'difficulty', 'is_active'], name='idx_q_pool_filter'),
        ]

    def __str__(self):
        return f"[{self.get_q_type_display()}] {self.title[:30]}"


class QuestionOption(models.Model):
    """题目选项（适用于单选、多选、判断）"""
    question = models.ForeignKey(Question, on_delete=models.CASCADE, related_name='options', verbose_name="所属题目")
    label = models.CharField(max_length=8, verbose_name="选项标识(A/B/C/D)")
    content = models.TextField(verbose_name="选项文字/内容")
    is_correct = models.BooleanField(default=False, verbose_name="是否为正确答案")
    sort_order = models.PositiveSmallIntegerField(default=1, verbose_name="显示顺序")

    class Meta:
        verbose_name = "题目选项"
        verbose_name_plural = verbose_name
        ordering = ['sort_order']


class Paper(models.Model):
    """试卷主实体"""
    subject = models.ForeignKey(Subject, on_delete=models.PROTECT, related_name='papers', verbose_name="所属学科")
    title = models.CharField(max_length=128, verbose_name="试卷标题")
    total_score = models.DecimalField(max_digits=5, decimal_places=1, default=100.0, verbose_name="试卷总分")
    pass_score = models.DecimalField(max_digits=5, decimal_places=1, default=60.0, verbose_name="及格线")
    time_limit_minutes = models.PositiveIntegerField(default=90, verbose_name="考试时长(分钟)")
    created_at = models.DateTimeField(auto_now_add=True, verbose_name="组卷时间")

    class Meta:
        verbose_name = "试卷"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.title


class PaperQuestion(models.Model):
    """试卷题目明细中间表（固化题序与实际分值）"""
    paper = models.ForeignKey(Paper, on_delete=models.CASCADE, related_name='paper_questions', verbose_name="所属试卷")
    question = models.ForeignKey(Question, on_delete=models.PROTECT, related_name='paper_records', verbose_name="题目引用")
    order_no = models.PositiveIntegerField(verbose_name="卷面题号顺序")
    score = models.DecimalField(max_digits=5, decimal_places=1, verbose_name="本卷实际分值")

    class Meta:
        verbose_name = "试卷题目关联"
        verbose_name_plural = verbose_name
        unique_together = ('paper', 'question')
        ordering = ['order_no']

注意 PaperQuestion 对 Question 的级联设置使用了 models.PROTECT。这是严防生产事故的关键细节：如果某道题目已经被任何正式试卷使用，系统将禁止从题库中物理硬删除该题目，以防止历史考试试卷渲染出现空指针错误。下架题目应通过修改 is_active=False 进行软标记。

# 错误示范：order_by('?')
random_questions = Question.objects.filter(
    subject=subject, q_type='SINGLE', difficulty=2
).order_by('?')[:20]

import random
from decimal import Decimal
from typing import List, Dict, Any
from django.db import transaction
from .models import Subject, Question, QuestionType, Paper, PaperQuestion


class PaperGenerationError(Exception):
    """组卷业务异常基类"""
    pass


class InsufficientQuestionsError(PaperGenerationError):
    """题库题量不足异常"""
    pass


class PaperGeneratorService:
    """
    智能随机组卷服务
    支持题型配额、难度分布与总分平衡
    """

    def __init__(self, subject: Subject, paper_title: str, total_score: float = 100.0, time_limit: int = 90):
        self.subject = subject
        self.paper_title = paper_title
        self.total_score = Decimal(str(total_score))
        self.time_limit = time_limit
        self.rules: List[Dict[str, Any]] = []

    def add_rule(self, q_type: QuestionType, difficulty: int, count: int, score_per_question: float):
        """
        添加组卷细分规则
        :param q_type: 题型枚举
        :param difficulty: 难度等级 (1-5)
        :param count: 抽取数量
        :param score_per_question: 单题分值
        """
        if count <= 0:
            return
        self.rules.append({
            'q_type': q_type,
            'difficulty': difficulty,
            'count': count,
            'score': Decimal(str(score_per_question))
        })

    def validate_rules(self):
        """校验规则配比总分是否与试卷总分吻合"""
        calculated_total = sum(r['count'] * r['score'] for r in self.rules)
        if calculated_total != self.total_score:
            raise PaperGenerationError(
                f"组卷规则总分 ({calculated_total}) 与试卷预设总分 ({self.total_score}) 不一致，请检查配置！"
            )

    def _sample_question_ids(self, rule: Dict[str, Any], excluded_ids: set) -> List[int]:
        """
        通过主键覆盖索引提取候选集并进行内存抽样
        """
        q_type = rule['q_type']
        difficulty = rule['difficulty']
        required_count = rule['count']

        # 1. 覆盖索引快速查询所有可用题目 ID
        candidate_ids = list(
            Question.objects.filter(
                subject=self.subject,
                q_type=q_type,
                difficulty=difficulty,
                is_active=True
            ).exclude(
                id__in=excluded_ids
            ).values_list('id', flat=True)
        )

        # 2. 题量充裕度检查
        if len(candidate_ids) < required_count:
            type_name = dict(QuestionType.choices).get(q_type, q_type)
            raise InsufficientQuestionsError(
                f"题库储备不足：[{self.subject.name}] 题型={type_name} 难度={difficulty} "
                f"需要 {required_count} 题，实际仅可用 {len(candidate_ids)} 题。"
            )

        # 3. 内存高效随机抽样
        selected = random.sample(candidate_ids, required_count)
        return selected

    @transaction.atomic
    def generate(self) -> Paper:
        """
        执行组卷并持久化到数据库
        保证原子性：只要有一类题目缺失，全部事务自动回滚
        """
        self.validate_rules()

        selected_question_plan = []  # 存放 (question_id, score)
        used_ids = set()

        # 依次对每项规则进行无放回抽样
        for rule in self.rules:
            sampled_ids = self._sample_question_ids(rule, excluded_ids=used_ids)
            for q_id in sampled_ids:
                selected_question_plan.append((q_id, rule['score']))
                used_ids.add(q_id)

        # 创建试卷主表记录
        paper = Paper.objects.create(
            subject=self.subject,
            title=self.paper_title,
            total_score=self.total_score,
            pass_score=self.total_score * Decimal('0.6'),
            time_limit_minutes=self.time_limit
        )

        # 批量组装试卷题目明细
        paper_questions = [
            PaperQuestion(
                paper=paper,
                question_id=q_id,
                order_no=index + 1,
                score=score
            )
            for index, (q_id, score) in enumerate(selected_question_plan)
        ]

        # 批量高效入库，减少 SQL 交互开销
        PaperQuestion.objects.bulk_create(paper_questions)

        return paper

from django.http import JsonResponse
from django.views.decorators.http import require_POST
from .models import Subject, QuestionType
from .services import PaperGeneratorService, PaperGenerationError


@require_POST
def generate_math_exam_api(request):
    try:
        subject = Subject.objects.get(code="MATH_HIGH")
        
        # 初始化组卷引擎：设定 100 分满分，考试时间 120 分钟
        service = PaperGeneratorService(
            subject=subject,
            paper_title="2026学年高等数学期中摸底考试卷",
            total_score=100.0,
            time_limit=120
        )

        # 设定题型与难度矩阵：
        # 1. 单选题 (共10题，每题3分，总计30分)：简单6题，中等4题
        service.add_rule(q_type=QuestionType.SINGLE, difficulty=2, count=6, score_per_question=3.0)
        service.add_rule(q_type=QuestionType.SINGLE, difficulty=3, count=4, score_per_question=3.0)

        # 2. 多选题 (共5题，每题4分，总计20分)：中等3题，困难2题
        service.add_rule(q_type=QuestionType.MULTI, difficulty=3, count=3, score_per_question=4.0)
        service.add_rule(q_type=QuestionType.MULTI, difficulty=4, count=2, score_per_question=4.0)

        # 3. 判断题 (共10题，每题2分，总计20分)：简单10题
        service.add_rule(q_type=QuestionType.JUDGE, difficulty=1, count=10, score_per_question=2.0)

        # 4. 简答计算题 (共3题，每题10分，总计30分)：中等2题，困难1题
        service.add_rule(q_type=QuestionType.ESSAY, difficulty=3, count=2, score_per_question=10.0)
        service.add_rule(q_type=QuestionType.ESSAY, difficulty=5, count=1, score_per_question=10.0)

        # 执行事务组卷
        paper = service.generate()

        return JsonResponse({
            "code": 200,
            "message": "组卷成功",
            "data": {
                "paper_id": paper.id,
                "title": paper.title,
                "total_score": float(paper.total_score),
                "question_count": paper.paper_questions.count()
            }
        })

    except Subject.DoesNotExist:
        return JsonResponse({"code": 404, "message": "指定学科不存在"}, status=404)
    except PaperGenerationError as e:
        return JsonResponse({"code": 400, "message": str(e)}, status=400)
    except Exception as e:
        return JsonResponse({"code": 500, "message": f"系统内部异常: {str(e)}"}, status=500)

Python Django 开发题库系统的关键在于“明晰的实体职责划分”与“轻量级主键随机算法”：通过数据模型将题库与试卷快照解耦，避免外键硬删除破坏历史数据；通过 values_list('id') 配合 random.sample 彻底摆脱 order_by('?') 的性能泥潭，最后以 transaction.atomic 与 bulk_create 完成原子持久化。这一套组合拳既保证了敏捷开发效率，也为系统日后平滑支撑百万级题库打下了坚实的架构基础。