Django之模型层

一、测试脚本

当你只是想测试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()

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