Python 框架学习 Django篇 (六) ORM关联

这篇具有很好参考价值的文章主要介绍了Python 框架学习 Django篇 (六) ORM关联。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

像是上一章我们很少会通过页面点击去添加和绑定关系表,更多的时候都是通过django的语法实现,接下来我们做一个案例 django rom是怎么操作外键关系的

创建mode模型表

Django_demo/mgr/models.py

# 国家表
class Country(models.Model):
    name = models.CharField(max_length=100)

# 学生表, country 字段是国家表的外键,形成一对多的关系
class Student(models.Model):
    name    = models.CharField(max_length=100)
    grade   = models.PositiveSmallIntegerField()
    country = models.ForeignKey(Country,on_delete=models.PROTECT)
python manage.py makemigrations 
python manage.py migrate

添加测试数据

python manage.py shell
#注意应用名称
from paas.models import *
c1 = Country.objects.create(name='中国')
c2 = Country.objects.create(name='美国')
c3 = Country.objects.create(name='法国')
Student.objects.create(name='白月', grade=1, country=c1)
Student.objects.create(name='黑羽', grade=2, country=c1)
Student.objects.create(name='大罗', grade=1, country=c1)
Student.objects.create(name='真佛', grade=2, country=c1)
Student.objects.create(name='Mike', grade=1, country=c2)
Student.objects.create(name='Gus',  grade=1, country=c2)
Student.objects.create(name='White', grade=2, country=c2)
Student.objects.create(name='Napolen', grade=2, country=c3)

一、外键表使用

1、字段访问

#获取student表中 name='白月' 的数据
s1 = Student.objects.get(name='白月')

#将拿到的数据通过外键直接获取到对应外键表的name字段数据并输出 
s1.country.name 

案例

>>> s1 = Student.objects.get(name='白月') 
>>> s1.country.name 
'中国' 

2、单个字段过滤

如果我们想要查询学生表中所有关于1年纪的学生,对应表字段是grade 年纪

Student.objects.filter(grade=1).values()

返回

<QuerySet [{'id': 1, 'name': '白月', 'grade': 1, 'country_id': 1}, {'id': 3, 'name': '大罗', 'grade': 1, 'country_id': 1}, {'id': 5, 'name': 'Mike', 'grade': 1, 'country_id': 2}, {
'id': 6, 'name': 'Gus', 'grade': 1, 'country_id': 2}]>

3、多字段过滤

如果我要同时实现多个条件呢,比如同时满足一年级, 并且国籍是中国的学生

我们不能直接添加多个选项  Student.objects.filter(grade=1,country='中国')

因为,Student表中 country 并不是国家名称字符串字段,而是一个外键字段,对应 Country 表中 id 字段,或许我们可以和上一张用sql语句一样,先查id,然后在查其他信息

cn = Country.objects.get(name='中国')
Student.objects.filter(grade=1,country_id=cn.id).values()

#或者

cn = Country.objects.get(name='中国')
Student.objects.filter(grade=1,country=cn).values()

 返回

>>> cn = Country.objects.get(name='中国') 
>>> Student.objects.filter(grade=1,country_id=cn.id).values() 
<QuerySet [{'id': 1, 'name': '白月', 'grade': 1, 'country_id': 1}, {'id': 3, 'name': '大罗', 'grade': 1, 'country_id': 1}]> 

>>> cn = Country.objects.get(name='中国') 
>>> Student.objects.filter(grade=1,country=cn).values() 
<QuerySet [{'id': 1, 'name': '白月', 'grade': 1, 'country_id': 1}, {'id': 3, 'name': '大罗', 'grade': 1, 'country_id': 1}]> 

4、多字段过滤优化

但是上面的方法其实相对来说过于繁琐,并且需要查询两次,性能不高,

Django ORM 中,对外键关联,有更方便的语法,使用外键+ 双下划线 + 字段名称

Student.objects.filter(grade=1,country__name='中国').values()

 返回

<QuerySet [{'id': 1, 'name': '白月', 'grade': 1, 'country_id': 1}, {'id': 3, 'name': '大罗', 'grade': 1, 'country_id': 1}]> 

5、过滤优化--指定显示字段

如果返回结果只需要 学生姓名 和 国家名两个字段,可以这样指定values内容

Student.objects.filter(grade=1,country__name='中国').values('name','country__name')

 返回

<QuerySet [{'name': '白月', 'country__name': '中国'}, {'name': '大罗', 'country__name': '中国'}]>

6、字段显示重命名

有个问题,我们返回数据的字段是country__name 这样的,双下划线很奇怪,有时候前后端定义好了接口格式,必须让用countryname的话就需要去做字段的重命名

from django.db.models import F

# annotate 可以将表字段进行别名处理
Student.objects.annotate(
    countryname=F('country__name'),
    studentname=F('name')
    )\
    .filter(grade=1,countryname='中国').values('studentname','countryname')

7、反向访问

 Django ORM中,关联表正向关系是通过表外键字段(或者多对多)表示

而反向访问,则是通过将model模板名称转换成小写表示的,比如说你已经获取到了某个国家信息,需要通过国家信息反向查看属于这个国家的学生数据

 案例

#声明获取国家表中name字段为中国的数据
cn = Country.objects.get(name='中国')

#先将要查看的表改为全小写,并且声明_set来获取所有的反向外键关联对象
cn.student_set.all()

返回

>>> cn = Country.objects.get(name='中国') 
>>> cn.student_set.all() 
<QuerySet [<Student: Student object (1)>, <Student: Student object (2)>, <Student: Student object (3)>, <Student: Student object (4)>]> 
>>>  

小知识

Django还给出了一个方法,是在定义Model的时候,外键字段使用 related_name 参数

#国家表
class Country(models.Model):
    name = models.CharField(max_length=100)

# country 字段是国家表的外键,形成一对多的关系
class Student(models.Model):
    name    = models.CharField(max_length=100)
    grade   = models.PositiveSmallIntegerField()
    country = models.ForeignKey(Country,on_delete = models.PROTECT,
                                # 指定反向访问的名字
                                related_name='students')
python manage.py makemigrations 
python manage.py migrate

查询

cn = Country.objects.get(name='中国')
students = cn.students.all()

#拿到的值循环存储并且输出
student_names = [student.name for student in students]

print(student_names)

返回

>>> print(student_names)
['白月', '黑羽', '大罗', '真佛'] 

8、反向过滤

如果我们想要获取所有一年纪学生的国家名称呢,同样可以依靠复合查询实现

# 先获取所有的一年级学生id列表
country_ids = Student.objects.filter(grade=1).values_list('country', flat=True)

# 再通过id列表使用  id__in  过滤
Country.objects.filter(id__in=country_ids).values()

存在的问题就是重复请求,造成性能下降 ,用Django ORM 的方法

Country.objects.filter(students__grade=1).values()

 返回

>>> Country.objects.filter(students__grade=1).values() 
<QuerySet [{'id': 7, 'name': '中国'}, {'id': 7, 'name': '中国'}, {'id': 8, 'name': '美国'}, {'id': 8, 'name': '美国'}]> 

发现存在重复的数据,我们使用 .distinct() 去重

>>> Country.objects.filter(students__grade=1).values().distinct() 
<QuerySet [{'id': 7, 'name': '中国'}, {'id': 8, 'name': '美国'}]> 
 注意

我们前面在定义学生表时, 使用了related_name = "students" 去指定了反向关联students

所以这里通过国家表查询学生表数据的时候使用的字段名称是students__grade 的反向关联名称

如果定义时,没有指定related_name, 则应该使用 表名转化为小写 ,就是这样

Country.objects.filter(student__grade=1).values()

二、实现项目代码

我们在 mgr 目录下面新建 order.py 处理 客户端发过来的 列出订单、添加订单 的请求

1、添加增删改查主体程序

vi Django_demo/mgr/order.py

from django.http import JsonResponse
from django.db.models import F
from django.db import IntegrityError, transaction

# 导入 Order 对象定义
from  paas.models import  Order,OrderMedicine

import json

def dispatcherorder(request):
    # 根据session判断用户是否是登录的管理员用户
    if 'usertype' not in request.session:
        return JsonResponse({
            'ret': 302,
            'msg': '未登录',
            'redirect': '/mgr/sign.html'},
            status=302)

    if request.session['usertype'] != 'mgr':
        return JsonResponse({
            'ret': 302,
            'msg': '用户非mgr类型',
            'redirect': '/mgr/sign.html'},
            status=302)


    # 将请求参数统一放入request 的 params 属性中,方便后续处理

    # GET请求 参数 在 request 对象的 GET属性中
    if request.method == 'GET':
        request.params = request.GET

    # POST/PUT/DELETE 请求 参数 从 request 对象的 body 属性中获取
    elif request.method in ['POST','PUT','DELETE']:
        # 根据接口,POST/PUT/DELETE 请求的消息体都是 json格式
        request.params = json.loads(request.body)

    # 根据不同的action分派给不同的函数进行处理
    action = request.params['action']
    if action == 'list_order':
        return listorder(request)
    elif action == 'add_order':
        return addorder(request)

    # 订单 暂 不支持修改 和删除

    else:
        return JsonResponse({'ret': 1, 'msg': '不支持该类型http请求'})

2、添加路由

vi  Django_demo/mgr/urls.py


urlpatterns = [

   ...

      path('orders', dispatcherorder), # 加上这行

   ...
]

3、定义添加订单函数

接下来,我们添加函数 addorder,来处理添加订单请求,首先我们要了解的是

每次添加一个订单,都需要在2张表(Order 和 OrderMedicine )中添加记录 订单表和中间表

我们给两张表添加记录,就会往数据库写两次,如果中有一次写入失败了,就会形成脏数据

而对应解决这个问题的办法,就是利用数据库"事务"的机制

什么是事务

    把一批数据库操作放在 事务 中, 该事务中的任何一次数据库操作 失败了, 数据库系统就会让 整个事务就会发生回滚,撤销前面的操作, 数据库回滚到这事务操作之前的状态

在django中使用事务机制

直接通过关键字with transaction.atomic()  即可实现数据库批量操作

 Django_demo/mgr/order.py

def addorder(request):

    info  = request.params['data']

    # 从请求消息中 获取要添加订单的信息
    # 并且插入到数据库中


    #设置事务
    with transaction.atomic():
        new_order = Order.objects.create(name=info['name'] ,
                                         customer_id=info['customerid'])

        batch = [OrderMedicine(order_id=new_order.id,medicine_id=mid,amount=1)
                 for mid in info['medicineids']]

        #  在多对多关系表中 添加了 多条关联记录
        OrderMedicine.objects.bulk_create(batch)


    return JsonResponse({'ret': 0,'id':new_order.id})

只要是在 with transaction.atomic() 下面 缩进部分的代码,对数据库相关的操作都视为在同一个事务中,如果其中有任何一步数据操作失败了, 前面的操作都会回滚,这样就解决了多次写入失败导致的脏数据问题

代码说明

batch = [OrderMedicine(order_id=new_order.id,medicine_id=mid,amount=1)
                 for mid in info['medicineids']]

        #  在多对多关系表中 添加了 多条关联记录
        OrderMedicine.objects.bulk_create(batch)

正常来说,OrderMedicine 对应的是订单和药品的多对对记录关系表,要在多对多表中加上关联记录,就是添加一条记录,直接写入即可,如下

OrderMedicine.objects.create(order_id=new_order.id,medicine_id=mid,amount=1)

但你实际上去买药的时候,很少会单独买一样,多少要带点其他的 ,但是我们如果直接用循环把去写入上面的语句,循环几次插入几次,那么多次写入也会影响性能,我们可以使用django中的bulk_create 把多条数据的插入,放在一个SQL语句中完成

batch = [OrderMedicine(order_id=new_order.id,medicine_id=mid,amount=1)  
            for mid in info['medicineids']]

#  在多对多关系表中 添加了 多条关联记录
OrderMedicine.objects.bulk_create(batch)

三、ORM 外键关联

接下来我们编写listorder 函数用来处理 列出订单请求,请求格式如下

[
    {
        id: 1, 
        name: "华山医院订单001", 
        create_date: "2018-12-26T14:10:15.419Z",
        customer_name: "华山医院",
        medicines_name: "青霉素"
    },
    {
        id: 2, 
        name: "华山医院订单002", 
        create_date: "2018-12-27T14:10:37.208Z",
        customer_name: "华山医院",
        medicines_name: "青霉素 | 红霉素 "
    }
] 

 1、基于接口案例返回值

 其中 ‘id’,’name’,‘create_date’ 这些字段的内容获取很简单,order表中就有这些字段

def listorder(request):
    # 返回一个 QuerySet 对象 ,包含所有的表记录
    qs = Order.objects.values('id','name','create_date')
    return JsonResponse({'ret': 0, 'retlist': newlist})

 但是customer_name 客户名称 medicines_name 药品名称是在订单表里面没有的,我们需要通过类似前面的方法从订单表的外键customer 获取到客户表的name字段,方法就是模型名称小写 + 双下划线 + 字段名称

def listorder(request):
    qs = Order.objects\
            .values(
                'id','name','create_date',
                # 两个下划线,表示取customer外键关联的表中的name字段的值
                'customer__name'
            )
    
    # 将 QuerySet 对象 转化为 list 类型
    retlist = list(qs)
    return JsonResponse({'ret': 0, 'retlist': retlist})

同样的道理 , 订单对应 的药品 名字段,是多对多关联, 也同样可以用 两个下划线 获取 关联字段的值

 Django_demo/mgr/order.py 

def listorder(request):
    qs = Order.objects\
            .values(
                'id','name','create_date',
                'customer__name',
                # 两个下划线,表示取medicines 关联的表中的name字段的值
                # 如果有多个,就会产生多条记录
                'medicines__name'
            )
    
    # 将 QuerySet 对象 转化为 list 类型
    retlist = list(qs)
    return JsonResponse({'ret': 0, 'retlist': retlist})

2、重命名返回字段

 这个是能返回数据了,但存在的问题是双下划线和接口要求的单下划线不同,需要通过annotate做一下重命名

from django.db.models import F

def listorder(request):
    # 返回一个 QuerySet 对象 ,包含所有的表记录
    qs = Order.objects\
            .annotate(
                customer_name=F('customer__name'),
                medicines_name=F('medicines__name')
            )\
            .values(
                'id','name','create_date',
                'customer_name',
                'medicines_name'
            )

    # 将 QuerySet 对象 转化为 list 类型
    retlist = list(qs)

    return JsonResponse({'ret': 0, 'retlist': retlist})

3、去除订单内多个不同药品

如果一个订单里面有多个药品,就会产生多条记录, 这不是我们要的。

根据接口,一个订单里面的多个药品, 用 竖线 隔开

def listorder(request):
    # 返回一个 QuerySet 对象 ,包含所有的表记录
    qs = Order.objects\
            .annotate(
                customer_name=F('customer__name'),
                medicines_name=F('medicines__name')
            )\
            .values(
                'id','name','create_date','customer_name','medicines_name'
            )

    # 将 QuerySet 对象 转化为 list 类型
    retlist = list(qs)

    # 可能有 ID相同,药品不同的订单记录, 需要合并
    newlist = []
    id2order = {}
    for one in retlist:
        orderid = one['id']
        if orderid not in id2order:
            newlist.append(one)
            id2order[orderid] = one
        else:
            id2order[orderid]['medicines_name'] += ' | ' + one['medicines_name']

    return JsonResponse({'ret': 0, 'retlist': newlist})

4、测试--获取订单信息

import  requests,pprint

#添加认证
payload = {
    'username': 'root',
    'password': '12345678'
}
#发送登录请求
response = requests.post('http://127.0.0.1:8000/api/mgr/signin',data=payload)
#拿到请求中的认证信息进行访问
set_cookie = response.headers.get('Set-Cookie')




# 构建添加 客户信息的 消息体,是json格式
payload = {
    "action":"list_order",
}
url='http://127.0.0.1:8000/api/mgr/orders/'

if set_cookie:
    # 将Set-Cookie字段的值添加到请求头中
    headers = {'Cookie': set_cookie}

    # 发送请求给web服务
    response = requests.post(url,json=payload,headers=headers)
    pprint.pprint(response.json())

返回

{'ret': 0,
 'retlist': [{'create_date': '2023-10-25T03:08:00Z',
              'customer_name': 'zhangsan',
              'id': 5,
              'medicines_name': 'gmkl',
              'name': 'test'}]}

5、测试--添加订单信息

import  requests,pprint

#添加认证
payload = {
    'username': 'root',
    'password': '12345678'
}
#发送登录请求
response = requests.post('http://127.0.0.1:8000/api/mgr/signin',data=payload)
#拿到请求中的认证信息进行访问
set_cookie = response.headers.get('Set-Cookie')




# 构建添加 客户信息的 消息体,是json格式
payload = {
    "action":"add_order",             #模式改为添加
    "data": {
        "name": "天山订单",                 #订单名称自定义
        "customerid": 1,              #客户表中的id值
        "medicineids": ["6"]          #这个是药品表中的id值
    }
}
url='http://127.0.0.1:8000/api/mgr/orders/'

if set_cookie:
    # 将Set-Cookie字段的值添加到请求头中
    headers = {'Cookie': set_cookie}

    # 发送请求给web服务
    response = requests.post(url,json=payload,headers=headers)
    pprint.pprint(response.json())

Python 框架学习 Django篇 (六) ORM关联,Django框架,python,学习,django

四、特殊字段参数使用

1、唯一性约束处理

我在实际使用的是时候为数据的一致性,我给好几个字段,都添加了唯一性约束

ip_address = modes.CharField(max_length=200,unique=True)

但是在写入的时候如果某个字段发现因为已经有相同数据程序就会崩掉,我们要就不能直接使用create去添加数据,而是改用get_or_create

 案例

#处理数据逻辑
obj, created = clusterINFO.objects.get_or_create(
      唯一性字段=传入的值比如ip, 
      唯一性字段2=传入的值2, 

      #表内其他非一致性字段
       defaults={
            'other_field': other_value
      }
)

上面这个方法当发现已经有字段时,则会给created变量返回一个值为false,如果发现可以正常写入就会返回一个true

2、传入值处理

一开始总是陷入一个误区,想着表内要啥数据就从客户端传啥数据

payload = {
    "action":"list_order",
    "data": {
        key: value
        key: value
 }
}

 比方说,我要添加集群中的node数据,肯定要确保有这个集群名称吧,还要确定下集群的园区是什么,这些都不是node表里面有的,但也要跟随传输过去处理

#拿到请求后先去集群表里面去查环境和集群名对应的字段数据
cn = 集群表.objects.get(环境=  ,集群名=)

#到到的cn如果没有报错就是存放着对应环境集群那一行的数据
cn.id  就能拿到id值了,剩下的就是写入


#给node表插入数据
obj, created = clusterINFO.objects.get_or_create(
      ...

       defaults={
            'node表关联的外键字段_id': cn.id  #给node表外键提供主键表的id值
                                             #这块外键的字段名要加_id表示外键表名
      }
)

3、前端代码访问api数据

把这个文件扔到templates模板目录下面,定义个路由从页面显示出来,在页面打开的时候自动去获取订单表信息循环打印出来

<html>
<head>
    <title>Your Page Title</title>
</head>
<body>
<h1>Your Page Content</h1>

<div id="list-container"></div>

<!-- 将 JavaScript 代码放在 <script> 标签中 -->
<script>
    // 定义请求参数
    const params = {
        action: 'list_order'
    };

    fetch('/api/mgr/orders/',{
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(params)
    })
        //获取请求的结果数据json
        .then(response => response.json())
        .then(data => {
            // 打印返回的 JSON 数据
            console.log(data);

            // 解析JSON数据并提取retlist的值

            const retlistValues = data.retlist; // retlist的值是一个包含多个JSON对象的数组
            console.log(retlistValues)

            //获取页面div,一会把自定义的div加进去
            const existingDiv = document.getElementById("list-container")

            // 遍历retlist的值,并将字段显示在页面上
            retlistValues.forEach(obj => {
                // 在页面上创建新的元素来显示字段和值
                const div = document.createElement('div');
                for (let key in obj) {
                    const span = document.createElement('span');
                    span.innerText = `${key}: ${obj[key]}`;
                    div.appendChild(span);
                }
                existingDiv.appendChild(div)
            });
        })

</script>
</body>
</html>

4、带表格和样式显示

<html>
<head>
    <title>Your Page Title</title>
    <style>
        #list-container{
            width: auto;
            overflow: hidden;
            text-align: center;
            margin: 1cm;
            justify-content: center;
        }

        #list-container table{
            width: 100%;
            border-collapse: collapse;

        }

        #list-container th, #list-container td{
            border: 0.1px solid black;
            padding: 4px;
            font-size: 9pt;
        }
    </style>
</head>
<body>
<h1>Your Page Content</h1>

<div id="list-container"></div>

<!-- 将 JavaScript 代码放在 <script> 标签中 -->
<script>
    // 定义请求参数
    const params = {
        action: 'list_order'
    };

    fetch('/api/mgr/orders/',{
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(params)
    })
        //获取请求的结果数据json
        .then(response => response.json())
        .then(data => {
            // 打印返回的 JSON 数据
            console.log(data);

            // 解析JSON数据并提取retlist的值
            // retlist的值是一个包含多个JSON对象的数组
            const retlistValues = data.retlist;


            //获取页面div,一会把自定义的div加进去
            const existingDiv = document.getElementById("list-container")

            //创建表格元素并添加到页面
            const  table = document.createElement('table');
            existingDiv.appendChild(table);

            //创建表格标题行
            const haderRow = document.createElement('tr');

            //遍历第一个对象作为表格的标题
            for (let key in retlistValues[0]){
                const th = document.createElement('th');
                th.innerText = key;
                haderRow.appendChild(th);
            }

            //将标题行添加到表格
            table.appendChild(haderRow)



            //变量retlist的值,显示到表格
            retlistValues.forEach(obj => {
                //创建新元素
                const  row = document.createElement('tr');

                //遍历对象添加到单元格
                for (let key in obj){
                    const cell  = document.createElement('td');
                    cell.innerText = obj[key];
                    row.appendChild(cell)
                }

                //将行添加到表格中
                table.appendChild(row)
            })
        })

</script>
</body>
</html>

Python 框架学习 Django篇 (六) ORM关联,Django框架,python,学习,django

5、多字段数据检查

比方说我们需要判断1套园区的 集群名A 是否有这个集群,同园区不能有相同集群,不同园区可以

Django_demo/paas/models.py

class Order(models.Model):
    name = models.CharField(max_length=200,null=True,blank=True)
    create_date = models.DateTimeField(default=datetime.datetime.now)
    customer = models.ForeignKey(Customer,on_delete=models.PROTECT)
    medicines = models.ManyToManyField(Medicine, through='OrderMedicine')
    
    

    #添加模块下函数
    def is_cluster_exists(self,info):
        cluster_count = Order.objects.filter(
            name=info["name"],
            customer=info["customer"]
        ).count()

        return cluster_count > 0

#调用
def test(request):
    info request.params['data']
    cluster = Order(字段=info[数据字段],字段2=info[字段2])

    if  Order.is_cluster_exitsts():
            xxx

6 、多个唯一性字段数据检查

class Order(models.Model):
    name = models.CharField(max_length=200,null=True,blank=True)
    create_date = models.DateTimeField(default=datetime.datetime.now)
    customer = models.ForeignKey(Customer,on_delete=models.PROTECT)
    medicines = models.ManyToManyField(Medicine, through='OrderMedicine')
    
    #假设现在上面的4个字段是唯一性约束unique

    def save(self, *args, **kwargs):
       #获取已存在的数据
       existing_data = Order.objects.all()

        #检查字段与已经存在的数据是否冲突
        for data in existing_data:
            if self.name ==data.name or self.create_date == data.create_date or  self.customer == data.customer or self.medicines ==data. medicines:
                 return   False  #检查到有冲突就返回false
        return True


#调用,你找个路由后面的函数下面添加
#声明类传入你要验证的字段值
order = Order(
 字段 = 数据
  字段2 = 数据
)

if order.save() == True:
  return JsonResponse({"ret":1})

7、批量插入数据校验

我有一个环境是往数据库插入大量ip,但是不同环境的ip都不同,所以在对应模型下面做一个字段数据检查文章来源地址https://www.toymoban.com/news/detail-715704.html

class Nodeinfo(xxxxxx):
   Node_Name
   Cluster_Name
   node_network_segment  =  xxx

   #添加对比函数
   def save(self):
      #获取全量数据
      existing_data = NodeInfo.objects.all()

      sublist = []
      #检查传入的列表数据和数据库中的ip是否冲突
      for data in existing_data:
          if data.Node_Name in self.Node_Name:
              sublist.append(data.Node_Name)

       #判断之后检查是否存在冲突ip
       if len(sublist) == 0:
             return True, ""
       else:
          return False, sublist


#调用

#声明类
NodeInfo(字段1=xx  字段2=xx 字段3=xx)

create, obj NodeInfo.save(传入列表数据)
if create != True:  
   判断有冲突
else
   无冲突继续向下走

#开启事务
with transaction.atomic():
   batch = [NodeInfo( 
           字段1  =  IP  
           字段2  =  xx
           字段3  =  xx
         )for IP in 列表数据]
   

到了这里,关于Python 框架学习 Django篇 (六) ORM关联的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Python 框架学习 Django篇 (八) 代码优化、数据库冗余处理

    我们开发软件系统的时候,需要不断的反思我们代码里面是否有可以优化的地方。而优化的重点之一,就是把冗余的代码优化为可以复用的库。我们在前面编写了一些功能,但是其中存在很多冗余的方法 打开这3个文件我们可以看到他们的入口函数dispatcher  实际的代码相似度

    2024年02月06日
    浏览(45)
  • Python学习笔记-Django框架基础,APP,数据模型,后台管理,路由

    Django框架是Python的常用web框架,遵循 MVC 设计模式的框架,采用了MTV的框架模式,即模型M,视图V和模版T。它最初是被开发来用于管理劳伦斯出版集团旗下的一些以新闻内容为主的网站的,即是CMS(内容管理系统)软件。并于2005年7月在BSD许可证下发布。这套框架是以比利时的

    2024年02月16日
    浏览(41)
  • [学习笔记]全面掌握Django ORM

    参考资料:全面掌握Django ORM 学习目标:独立使用django完成orm的开发 学习内容:Django ORM所有知识点 ORM:Object-Relational Mapping Django的ORM详解 在django中,应用的文件夹下面会自动建一个models.py文件。 模型类的优势与劣势 优势:让开发人员专注于业务逻辑处理,提高开发效率。不

    2024年02月15日
    浏览(37)
  • 【python】 Django Web框架

    2024年04月16日
    浏览(36)
  • 浅谈Python中的Django框架

    Django框架在Python开发很重要,Django框架是一个web框架,且是一个后端框架程序,它不是服务器,需要注意Django框架帮我们封装了很多的组件,帮助我们实现各种功能,具有很强的扩展性。 Django是Python社区两大受欢迎的Web框架之一。 凭借功能强大的脚手架和诸多开箱即用的组件,用

    2024年02月07日
    浏览(42)
  • Python - Django 框架 - 设置时间区

    在Django的settings.py文件中,可以设置时区的配置。以下是设置时间区的步骤: 导入pytz模块: 在settings.py文件中找到TIME_ZONE设置项,并将其设置为希望使用的时区。 确保USE_TZ设置为True,以启用时区支持: 这将告诉Django使用设置的时区进行时间处理。 完成上述步骤后,Django将

    2024年02月15日
    浏览(37)
  • python Web框架要点---Django流程详解

    用于搭建Web应用程序 免去不同Web应用相同代码部分的重复编写,只需关心Web应用核心的业务逻辑实现 接收并解析HTTP请求,获取具体的请求信息 处理本次HTTP请求,即完成本次请求的业务逻辑处理 构造并返回处理结果——HTTP响应 重点 重点 MVT流程:掌握M,V,T的每个模块的功能

    2024年02月04日
    浏览(41)
  • Django--基于Python的Web应用框架

    基本介绍 Django 是一个由 Python 编写的一个开放源代码的 Web 应用框架。 使用 Django,只要很少的代码,Python 的程序开发人员就可以轻松地完成一个正式网站所需要的大部分内容,并进一步开发出全功能的 Web 服务 Django 本身基于 MVC 模型,即 Model(模型)+ View(视图)+ Control

    2024年02月05日
    浏览(45)
  • Python Web开发:Django与Flask框架

    Django和Flask都是Python中非常受欢迎的Web开发框架。虽然它们都是用于构建Web应用程序的工具,但它们在设计理念、使用方式和适用场景等方面存在一些差异。 Django Django是一个“大而全”的框架,遵循MVC设计模式。它内置了很多功能,如ORM(对象关系映射)、模板引擎、表单处

    2024年02月22日
    浏览(52)
  • 面试之 Python 框架 Flask、Django、DRF

    Django:大而全的框架。它的内部组件比较多,如 ORM、Admin、中间件、Form、ModelForm、Session、缓存、信号、CSRF等,功能也都很完善。 flask:微型框架,内部组件就比较少了,但是有很多第三方组件来扩展它,比如 wtform(与django的modelform类似,表单验证)、flask-sqlalchemy(操作数

    2024年02月05日
    浏览(51)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包