Python 如果我有两个模型，模型A和模型B，我希望模型A的平均值是模型B中的平均值

我有两种型号：

class Order(models.Model):
    truck = models.ForeignKey(Truck, on_delete=models.CASCADE, related_name='relation_truck',default=None)
    date= models.DateField()
    product=models.CharField(max_length=30)
    depot = models.CharField(max_length=10)
    volume = models.CharField(max_length=30, blank=True)
    volume_delivered = models.CharField(max_length=30, blank=True)
    order_status = models.CharField(max_length=50, blank=True)
    pub_date = models.DateTimeField(auto_now_add=True, blank=True)

模型：

class LoadingDashboard(models.Model):
    order = models.ForeignKey(Order, on_delete=models.CASCADE, related_name='relation_loading',default=None,blank=True)
    product = models.CharField(max_length=3)
    loading_average = models.IntegerField(null=True)
    expect_quantity = models.IntegerField()
    loaded_quantity = models.IntegerField()
    remaining_quantity = models.IntegerField(null=True)
    total_trucks = models.IntegerField(null=True)
    loaded_trucks=models.IntegerField()
    remaining_trucks = models.IntegerField(null=True)

我想做一些数学运算，如下所示：

装载模型中的产品只有两种：PMS和AGO

型号订单中的产品也是PMS和Ago

按型号顺序装载PMS的卡车的具体体积为35000，交付的体积_应略小于35000，例如34294

装载AGO的卡车的具体体积为33000，交付的体积为32294

我希望装载模型中的现场装载量_平均值是指定产品交付的现场体积_的平均值，无论是在之前还是在PMS，因为它们具有不同的体积_交付值除以1000

加载模型中的预期数量表示我将决定该值

装载的型号中装载的数量应为所有型号订单中交付的数量之和，且PMS和AGO的交付数量不同，因此，如果产品为PMS且AGO相同，则仅应为型号订单中交付的数量之和

剩余数量应为预计数量和装载数量之差

卡车总数应为预期数量和平均装载量的划分

装载的卡车应为模型订单中卡车的总和，同样，应存在带有PMS的卡车和带有AGO的卡车。因此，若产品为模型中的PMS，则装载的卡车应为模型订单中仅有产品PMS的卡车的总和减去产品PMS的总卡车

剩余的_卡车是装载卡车和总_卡车的差异

到目前为止，我所管理的是：

def loading_dashboard(request):
# import pdb; pdb.set_trace()
loaded = LoadingDashboard.objects.all()
for math in loaded.iterator():
    if math.product == 'PMS':
        volume = list(Order.objects.filter(product='PMS')
        .values_list('volume_delivered', flat=True))
        order = volume
        sum = 0
        for volume in order:
            sum = sum + int(volume)
        return sum
        total = sum
        trucks = Order.objects.filter(product='PMS').count()
        loading = Order.objects.filter(product='PMS', order_status='Loaded').count()
        math.loading_average = total / trucks / 1000
        math.total_trucks = math.expect_quantity / math.loading_average
        math.loaded_quantity = total / 1000
        math.remaining_quantity = math.expect_quantity - math.loaded_quantity
        math.loaded_trucks = loading
        math.remaining_trucks = math.total_trucks - math.loaded_trucks
return render(request, 'loadings_dashboard.html' , {'loaded': loaded})

我犯了一个错误

---

AttributeError:“int”对象没有属性“get”。

经过三天的研究，我解决了这个问题：

def loading_dashboard(request):
# import pdb; pdb.set_trace()

loaded = LoadingDashboard.objects.all()
for math in loaded:
    volume = list(Order.objects.filter(product='PMS')
    .values_list('volume_delivered', flat=True))
    order = volume
    sum = 0
    for volume in order:
        sum = sum + int(volume)

    trucks = Order.objects.filter(product='PMS').count()
    loading = Order.objects.filter(product='PMS', order_status='Loaded').count()

    volume_ago = list(Order.objects.filter(product='AGO')
    .values_list('volume_delivered', flat=True))
    order_ago = volume_ago
    sum_ago = 0
    for volume in order_ago:
        sum_ago = sum_ago + int(volume)

    trucks_ago = Order.objects.filter(product='AGO').count()
    loading_ago = Order.objects.filter(product='AGO', order_status='Loaded').count()
    if math.product == 'PMS':
        math.loading_average = sum // trucks // 1000
        math.total_trucks = math.expect_quantity // math.loading_average
        math.loaded_quantity = sum // 1000
        math.remaining_quantity = math.expect_quantity - math.loaded_quantity
        math.loaded_trucks = loading
        math.remaining_trucks = math.total_trucks - math.loaded_trucks
    elif math.product == 'AGO':
        math.loading_average = sum_ago // trucks_ago // 1000
        math.total_trucks = math.expect_quantity // math.loading_average
        math.loaded_quantity = sum_ago // 1000
        math.remaining_quantity = math.expect_quantity - math.loaded_quantity
        math.loaded_trucks = loading_ago
        math.remaining_trucks = math.total_trucks - math.loaded_trucks
return render(request, 'loadings_dashboard.html' , {'loaded': loaded})

---

经过三天的研究，我解决了这个问题：

def loading_dashboard(request):
# import pdb; pdb.set_trace()

loaded = LoadingDashboard.objects.all()
for math in loaded:
    volume = list(Order.objects.filter(product='PMS')
    .values_list('volume_delivered', flat=True))
    order = volume
    sum = 0
    for volume in order:
        sum = sum + int(volume)

    trucks = Order.objects.filter(product='PMS').count()
    loading = Order.objects.filter(product='PMS', order_status='Loaded').count()

    volume_ago = list(Order.objects.filter(product='AGO')
    .values_list('volume_delivered', flat=True))
    order_ago = volume_ago
    sum_ago = 0
    for volume in order_ago:
        sum_ago = sum_ago + int(volume)

    trucks_ago = Order.objects.filter(product='AGO').count()
    loading_ago = Order.objects.filter(product='AGO', order_status='Loaded').count()
    if math.product == 'PMS':
        math.loading_average = sum // trucks // 1000
        math.total_trucks = math.expect_quantity // math.loading_average
        math.loaded_quantity = sum // 1000
        math.remaining_quantity = math.expect_quantity - math.loaded_quantity
        math.loaded_trucks = loading
        math.remaining_trucks = math.total_trucks - math.loaded_trucks
    elif math.product == 'AGO':
        math.loading_average = sum_ago // trucks_ago // 1000
        math.total_trucks = math.expect_quantity // math.loading_average
        math.loaded_quantity = sum_ago // 1000
        math.remaining_quantity = math.expect_quantity - math.loaded_quantity
        math.loaded_trucks = loading_ago
        math.remaining_trucks = math.total_trucks - math.loaded_trucks
return render(request, 'loadings_dashboard.html' , {'loaded': loaded})

---

到目前为止你尝试了什么？你有一些示例代码吗？我已经发布了到目前为止我管理的内容。到目前为止你尝试了什么？你有一些示例代码吗？我已经发布了到目前为止我管理的内容