django 模型 学习笔记

最新推荐文章于 2024-07-07 18:35:30 发布
最新推荐文章于 2024-07-07 18:35:30 发布
阅读量108 收藏
点赞数
文章标签： django python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fighter_luo/article/details/116655540
版权

文章目录

1.3 模型

1.3.1 基础配置

1.3.1.1 数据连接配置
  • 安装Pymysql库
pip install pymysql
  • settings文件配置
DATABASES = {
    'default': {
        # 'ENGINE': 'django.db.backends.sqlite3',
        # 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'dj_demo',
        'HOST': '127.0.0.1',
        'PORT': '3306',
        'USER': 'dj_demo',
        'PASSWORD': '123456'
    }
}
  • 特殊情况
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ghCjEUb9-1620716472472)(6DE380E4BF814812B4A04A52507424DB)]
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ikJyv7lw-1620716472474)(95D05605373841228B40C3AFCBD058AA)]
    解决办法

主APP__init__.py文件做如下配置

import pymysql
pymysql.version_info = (1, 3, 13, 'final', 0)  #pymsql版本
pymysql.install_as_MySQLdb()

1.3.2 Model类

1.3.2.1 创建model类

在对应APP目录下新建models.py文件
类：对应数据的物理表
类属：性对应数据库的字段
表名默认为：APP名称_类名

from django.db import models
# Create your models here.

class Student(models.Model):
    name = models.CharField(max_length=20)
    gender = models.CharField(max_length=10)
    score = models.FloatField()

指定数据库物理表名

class Teacher(models.Model):
    name = models.CharField(max_length=20)
    age = models.IntegerField()
    gender = models.FloatField()
    #内部类指定表名
    class Meta:
        db_table = 'teacher'
1.3.2.2 迁移模型
  1. 生成迁移计划

项目根目录下执行相关命令

python manage.py makemigrations
  1. 执行迁移任务
python manage.py migrate 
或
python manage.py migrate APP名称

1.3.3 数据操作

1.3.3.1 新增数据
 # 方式一
stu = Student.objects.create(name="小白", gender="男", score=55)

# 方式二
stu = Student(name="韩梅", gender="男", score=85)
stu.save()
1.3.3.2 删除数据
stu = Student.objects.get(name="小白")
stu.delete()
re = stu
1.3.3.3 修改数据
stu = Student.objects.get(name="小明")
stu.gender = "女"
stu.save()
1.3.3.4 数据查询
  1. 简单查询
stu = Student.objects.get(id=3)   # get方法只能查询单条记录
stu = Student.objects.all()
  1. 过滤查询
stu = Student.objects.filter(gender="女")
  1. 魔法查询
"""
    1.日期格式
    __year
    __month
    __day
    2.字符串
    __startswith
    __endswith
    __contains
    3.大于、小于、等于
    __gte   大于等于
    __lte   小于等于
    __eq        等于
"""
stu = Student.objects.filter(score__gte=85)
  1. 排除查询
stu = Student.objects.exclude(score__gt=85)
  1. 限制查询
stu = Student.objects.all()[1:3]
stu = Student.objects.all()[::2]

# 排序
stu = Student.objects.order_by("score")                  # 升序
stu = Student.objects.order_by("-score", "-name")        # 降序在对应字段前加“-”号
  1. 原生查询
stu = Student.objects.raw("select * from my_app_student order by score desc")
# 模糊查询需要用%%对百分号进行转义
stu = Student.objects.raw("select * from my_app_student where name like '%%小%%'")
# 多条件查询
stu = Student.objects.raw("select * from my_app_student where name like '%%小%%' and gender = '男'")
stu = Student.objects.raw("select * from my_app_student where name like '{}' and gender ='{}'".format('%%小%%', '男'))
  1. Q查询
q1 = Q(gender = "男")
q2 = Q(score__gte = 90)
stu = Student.objects.filter(q1&q2)     # &为且

q3 = Q(name__startswith ="李")
q4 = Q(score__gte = 85)
stu =Student.objects.filter(q3|q4)      # |为或
  1. F查询 主要用来做更新操作
stu = Student.objects.get(id=6)
stu.score = F("score") + 5
stu.save()
  1. 聚合查询 数据量大的时候谨慎使用
stu = Student.objects.aggregate(Avg("score")) #返回字典{'score__avg': 82.71428571428571}
stu = Student.objects.aggregate(avg_score = Avg("score"))        #指定返回字典的键值为avg_score
stu = Student.objects.all().aggregate(avg_score = Avg("score"))
  1. 分组查询
stu = Student.objects.values("gender").annotate(Avg("score"))
1.3.3.5 自定义对象管理器

新建模型类和对象管理器并与之关联

from django.db import models
from django.db.models import Manager


class CakeManager(Manager):         #自定义对象管理器
    def create_cake(self, cake_type, price):
        new_model = self.model()   # 实例化的与该对象管理器关联的对象
        new_model.cake_type = cake_type
        new_model.price = price
        print()
        new_model.save()
        return new_model

    def query_all(self):
        return super().all()

class Cake(models.Model):
    cake_type = models.CharField(max_length=20)
    price = models.FloatField()
    cake_manager = CakeManager()   # 关联自定义对象管理器

调用自定义对象管理器

from django.shortcuts import render

from common.method.base import result_to_list
from my_app.models import Cake, CakeManager


def create_cake(request):
    cake = Cake.cake_manager.create_cake("生日", 200)
    re = result_to_list([cake])
    data = {
        "tag": "插入了数据",
        "re": re
    }
    return render(request, "../templates/my_app/cake.html", context = data)

def delete_cake(request):
    cake = Cake.cake_manager.filter(id = 32)
    re = result_to_list(cake)
    cake.delete()
    data = {
        "tag": "删除数据",
        "re": re
    }
    return render(request, "../templates/my_app/cake.html", context = data)

def update_cake(request):
    cake = Cake.cake_manager.get(id = 33)
    cake.cake_type = "生日"
    cake.save()
    re = result_to_list([cake])
    data = {
        "tag": "数据修改为",
        "re": re
    }
    return render(request, "../templates/my_app/cake.html", context=data)

def select_cake(request):
    cake = Cake.cake_manager.query_all()
    re = result_to_list(cake)
    data = {
        "tag": "查询结果",
        "re": re
    }
    return render(request, "../templates/my_app/cake.html", context=data)

1.3.4 模型之间的关

  • 模型类创建
from django.db import models

# Create your models here.

# 一对多模型关系
class School(models.Model):     # 一方模型
    name = models.CharField(max_length=64)
    addr = models.CharField(max_length=64)
    history = models.TextField()

    def __str__(self):
        return self.name


class Student(models.Model):        # 多方模型
    name = models.CharField(max_length=64)
    gender = models.CharField(max_length=4)
    age = models.IntegerField()
    school = models.ForeignKey(School, on_delete=models.CASCADE)        # 设置外键
1.3.4.1 一对多
  • 模型类创建
from django.db import models

# Create your models here.

# 一对多模型关系
class School(models.Model):     # 一方模型
    name = models.CharField(max_length=64)
    addr = models.CharField(max_length=64)
    history = models.TextField()

    def __str__(self):
        return self.name


class Student(models.Model):        # 多方模型
    name = models.CharField(max_length=64)
    gender = models.CharField(max_length=4)
    age = models.IntegerField()
    school = models.ForeignKey(School, on_delete=models.CASCADE)        # 设置外键
  • 对象间的关联
def create_student(request):
    # 方式一：通过“多方”模型的外键类属性关联“一方”模型的实例化对象
    school = School.objects.get(id = 1)
    student = Student.objects.create(name = "小明", gender = "男", age=19, school=school)
    # 方式二：通过“多方”对应表的外键关联“一方”
    student = Student.objects.create(name = "郭靖", gender = "男",age = "19",school_id = 2)
    student = Student.objects.create(name = "黄蓉", gender = "女",age = "19",school_id = 3)
    re = result_to_list([student])
    data = {
        "tag": "添加成功",
        "re": re
    }
    return render(request, "../templates/model_relation/student.html", context= data)
  • 查询
def search_one_to_more(request):
    # 1.从一查多，”一方“的实例化对象.“多方”模型类名小写_set.all()
    school = School.objects.get(id = 3)
    re = school.student_set.all()
    # 2.从多查一，通过“多方”设置的关联属性查询
    student = Student.objects.get(id = 3)
    re = [student.school]


    # 查询数据处理与查询方式无关
    re = result_to_list(re)
    data = {
        "tag": "查询结果",
        "re": re
    }
    return render(request, "../templates/model_relation/search.html", context=data)
1.3.4.2 一对一
  • 模型类创建
class Student(models.Model):        
    name = models.CharField(max_length=64)
    gender = models.CharField(max_length=4)
    age = models.IntegerField()
    school = models.ForeignKey(School, on_delete=models.CASCADE)        


# 一对一模型关系   一个学生只对应一个学籍，一个学籍也只能对应一个学生
class StudentStatus(models.Model):
    student = models.OneToOneField(Student, on_delete=models.CASCADE)
    number = models.CharField(max_length=16, unique=True)
    state = models.CharField(max_length=8)
  • 对象间的关联
def create_status(request):
    # 方式一：通过主动一方模型类属性，关联另一方对象
    # status = StudentStatus.objects.create(student= Student.objects.get(id = 3), number = "000002", state= "在读")
    # 方式二通过对应表的唯一外键字段关联
    student_id = Student.objects.filter(name = "黄蓉")[0].id
    status = StudentStatus.objects.create(student_id = student_id, number = "000003",state = "在读")

    re = result_to_list([status])
    data = {
        "tag": "添加成功",
        "re": re
    }
    return render(request, "../templates/model_relation/status.html", context= data)
  • 查询
def search_one_to_one(request):
    # 1.从维护关系一方查：使用模型类中维护关系的那个类属性
    status = StudentStatus.objects.get(id = 1).student
    re = [status]
    # 2.从不维护关系的一方查：使用对方类名的小写
    student = Student.objects.get(id = 1).studentstatus
    re = [student]
    # 查询数据处理与查询方式无关
    re = result_to_list(re)
    data = {
        "tag": "查询结果",
        "re": re
    }
    return render(request, "../templates/model_relation/search.html", context=data)
1.3.4.3 多对多
  • 模型类创建
class Student(models.Model):        
    name = models.CharField(max_length=64)
    gender = models.CharField(max_length=4)
    age = models.IntegerField()
    school = models.ForeignKey(School, on_delete=models.CASCADE)       

    def __str__(self):
        return self.name
        

# 多对多模型关系  学生和社团的关系
class Community(models.Model):
    name = models.CharField(max_length=128)
    build_time = models.DateField()
    member = models.ManyToManyField(Student, through="StudentCommunity")  # 维护关系的一方指定需要的关联的模型类和第三方模型类

    def __str__(self):
        return self.name

# 通过第三方模型进行关联
class StudentCommunity(models.Model):
    member = models.ForeignKey(Student, on_delete=models.CASCADE)
    community = models.ForeignKey(Community, on_delete=models.CASCADE)
    join_reason = models.CharField(max_length=256)
  • 对象间的关联
def create_student_community(request):
    # 通过被关联方的实例化的对象或实例化对象的id属性进行关联
    community = StudentCommunity.objects.create(member = Student.objects.get(id = 6),
                                                community = Community.objects.get(id = 2),
                                                join_reason="喜欢高科技")
    re = result_to_list([community])
    data = {
        "tag": "添加成功",
        "re": re
    }
    return render(request, "../templates/model_relation/community.html", context= data)
  • 查询
def search_many_to_many(request):
    community = Community.objects.get(id = 1)
    student = Student.objects.get(id = 6)
    re = StudentCommunity.objects.filter(member = student )

    # 2.从主动维护关系的“多方”查询：通过关联的类属性查询另一方.all()
    re  = Community.objects.get(id = 2).member.all()

    # 3.从不负责维护关系的多方查询：对方模型类名小写_set.all()
    re = Student.objects.get(id = 1).community_set.all()


    print("-----------------------|",re)
    re = result_to_list(re)
    data = {
        "tag": "查询结果",
        "re": re
    }
    return render(request, "../templates/model_relation/search.html", context=data)
1.3.4.4 模型外键自关联
  • 模型类的创建
# 一对多自关联
class Organization(models.Model):
    num = models.CharField(max_length = 10)
    name = models.CharField(max_length = 64)
    function = models.CharField(max_length = 256)
    parent_organization = models.ForeignKey("self", on_delete = models.CASCADE, null = True)        #外键自引用
  • 对象间的关联
def create_organization(request):
    # 新建一级组织
    organization = Organization.objects.create(num="0000010000", name="总裁办", function="协助总裁处理日常事务")
    organization = Organization.objects.create(num="0000020000", name="财务部", function="制定企业财务相关制度，并执行，其他与财务相关的的事物办理")
    organization = Organization.objects.create(num="0000030000", name="人事部", function="制定企业人事相关制度，负责人员招聘，其他与财务相关的的事物办理")
    organization = Organization.objects.create(num="0000040000", name="报表事业部", function="报表产品的开发")
    organization = Organization.objects.create(num="0000040000", name="资产事业部", function="资产管理产品开发")
    organization = Organization.objects.create(num="0000040000", name="政府事业部", function="为政府客户提供服务")
    organization = Organization.objects.create(num="0000050000", name="企业事业部", function="为企业客户提供服务")
    # 新建二级组织
    organization = Organization.objects.create(num="0000040100", name="实施一部", function="经济建设行业",
                                               parent_organization=Organization.objects.get(id = 6))
    organization = Organization.objects.create(num="0000040200", name="实施二部", function="行业协会",
                                               parent_organization=Organization.objects.get(id = 6))
    organization = Organization.objects.create(num="0000040300", name="实施三部", function="教育行业",
                                               parent_organization=Organization.objects.get(id = 6))
    # 新建三级组织
    organization = Organization.objects.create(num="0000040101", name="项目一组", function="报表业务",
                                               parent_organization=Organization.objects.get(id = 8))
    organization = Organization.objects.create(num="0000040102", name="项目二组", function="资产业务",
                                               parent_organization=Organization.objects.get(id = 8))
    organization = Organization.objects.create(num="0000040101", name="项目三组", function="大数据业务",
                                               parent_organization=Organization.objects.get(id = 8))
    re = result_to_list([organization])
    data = {
        "tag": "添加成功",
        "re": re
    }
    return render(request, "../templates/model_relation/community.html", context= data)
  • 查询
def search_one_to_many(request):
    # 1.从一查多，”一方“的实例化对象.“多方”模型类名小写_set.all()
    organization = Organization.objects.get(id = 6)
    re = organization.organization_set.all()
    # 2.从多查一，通过“多方”设置的关联属性查询
    organization = Organization.objects.get(id = 9)
    re = [organization.parent_organization]


    # 查询数据处理与查询方式无关
    re = result_to_list(re)
    data = {
        "tag": "查询结果",
        "re": re
    }
    return render(request, "../templates/model_relation/search.html", context=data)
胡子白了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Django-23-ORM一对多更新
karry_孙二的博客
04-15 469
前提（初始数据表） city表 user表 django_study.app01.views.py：新建一个one_to_more_update_db视图函数 from django.shortcuts import render # 导入显示页面的模块 from django.http import HttpResponse # 导入显示字符串的模块 from .mo...
Django-25-ORM一对多删除
karry_孙二的博客
04-15 732
前提（初始数据表） city表 user表 django_study.app01.views.py：新建一个one_to_more_delete_db视图函数 from django.shortcuts import render # 导入显示页面的模块 from django.http import HttpResponse # 导入显示字符串的模块 from .mo...
77.Q表达式详解
zjy123078_zjy的博客
02-04 752
Q表达式可以包裹查询条件，可以在多个条件之间进行操作：与或非等。Q表达式一般会放在filter()中进行使用，F表达式一般是放在update()中进行使用。 定义模型的models.py文件中，示例代码如下： from django.db import models # 定义作者模型 class Author(models.Model): name = models.CharField...
Django的ORM模型查询操作涉及的查询条件和聚合函数
SGTXS的博客
08-29 529
查询一般就是使用filter、exclude和get三个方法来实现。在ORM层面，这些查询条件都是使用field+__(双下划线)+condition的方式来实现的。 一、查询条件 exact：使用精确的 = 进行查找。如果提供的是一个None，那么在SQL层面就是被解释为NULL，例如 person = Person.objects.get(name__exact="张三")；对应的sql...
python聚合函数_72.Python中ORM聚合函数详解：Avg，aggregate，annotate
weixin_39520149的博客
12-03 619
聚合函数：如果你用原生SQL语句，则可以使用聚合函数提取数据。比如提取某个商品销售的数量，那么就可以使用Count，如果想要知道销售的平均价格，那么就可以使用Avg。聚合函数是通过aggregate方法来实现的，在讲解这些聚合函数的用法的时候，都是基于以下的模型来实现的。示例代码如下：'''python#模型要放在app当中。所以首先要在终端命令行窗口，执行命令：python manage.py ...
Django 模型学习笔记
大西瓜Blog
08-03 239
Django 对各种数据库提供了很好的支持，包括：PostgreSQL、MySQL、SQLite、Oracle。 Django 为这些数据库提供了统一的调用API。 我们可以根据自己业务需求选择不同的数据库。 MySQL 是 Web 应用中最常用的数据库。   数据库配置 我们在项目的 settings.py 文件中找到 DATABASES 配置项，将其信息修改为： DATABASE...
Django的学习笔记
m0_66295378的博客
12-05 1125
Django的基础内容
django学习笔记
仰望星空
03-12 483
django学习笔记
Django学习笔记（一）
qq_57815468的博客
03-23 911
Django项目的创建与运行
【Django】学习笔记
丷从心·的博客
04-20 4310
【Django】学习笔记
django框架学习笔记
03-16
【标题】：“django框架学习笔记” 【描述】：“django学习” 在Python的世界里，Django是一个强大且受欢迎的Web框架，它遵循模型-视图-控制器（MVC）设计模式，用于快速开发高效且可维护的网站。Django强调代码...
python+django学习笔记
02-05
然后是Django模型，通过定义模型类来创建数据库表，并利用ORM（对象关系映射）进行数据操作。接下来是视图函数或视图类，它们处理HTTP请求并返回响应。模板语言是Django的另一大特色，用于生成动态HTML页面。 ...
django笔记 django笔记
06-16
本笔记将深入探讨Django的基础概念、核心功能以及实际应用。 1. **Django简介**： Django是由两位美国开发者在2005年创建的开源项目，它遵循MVC（模型-视图-控制器）设计模式，但更倾向于MTV（模型-模板-视图）...
Django学习笔记.zip
06-12
这个名为"Django学习笔记.zip"的压缩包文件显然包含了关于Django框架深入学习的各种资料，涵盖了从基础到进阶的主题。让我们逐一探讨这些主题。 1. **Django安装**：Django的安装通常通过Python的包管理器pip完成。...
Django学习笔记.docx
08-03
Django学习笔记 本文档是 Django 学习笔记，基于 b 站千锋教育的视频课程...本文档涵盖了 Django 项目的基本结构、数据库配置、应用创建、模型定义和模板及 URL 配置等知识点，为 Django 初学者提供了系统的学习笔记。
Django QuerySet对象，all()方法
人生苦短，何妨一试
07-03 779
在Django中，all()方法是QuerySet对象的一个方法，用于获取模型的所有实例。当你调用ModelName.objects.all()时，Django会生成一个SQL查询，从数据库中获取该模型的所有记录，并返回一个QuerySet对象，这个对象包含了所有的模型实例。在这个例子中，posts是一个QuerySet对象，你可以像操作列表一样操作它，例如，你可以遍历它，获取它的长度，或者对它进行切片等操作。
Django之项目开发（一）
最新发布
Calor13的博客
07-07 271
传统Web 项目的生命周期指的是从开始构建一个网站到该网站完成并维护的整个过程。通常情况下，Web 项目的生命周期包括以下几个阶段需求分析阶段：在这个阶段，项目组会与客户进行沟通，确定网站的功能、内容和设计。主要由产品经理参与产出思路与方案，领导确认方案设计阶段：在这个阶段，项目组会制定网站的整体架构和功能模块，并设计网站的外观和交互。产品团队参与产出需求文档、项目里程表开发阶段：在这个阶段，项目组会根据设计图制作网站的前端界面，并编写后端代码来实现网站的功能开发团队，运维团队。
探索LlamaIndex：如何用Django打造高效知识库检索
我码玄黄的博客
07-06 1090
LlamaIndex（前身为GPT Index）是一个数据框架，为了帮助我们去建基于大型语言模型（LLM）的应用程序。主要用于处理、构建和查询自定义知识库。
Django QuerySet对象，get()方法
人生苦短，何妨一试
07-07 326
Django的QuerySet对象的get()方法用于从数据库中获取单个对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值