Django之模型层

已于 2022-12-04 16:04:31 修改
阅读量551 收藏 2
点赞数 2
分类专栏： python后端 文章标签： django python 后端
于 2022-12-03 19:13:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64599482/article/details/128157653
版权

一、测试脚本

当你只是想测试django中的某一个py文件内容 那么可以不用书写前后的交互的形式而是直接写一个测试脚本即可

脚本代码无论是写在应用下的tests.py还是自己单独开设py文件都可以

测试环境的准备 去manage.py中拷贝前四行代码 然后自己写两行

import os

import sys

if __name__ == "__main__":

        os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'day53.settings')

        import django

        django.setup()

        # 在这个代码块的下面就可以测试django里面的单个py文件了

二、models.py单表操作

from django.db import models


# Create your models here.
class User(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    register_time = models.DateTimeField()  # 年月日
    """
    DateField
    DateTimeField
        两个重要参数：
        auto_now：每次操作数据的时候 该字段会自动将当前时间更新
        auto_now_add：在创建数据的时候会自动将当前创建时间记录下来 之后只要不认为的修改 那么就一直不变
    """

三、tests.py单表操作

from django.test import TestCase

# Create your tests here.
import os

import sys

if __name__ == "__main__":
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'day53.settings')
    import django

    django.setup()
    # 所有的代码都必须等待环境准备完毕之后才能书写
    from app01 import models
    # 单表操作
    # 增
    # res = models.User.objects.create(name='qiansuiyou', age=100, register_time='2022-12-3')
    # print(res)
    # import datetime
    # ctime = datetime.datetime.now()
    # user_obj = models.User(name='zero', age=99, register_time=ctime)
    # user_obj.save()

    # 删
    # res = models.User.objects.filter(pk=2).delete()
    # pk会自动查找到当前表的主键字段 指代的就是当前表的主键字段
    # print(res)
    # user_obj = models.User.objects.filter(pk=1).first()
    # user_obj.delete()

    # 改
    # models.User.objects.filter(pk=4).update(name='king')
    # user_obj = models.User.objects.get(pk=4)
    # user_obj.name = 'like'
    # user_obj.save()

    # 必知必会13条
    # 1.all()   查询所有数据
    # res = models.User.objects.all()
    # print(res)
    # 2.filter()    带有过滤条件的查询
    # res = models.User.objects.filter(name='qiansuiyou')
    # print(res)
    # 3.get()   直接拿数据对象，但是条件不存在直接报错
    # res = models.User.objects.get(pk=3)
    # print(res)
    # 4.first() 拿queryset里面第一个元素
    # res = models.User.objects.all().first()
    # print(res)
    # 5.last()  拿queryset里面最后一个元素
    # res = models.User.objects.all().last()
    # print(res)
    # 6.values()    可以指定获取的数据字段
    # res = models.User.objects.values('name', 'age')
    # print(res)
    # 7.values_list()   可以指定获取的数据字段 列表套元组的形式
    # res = models.User.objects.values_list('name', 'age')
    # print(res)
    # print(res.query)
    # 查看内部sql语句 queryset对象才能够.query查看内部的sql语句
    # 8.distinct()  去重 一定要是一模一样的数据 不要忽略主键
    # res = models.User.objects.values('name', 'age').distinct()
    # print(res)
    # 9.order_by()  排序
    # res = models.User.objects.order_by('age')   # 默认升序
    # res = models.User.objects.order_by('-age')   # 降序
    # print(res)
    # 10.reverse()  反转的前提是数据已经排序了
    # res = models.User.objects.all()
    # res1 = models.User.objects.order_by('age').reverse()
    # print(res, res1)
    # 11.count()    统计当前数据的个数
    # res = models.User.objects.count()
    # print(res)
    # 12.exclude()  排除在外
    # res = models.User.objects.exclude(name='qiansuiyou')
    # print(res)
    # 13.exists()   判断某个是否存在    返回布尔值
    # res = models.User.objects.filter(pk=4).exists()
    # print(res)

    # 神奇的双下划线查询
    # 1.年龄大于35岁的数据
    # res = models.User.objects.filter(age__gt=35)
    # print(res)
    # 2.年龄小于35岁的数据
    # res = models.User.objects.filter(age__lt=35)
    # print(res)
    # 3.年龄大于等于/小于等于35岁的数据
    # res = models.User.objects.filter(age__gte=35)
    # print(res)
    # res = models.User.objects.filter(age__lte=35)
    # print(res)
    # 4.年龄是66 或者99 或者100
    # res = models.User.objects.filter(age__in=[66, 99, 100])
    # print(res)
    # 5.年龄在50到100岁之间的 首位都要
    # res = models.User.objects.filter(age__range=[50, 100])
    # print(res)
    # 6.查询出名字含有q的数据 模糊查询 区分大小写
    # res = models.User.objects.filter(name__contains='n')
    # print(res)
    # 忽略大小写
    # res = models.User.objects.filter(name__icontains='n')
    # print(res)
    # 7.查询出注册时间是2022 12月的数据
    # res = models.User.objects.filter(register_time__year='2022', register_time__month='12')
    # print(res)

四、models.py多表操作

class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_date = models.DateField(auto_now_add=True)
    # F与Q查询时添加库存和卖出方便演示
    # 库存
    kucun = models.IntegerField(default=1000)
    # 卖出
    maichu = models.IntegerField(default=1000)
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)  # 一对多
    authors = models.ManyToManyField(to='Author')

class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=64)
    email = models.EmailField()  # varchar(254) 该字段类型不是给models看的 而是给校验型组件看的

class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)

class AuthorDetail(models.Model):
    phone = models.BigIntegerField()
    addr = models.CharField(max_length=64)

五、多表插入数据

1.author

 2.authordetail

3.publish 

4.bookF与Q查询的表数据

六、tests.py多表操作 

# 一对多 外键增删改查
# 增
# 1.直接写实际字段 id
# models.Book.objects.create(title='三国演义', price=123.23, publish_id=1)
# models.Book.objects.create(title='三体', price=899.23, publish_id=1)
# models.Book.objects.create(title='吕氏春秋', price=444.23, publish_id=2)
# models.Book.objects.create(title='老子', price=333.23, publish_id=2)
# 2.虚拟字段 对象
# publish_obj = models.Publish.objects.filter(pk=2).first()
# models.Book.objects.create(title='红楼梦', price=666.23, publish=publish_obj)

# 删
# models.Publish.objects.filter(pk=1).delete()  # 级联删除

# 改
# models.Book.objects.filter(pk=1).update(publish_id=2)
# publish_obj = models.Publish.objects.filter(pk=1).first()
# models.Book.objects.filter(pk=1).update(publish=publish_obj)

# 多对多 增删改查 就是操作第三张表
# 如果给书籍添加作者
book_obj = models.Book.objects.filter(pk=1).first()
# print(book_obj.authors)  # 就类似于你已经找到了第三张关系表
# book_obj.authors.add(1)  # 书籍id为1的书籍绑定一个主键为1的作者
# book_obj.authors.add(2,3)  # 书籍id为1的书籍绑定一个主键为1的作者
# author_obj = models.Author.objects.filter(pk=1).first()
# author_obj1 = models.Author.objects.filter(pk=2).first()
# author_obj2 = models.Author.objects.filter(pk=3).first()
# book_obj.authors.add(author_obj)
# book_obj.authors.add(author_obj1,author_obj2)
# add给第三张关系表添加数据 并且支持多个

# 删 remove给第三张关系表删除数据 并且支持多个 也支持放对象
# book_obj.authors.remove(2)
# book_obj.authors.remove(1,3)

# 改
# book_obj.authors.set([1, 2])  # 括号内必须给一个可迭代对象 也支持放对象 并且支持多个
# 清空clear 在第三张关系表中清空某个书籍与作者的绑定关系
book_obj.authors.clear()

七、tests.py表查询

1.多表查询

# 子查询(基于对象的跨表查询)
# 1.查询书籍主键为1的出版社
# book_obj = models.Book.objects.filter(pk=1).first()
# 书籍出版社 正向
# res = book_obj.publish
# print(res)
# print(res.name)
# print(res.addr)
# 2.查询书籍主键为1的作者
# 书查作者 正向
# res = book_obj.authors  # app01.Author.None
# res = book_obj.authors.all()
# print(res)
# 3.查询作者qiansuiyou的电话号码
# author_obj = models.Author.objects.filter(name='qiansuiyou').first()
# res = author_obj.author_detail
# print(res)
# print(res.phone)
# print(res.addr)
# 什么时候需要.all()  当结果可能有多个的时候就需要.all()  如果是一个则直接拿到数据对象
# 4.查询出版社是东方出版社的书
# publish_obj = models.Publish.objects.filter(name='东方出版社').first()
# 出版社查书 反向
# res = publish_obj.book_set  # app01.Book.None
# res = publish_obj.book_set.all()
# print(res)
# 5.查询作者是qiansuiyou写过的书
# author_obj = models.Author.objects.filter(name='qiansuiyou').first()
# 作者查书 反向
# res = author_obj.book_set.all()
# print(res)
# 6.查询手机号是110的作者姓名
# author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
# res = author_detail_obj.author
# print(res.name)
# 连表查询(基于双下划线的跨表查询)
# 1.查询qiansuiyou的手机号和作者姓名
# res = models.Author.objects.filter(name='qiansuiyou').values('author_detail__phone', 'name')
# print(res)
# 反向
# res = models.AuthorDetail.objects.filter(author__name='qiansuiyou').values('phone', 'author__name')
# print(res)
# 2.查询书籍主键为1的出版社名称和书的名称
# res = models.Book.objects.filter(pk=1).values('title', 'publish__name')
# print(res)
# 反向
# res = models.Publish.objects.filter(book__id=1).values('name', 'book__title')
# print(res)
# 3.查询书籍主键为1的作者姓名
# res = models.Book.objects.filter(pk=1).values('authors__name')
# print(res)
# 反向
# res = models.Author.objects.filter(book__id=1).values('name')
# print(res)
# 4.查询书籍主键是1的作者的手机号
# res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
# print(res)
# 只要有外键就可以无限跨表
# 聚合查询aggregate  只要跟数据库相关的模块 基本上都在django.db.models里面 如果没有那么应该在django.db里面
from django.db.models import Max, Min, Sum, Count, Avg

# 1.所有书的平均价格
# res = models.Book.objects.aggregate(Avg('price'))
# print(res)
# res = models.Book.objects.aggregate(Max('price'), Min('price'), Sum('price'), Count('pk'), Avg('price'))
# print(res)

# 分组查询annotate
# 1.统计每一本书的作者个数
# authors_num是我们自定义的字段 用来存储统计出来的每本书对应的作者个数
# res = models.Book.objects.annotate()    # models后面点什么 就是按什么分组
# res = models.Book.objects.annotate(authors_num=Count('authors')).values('title', 'authors_num')
# print(res)
# 2.统计每个出版社卖的最便宜的书的价格
# res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name', 'min_price')
# print(res)
# 3.统计不止一个作者的图书
# 3.1.先按照图书分组
# 3.2.过滤出不止一个作者的图书
# res = models.Book.objects.annotate(authors_num=Count('authors')).filter(authors_num__gt=1).values('title', 'authors_num')
# 只要你的orm语句得出的结果还是一个queryset对象,那么它就可以继续无限制的点queryset对象封装的方法
# print(res)
# 4.查询每个作者出的书的总价格
# res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
# print(res)
# F查询与Q查询
from django.db.models import F, Q

# F能够帮助你直接获取到列表中某个字段对应的数据
# 1.获取卖出大于库存的书籍
# res = models.Book.objects.filter(maichu__gt=F('kucun')).values('title')
# print(res)
# 2.将所有书籍的价格提升50块
# models.Book.objects.update(price=F('price') + 50)
# 3.将所有书的名称后面加上爆款两个字
# from django.db.models.functions import Concat
# from django.db.models import Value
# models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
# Q查询
# 1.查询卖出数大于100或者价格小于600的书籍
# res = models.Book.objects.filter(Q(maichu__gt=100) , Q(price__lt=600))  # , and关系
# res = models.Book.objects.filter(Q(maichu__gt=100) | Q(price__lt=600))  # | or关系
# res = models.Book.objects.filter(~Q(maichu__gt=100) | Q(price__lt=600))  # ~ not关系
# print(res.values('title'))
# Q的高阶用法 能够将查询条件的左边也变成字符串形式
q = Q()
q.children.append(('maichu__gt', 100))
q.children.append(('price__lt', 600))
res = models.Book.objects.filter(q)  # 默认还是and关系
print(res)

2.django中开启事务

from django.db import transaction

with transaction.atomic():

        # 在with代码块内书写的所有orm操作都是同一个事务

3.orm常用字段及参数

AutoField

        主键字段 primary_key=True

CharField  varchar

        verbose_name  字段的注释

        max_length       长度

IntegerField        int

BigIntegerField   bigint

DecimalField

        max_digits=8

        decimal_places=2

EmailFiled        varchar(254)

DateField        date

DateTimeField        datetime

        auto_now：每次修改数据的时候都会自动更新当前时间

        auto_now_add：只在创建数据的时候记录创建时间后续不会自动修改了

BooleanField        布尔值

        该字段传布尔值(False/True)        数据库里面存0/1

TextField        文本类型

        该字段可以存大段内容没有字数限制

FileField        字符类型

        upload_to = "/data"

        给该字段传一个文件对象，会自动将文件保存到/data目录下然后将文件路径保存到数据库中/data/a.txt

外键字段：

unique=True

        ForeignKey(unique=True) === OneToOneField()

db_index

        如果db_index=True则代表着为此字段设置索引

to_field

        设置要关联的表的字段，默认不写关联的就是另一张的主键字段

on_delete=models.CASCADE

        级联删除

4.数据库优化

only与defer

only：

        结果是一个列表套多个对象，这些对象默认只有only括号内的属性

        但是也可以点击括号内没有的属性，但是需要额外的走数据库操作

defer：

        跟only刚好相反，对象里面唯独没有括号内指定的属性

select_related与prefetch_related

select_related内部的本质是联表操作 inner join

        括号内只能放外键字段并且多对多不行

        括号内可以放多个外键字段

                select_related(外键字段1__外键字段2__外键字段3)

        将联表之后的结果全部查询出来封装到对象里面

        之后对象在点击表的字段的时候都无需再走数据库

prefetch_related内部本质是子查询

        内部通过子查询的方式将多张的表数据也封装到对象中

        这样用户在使用的时候也是感觉不出来的

5.choices参数

在设计表的时候 针对可以列举完全的可能性字段 一般都是用choices参数

        gender_choices = ((1,'male'),(2,'female'),(2,'others'))

        gender = models.IntegerField(choices=gender_choices)

针对针对具有choices参数的字段 存储数据的时候还是按照字段本身的数据类型存储没有其他的约束，但是如果你存的字段在你列举的范围内，那么可以自动获取对应关系

user_obj.gender        # 数字

user_obj.get_gender_display()        # 固定格式 get_choices参数字段名_display()

有对应关系就拿对应关系，没有则还是数据本身不会报错

Soulmate.
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Django学习之模型层---介绍及添加数据
huangql517的博客
07-17 1608
1>ORM简介     ORM是“对象-关系-映射”的简称。它实现了数据模型与数据库的解耦，即数据模型的设计不需要依赖于特定的     数据库，通过简单的配置就可以轻松更换数据库。     一张图看下他们的对应关系 从上图就可以简要的看出来：数据库中的一个表，再Python这边就相当于一个类，表里面的一条条记录就是类实例出来的 对象，对象的属性对应的就是记录里面的数据，删除一条...
Django之模型层多表操作的实现
09-19
本文将详细介绍如何通过Django模型层实现多种表间关系的操作。 ##### 1. 一对多关系 一对多关系是指一个实体可以与多个其他实体关联，而另一个实体只能与一个实体关联。例如，一本书可以由一家出版社出版，而一家...
Django模板系统模型层
weixin_30576827的博客
04-18 113
单表操作 DateField里面的参数: auto_now:每次更新的时候,都会重新记录时间 (=True) auto_now_add:创建数据时,自动将当前时间记录下来 =(True) 测试test创建 import os if __name__ == "__main__": os.environ.setdefaul...
Django模型层：单表操作
a9794666的博客
09-10 149
一 ORM简介 查询数据层次图解：如果操作mysql，ORM是在pymysq之上又进行了一层封装 MVC或者MTV框架中包括一个重要的部分，就是ORM，它实现了数据模型与数据库的解耦，即数据模型的设计不需要依赖于特定的数据库，通过简单的配置就可以轻松更换数据库，这极大的减轻了开发人员的工作量，不需要面对因数据库变更而导致的无效劳动 ORM是“对象-关系-映射”的简...
django 模型层
s_mitsuha的博客
02-13 717
django 学习 django 模型
Django中的模型层
weixin_53766744的博客
11-07 656
Model是MVC框架中重要的一部分,主要负责程序中用于处理数据逻辑的部分（如数据的存取）。它包含你所储存数据的必要字段和行为。通常，每个模型对应数据库中唯一的一张表。大家都知道Django遵循的是MTV模式，其中M指的就是Model，就是今天要学习的模型层。我们知道了模型层的作用，你有没有想过模型是一个什么东西呢？下面带领大家一起来学习。
django框架模型层功能、组成与用法分析
09-18
django模型层是基于Python的ORM（Object Relational Mapping）框架，允许开发者使用Python类来定义数据库中的表结构以及相应的操作。模型层的主要职责包括定义数据结构、数据库迁移、数据操作等，是 django MVC...
26.6 Django模型层
最新发布
07-08
配套资源
Django之模板层的实现代码
09-18
在Django框架中，模板层是负责呈现HTML和动态内容的部分，它与视图和模型层协同工作，实现了MVC（Model-View-Controller）设计模式。模板层的主要目标是将数据和页面设计分离，使得开发者可以专注于后端逻辑，而设计...
django模型层
weixin_39349045的博客
02-24 829
每个模型层都可以被映射为数据库中的一个数据库，而类属性被映射为数据字段，除此之外，数据表的主键、外键、约束等都可以通过属性完成定义 from django.db import models # Create your models here. class Category(models.Model): name = models.CharField(verbose_name="分类名称",max_length=20) #=> varchar create_time = model
django框架之模型层
weixin_34301132的博客
06-13 116
django 什么是模型层？
人生苦短，何妨一试
10-31 320
什么是模型？ 模型是一个Python类，它是由django.db.models.Model派生出的子类。 一个模型类代表数据库中的一张数据表 模型类中每一个类属性都代表数据库中的一个字段 模型是数据交互的接口，是表示和操作数据库的方法和方式 模型层主要负责和数据库之间进行交互通信 ...
Django中model层的操作
舍硪齐誰
07-18 392
创建模型类：在models.py中创建一个类，继承于models.Model  模型迁移：在Terminal下执行python manage.py makemigtaions，将sqlite3部署到database 模型ORM：给模型类创建一个对象，给对象赋值后调用save可以将数据写入对应表中 站点管理：1、管理界面本地化将管理界面的语言时间都设置为中国  2、创建管理员执行python ...
Django的模型层
weixin_51445771的博客
08-23 1542
Django的模型层1.Model的开发流程2.定义Model模型3.Model模型的实例4.Model模型的实战操作笔记开发流程1.在models.py中定义模型类，要求继承自models.Model2.生成迁移文件3.执行迁移5.定义属性1.字段类型2.字段选项3.关系模型实例1.类的属性2.创建对象3.实例的属性模型查询1.查询集2.限制查询集3.查询集的缓存4.字段查询1.比较运算符2.跨关联关系的查询：处理join查询3.聚合函数 Django的模型层 模型是项目中的数据消息源，它包
Django-模型层
大多博客仅为学习笔记使用
10-29 405
在多表查询操作中，对于有关系的表都会建外键，外键在哪个地方，从该地方向它的对应关系向查询就是正向，反之就是反向。如book表和publish表：book>>>publish多对一 ， publish>>>book一对多外键建在book表内：则从book表查询publish表中数据就是正向publish表中没有外键字段：则从publish表中查book表数据就是反向一对一和多对多判断也是如此。
Django模型层
小青头的博客
09-09 472
Django模型层 ORM简介 ORM使用 Django配置数据库信息 创建表 字段 参数 Django模型层 这里所说的Django模型层，就是应用下面的models.py中的东西 ORM简介 ORM功能就是将数据库SQL语句映射为python语句。相当于用python语法写出SQL语法的效果 实现过程：ORM –》pymysql –》mysql –》...
Django - 模型层 - 模型
qq_33962481的博客
12-29 201
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
Django框架的模型层models
05-23
Django框架的模型层（models）是用于定义应用程序中的数据模型的一组类。它们以Python类的形式定义，每个类表示一个数据库表，每个属性表示表中的一个字段。模型层提供了一个简单的API来执行各种数据库操作，如创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值