Django数据分析项目性能优化：基因比率计算慢的解决方案咨询

嘿，作为Django开发者，我太懂这种循环查询导致页面卡成狗的痛苦了！咱们一步步来拆解你的问题：

首先，你想通过预存比率减少查询的思路完全没问题——毕竟每次绘图都跑几百次数据库查询、耗时几百秒肯定是不可接受的。不过具体实现上，我更建议你新建一个Gene模型来维护每个基因的统计数据（而不是给GeneEntry加冗余字段），这样数据更规范，维护成本更低。当然，如果你不想改动现有模型，用数据库聚合查询一次性算出所有需要的比率，也能把查询次数从几百次降到1次，性能提升同样明显。

方案一：新建Gene模型，预存统计数据（适合数据稳定、高频绘图的场景） #

这个方案的核心是把每个基因的总条目数、显著条目数（Pval<0.05）存在单独的Gene模型里，通过Django信号自动维护这些数据，绘图时直接取预计算好的比率就行。

1. 修改模型定义 #

首先新增Gene模型，然后把GeneEntry里的gene_symbol字段替换成外键关联到Gene：

from django.db import models

class Dataset(models.Model):
    dataset_name = models.CharField(max_length=200)
    def __str__(self):
        return self.dataset_name

class Gene(models.Model):
    gene_symbol = models.CharField(max_length=200, unique=True)
    total_entries = models.IntegerField(default=0)
    significant_entries = models.IntegerField(default=0)  # 存储Pval<0.05的条目数

    @property
    def ratio(self):
        """计算比率r=a/b，避免除以0的情况"""
        if self.total_entries == 0:
            return 0.0
        return self.significant_entries / self.total_entries

    def __str__(self):
        return self.gene_symbol

class GeneEntry(models.Model):
    dataset = models.ForeignKey(Dataset, on_delete=models.CASCADE)
    gene = models.ForeignKey(Gene, on_delete=models.CASCADE)  # 替换原来的gene_symbol
    Pval = models.FloatField(default=0)
    x = models.IntegerField(default=0)
    y = models.IntegerField(default=0)

    def __str__(self):
        return self.gene.gene_symbol

2. 用Django信号自动维护统计数据 #

接下来写信号，确保新增、修改、删除GeneEntry时，自动更新对应的Gene统计数据：

# 在你的app的signals.py文件里（如果没有就新建一个）
from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
from .models import GeneEntry, Gene

@receiver(post_save, sender=GeneEntry)
def update_gene_stats_on_save(sender, instance, created, **kwargs):
    gene = instance.gene
    if created:
        # 新增条目：总数量+1，符合条件的话显著数量+1
        gene.total_entries += 1
        if instance.Pval < 0.05:
            gene.significant_entries += 1
        gene.save()
    else:
        # 更新条目：如果Pval的显著状态变了，才调整数量
        old_instance = sender.objects.get(pk=instance.pk)
        old_significant = old_instance.Pval < 0.05
        new_significant = instance.Pval < 0.05
        if old_significant != new_significant:
            gene.significant_entries += 1 if new_significant else -1
            gene.save()

@receiver(post_delete, sender=GeneEntry)
def update_gene_stats_on_delete(sender, instance, **kwargs):
    gene = instance.gene
    gene.total_entries -= 1
    if instance.Pval < 0.05:
        gene.significant_entries -= 1
    gene.save()

别忘了在app.py里注册信号：

# 在你的app的apps.py文件里
from django.apps import AppConfig

class YourAppConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'yourapp'

    def ready(self):
        import yourapp.signals  # 替换成你的app名称

3. 迁移现有数据 #

如果你已经有旧数据，需要把现有的gene_symbol迁移到Gene模型里。可以通过Django数据迁移来实现：

1. 先执行python manage.py makemigrations生成模型变更的迁移文件
2. 新建一个空迁移：python manage.py makemigrations --empty yourapp
3. 编辑这个空迁移文件，添加数据迁移逻辑：

from django.db import migrations
from django.db.models import F

def migrate_gene_symbols(apps, schema_editor):
    GeneEntry = apps.get_model('yourapp', 'GeneEntry')
    Gene = apps.get_model('yourapp', 'Gene')
    
    # 先创建所有唯一的Gene记录
    gene_symbols = GeneEntry.objects.values_list('gene_symbol', flat=True).distinct()
    for symbol in gene_symbols:
        Gene.objects.get_or_create(gene_symbol=symbol)
    
    # 再更新每个GeneEntry的gene外键，同时统计初始的total和significant数量
    for gene in Gene.objects.all():
        entries = GeneEntry.objects.filter(gene_symbol=gene.gene_symbol)
        total = entries.count()
        significant = entries.filter(Pval__lt=0.05).count()
        gene.total_entries = total
        gene.significant_entries = significant
        gene.save()
        
        # 更新GeneEntry的gene字段
        entries.update(gene=gene)

def reverse_migrate(apps, schema_editor):
    # 反向迁移时恢复GeneEntry的gene_symbol字段
    GeneEntry = apps.get_model('yourapp', 'GeneEntry')
    GeneEntry.objects.update(gene_symbol=F('gene__gene_symbol'))

class Migration(migrations.Migration):
    dependencies = [
        ('yourapp', '000x_your_previous_migration'),  # 替换成上一个迁移的编号
    ]

    operations = [
        migrations.RunPython(migrate_gene_symbols, reverse_migrate),
    ]

4. 执行python manage.py migrate完成迁移

4. 绘图时使用预计算的比率 #

现在绘图时，你可以直接从Gene模型获取比率，不用再做循环查询：

# 假设你已经把GeneEntry的数据加载到df里（可以通过select_related关联Gene）
df['ratio'] = df.apply(lambda x: x['gene__ratio'] if x['Pval'] < 0.05 else 0.0, axis=1)

方案二：用聚合查询批量计算比率（适合数据频繁变动、不想改模型的场景） #

如果你不想改动现有模型，那可以把循环查询改成一次聚合查询，直接从数据库批量算出所有需要的基因比率：

1. 批量计算比率 #

import pandas as pd
from django.db.models import Count, Case, When, FloatField, Cast, F

# 假设你的df已经加载了当前绘图需要的GeneEntry数据
gene_symbols = df['gene_symbol'].unique()

# 一次性查询所有基因的总条目数、显著条目数和比率
gene_stats = GeneEntry.objects.filter(gene_symbol__in=gene_symbols).values('gene_symbol').annotate(
    total=Count('id'),
    significant=Count(Case(When(Pval__lt=0.05, then='id'), output_field=models.IntegerField()))
).annotate(
    ratio=Case(
        When(total=0, then=0.0),
        then=Cast(F('significant'), FloatField()) / Cast(F('total'), FloatField()),
        output_field=FloatField()
    )
).values('gene_symbol', 'ratio')

# 转换成字典方便映射
ratio_map = {stat['gene_symbol']: stat['ratio'] for stat in gene_stats}

2. 给DataFrame添加比率列 #

df['ratio'] = df.apply(lambda x: ratio_map.get(x['gene_symbol'], 0.0) if x['Pval'] < 0.05 else 0.0, axis=1)

这个方案把几百次查询合并成1次，性能会提升非常明显，而且不需要修改现有模型，代码改动很小。

方案对比怎么选？ #

• 选方案一：如果你的数据集入库后很少修改，而且绘图请求很频繁，预存数据能让每次绘图的速度最快，适合生产环境稳定使用。
• 选方案二：如果数据经常有新增、修改，或者你不想折腾模型迁移和信号维护，这个方案更轻量，改动小，性能也足够解决当前的慢查询问题。

内容的提问来源于stack exchange，提问作者KHayes