Skip to main content
 首页 » 编程设计

python之在 Django 中为 4-D 类型的数组创建模型

2024年12月31日22myhome

我为 Django webapp 的数据库构造了一些逻辑，但我完全无法将它转换成模型形式用于 Models.py :

User : U 
Transaction-ID : T 
Datetime : D 
Transaction-ID Status-1 for a today : A[0] 
Transaction-ID Status-2 for a today : A[1] 
Transaction-ID Status-3 for a today : A[2]

对于上面的逻辑，可以用 N 构造用户:U[N]其中 U[i] -> T[i][] 交易，每个交易都有3个交易属性T[j] -> A[j][3] .我应该如何为给定的细节构建一个模型。另外，如果可能的话，我如何为这三个 A[k] 存储日期明智的模型 交易 的状态并将它们添加到周 和月 平均值，然后继续制作数据库。

含义:

一个特定的用户可以完成可变数量的交易，并且对于每个交易，都提供了一个 key ，用于获取该特定交易状态 em>。就像赚取的能量点数、赚取的奖励点数和声望点数 赚了。 定期更新 每日、每周 和每月 获得的 3 个积分 跨越该用户完成的所有交易并将它们存储在数据库中每个用户 应该做什么。

在 C++ 中会更容易，但由于我的项目基于 SQLite，它在 Django 框架 中内置运行，所以很难理解有多少模型 应该被使用以及如何链接它们来实现这个系统。任何建议将不胜感激。

4 维视角是因为 : entry = U[N][< strong>M][3][D]

请您参考如下方法:

我为此目的放置了我项目的一部分，并为没有在这个答案中总结代码而道歉(因为我认为总结它可能会在没有测试的情况下出错，所以我决定使用复制粘贴测试代码)。

当我想读取四个嵌套的 Django 管理模型 (4D) 并在代码中使用它们时，我执行了以下过程:

模型.py:

from __future__ import unicode_literals 
from django.db import models 
from django.db.models.deletion import CASCADE 
 
MODBUS_TYPES = (('tcp', 'Tcp'), ('udp', 'Udp'), ('ascii', 'Ascii'), ('rtu', 'Rtu')) 
 
 
class BatteryMonitoringServer(models.Model): 
    enable = models.BooleanField(default=True) 
    name = models.CharField(max_length=150) 
    server_ip = models.GenericIPAddressField(default='0.0.0.0', null=True) 
 
    def __str__(self): 
        return self.name 
 
class BatteryMonitoringDevice(models.Model): 
    bm_id = models.ForeignKey(BatteryMonitoringServer, on_delete=CASCADE) 
    enable = models.BooleanField(default=True) 
    name = models.CharField(max_length=100, null=True) 
    method = models.CharField(max_length=5, choices=MODBUS_TYPES) 
    bm_device_ip = models.GenericIPAddressField(default='127.0.0.1', null=True) 
    bm_device_port = models.IntegerField(default=5558, null=True) 
    baud_rate = models.IntegerField(null=True, default=9600) 
 
class BatteryMonitoringSubDevice(models.Model): 
    enable = models.BooleanField(default=True) 
    name = models.CharField(max_length=100) 
    unit = models.IntegerField(default=1) 
    sub_bm_count = models.IntegerField(default=4, null=True, blank=True, name='bm') 
    fk = models.ForeignKey(BatteryMonitoringDevice, on_delete=CASCADE) 
 
class BatteryMonitoringMeta(models.Model): 
    key = models.CharField(max_length=100) 
    value = models.CharField(max_length=100) 
    module = models.ForeignKey(BatteryMonitoringSubDevice, on_delete=CASCADE)

conf_reader.py

from battery_monitoring.models import BatteryMonitoringServer 
from delta_device.utility import DictEncoder 
 
class BMSubDeviceConf(object): 
    def __init__( 
            self, 
            start, 
            name, 
            unit, 
            bm, 
            meta_data): 
 
        self._start = start 
        self._name = name 
        self._unit = unit 
        self._bm = bm 
        self._meta_data = meta_data 
 
    @property 
    def start(self): 
        return self._start 
 
    @property 
    def name(self): 
        return self._name 
 
    @property 
    def unit(self): 
        return self._unit 
 
    @property 
    def bm(self): 
        return self._bm 
 
    @property 
    def meta_data(self): 
        return self._meta_data 
 
class BMDeviceConf(object): 
    def __init__( 
            self, 
            bm_id, 
            start, 
            name, 
            method, 
            bm_device_ip, 
            bm_device_port, 
            baud_rate, 
            sub_devices=None): 
 
        self._id = bm_id 
        self._start = start 
        self._name = name 
        self._method = method 
        self._bm_device_ip = bm_device_ip 
        self._bm_device_port = bm_device_port 
        self._baud_rate = baud_rate 
        self._sub_devices = sub_devices or [] 
 
    def add_sub_device(self, sub_device): 
        self._sub_devices.append(sub_device) 
 
    def get_sub_devices(self): 
        return self._sub_devices 
 
    @property 
    def start(self): 
        return self._start 
 
    @property 
    def id(self): 
        return self._id 
 
    @property 
    def name(self): 
        return self._name 
 
    @property 
    def bm_device_ip(self): 
        return self._bm_device_ip 
 
    @property 
    def bm_device_port(self): 
        return self._bm_device_port 
 
    @property 
    def baud_rate(self): 
        return self._baud_rate 
 
class BMConf(object): 
    def __init__( 
            self, 
            start, 
            name, 
            server_ip, 
            devices=None, 
    ):  # :( :| :) (: :p 
 
        self._start = 'ON' if start else 'OFF' 
        self._name = name 
        self._server_ip = server_ip 
        self._devices = devices or [] 
 
    def add_device(self, device): 
        self._devices.append(device) 
 
    def get_devices(self): 
        return self._devices 
 
    @property 
    def start(self): 
        return self._start 
 
    @property 
    def name(self): 
        return self._name 
 
    @property 
    def server_ip(self): 
        return self._server_ip 
 
def get_server(): 
    """Using list method to make a fast sql reading.""" 
    return list(BatteryMonitoringServer.objects.all()) 
 
def get_devices(dev): 
    return list(dev.batterymonitoringdevice_set.all()) 
 
def get_sub_devices(sub_dev): 
    return list(sub_dev.batterymonitoringsubdevice_set.all()) 
 
def get_metadata(metric): 
    return list(metric.batterymonitoringmeta_set.all()) 
 
class BMReadConf(object): 
    """BM configuration Reader""" 
    def __init__(self): 
        pass 
 
    @classmethod 
    def get_bm_config(cls): 
        """Read BM metrics and return it on a object list""" 
        result = list() 
 
        for srv in get_server(): 
            data = BMConf(srv.enable, 
                          srv.name, 
                          srv.server_ip,) 
 
            for dev in get_devices(srv): 
                device = BMDeviceConf( 
                    dev.bm_id, 
                    dev.enable, 
                    dev.name, 
                    dev.method, 
                    dev.bm_device_ip, 
                    dev.bm_device_port, 
                    dev.baud_rate, 
                ) 
 
                for sub_dev in get_sub_devices(dev): 
                    meta_data = {} 
 
                    for meta in get_metadata(sub_dev): 
                        meta_data[meta.key] = meta.value 
 
                    sub_device = BMSubDeviceConf( 
                        sub_dev.enable, 
                        sub_dev.name, 
                        sub_dev.unit, 
                        sub_dev.bm, 
                        meta_data, 
                        ) 
 
                    device.add_sub_device(sub_device) 
 
                data.add_device(device) 
 
            result.append(data) 
 
        return result

用法(测试.py)

from battery_monitoring.conf_reader import BMReadConf 
 
conf_obj = BMReadConf() 
configs = conf_obj.get_bm_config() 
 
for cnf in configs: 
    print(cnf.name)  # This is name field in BatteryMonitoringServer Table. 
    devices = cnf.get_devices() 
     
    for dev in devices: 
        print(dev.baud_rate)  # This is baud_rate field in second nested table. 
        sub_devices = dev.get_sub_devices() 
     
        for sub_dev in sub_devices: 
            print(sub_dev.unit)  # This is unit field in third nested table.  
            print(sub_dev.meta_data)  # This is meta_data table (fourth nested table).

我希望这会有用。

[注意]:

第四个嵌套表 (meta_data) 具有递增的键/值字段。


  文章来源：
  https://blog.windname.com/post/ajiabb2b1.html
阅读延展