一、Django模型层

一、Django模型层

1. 配置django测试脚本

共有两种配置方式

（1）方式一

直接字某一个应用文件夹下的test文件中写下面的内容

取manage.py文件中拷贝其前四行代码
再自己写两行代码
在下面直接写测试的代码即可

# manage.py中拷贝的前四行
import os
import sys

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

    # 自己写的两行
    import django
    django.setup()
    
    # 一定要等待测试脚本搭建完毕之后 才能导入django文件进行测试
    from app01 import models

（2）方式二

直接新建一个任意名称的py文件配置方式一的内容。

2. orm表数据的两种增删改

（1）方式一：

利用queryset对象的方法
filter方法查询出来的结果是一个Queryset对象

1. 创建表记录
book_obj = models.Books.objects.create(title='三国演义',price=123.23,publish_date='2019-11-11')
print(book_obj)

2. 修改表记录
models.Books.objects.filter(pk=1).update('title'='aaa')

3. 删除数据
models.Books.objects.filter(pk=3).delete()

（2）方式二：

利用数据对象本身的方法

1. 创建表记录
book_obj = models.Books(title='西游记',price=666.66,publish_date='2000-1-21')
book_obj.save()

2. 修改表数据
book_obj = models.Books.objects.get(pk=1)
book_obj.price = 222.66
book_obj.save()  # 该方法不推荐使用，因为他会把该行所有字段数据全都用新的数据覆盖一遍，造成资源的浪费，且效率也降低了。  推荐使用queryset方法

3. 删除表数据
book_obj = models.Books.objects.get(pk=3)
book_obj.delete()

3. orm表记录的查的两个方法

（1）filter

# pk关键字的作用：
1. pk会自动帮你查找到当前表的主键字段，所以后期我们都是用pk来指代主键字段
user_obj_list = models.Books.objects.filter(pk=1)
# filter的特点：
1. filter查询出来的结果是一个Queryset对象
2. 当条件不存在的情况下，filter不报错直接返回一个空  推荐使用filter方法
3. filter方法可以查询多个数据对象

# queryset对象的特点：
1.只要是queryset对象就可以无限制的调用queryset的方法
如：res = models.Books.objects.filter(pk=1).filter().filter().filter().filter()

2.只要是queryset对象就可以点query查看当前结果内部对应的sql语句
如：
res.query
结果：SELECT `app01_books`.`id`, `app01_books`.`title`, `app01_books`.`price`, `app01_books`.`publish_date` FROM `app01_books` WHERE `app01_books`.`id` = 1

（2）get （不推荐使用）

book_obj = models.Books.objects.get(pk=1)
# get方法的特点
1.get获取到的直接就是数据对象本身
2.当条件不存在的情况下，get直接报错 所以不推荐使用get方法
3.get方法只能用来查询单个对象，当对应的条件有多个对象时也保错。

4. orm表单操作必会13条

（1）`all()`查所有

返回的结果QuerySet对象
没有参数
orm语句的查询默认都是惰性查询，只有当你真正要使用数据的时候才会执行orm语句。类似生成器。

（2）`filter()` 筛选

返回的结果QuerySet对象
支持多个关键字参数，并且是and关系

（3）`get()` 筛选

获取的是数据对象本身
条件不存在直接报错
根据查询条件得到数据对象必须是唯一的

（4）`first()`

取queryset对象中第一个数据对象

（5）`last()`

取queryset对象中最后一个数据对象

（6）`count()`

统计数据对象的个数
结果是一个数字类型
```
num = models.Books.objects.count()
```

（7）`values()`

获取数据对象中指定的字段的值
可以有多个参数
得到的是queryset对象，列表套字典的格式

res = models.Books.objects.values('title','price')
print(res)

# <QuerySet [{'title': '三国演义', 'price': Decimal('222.66')}, {'title': '红楼梦', 'price': Decimal('888.99')}]>

（8）`values_list()`

获取数据对象中指定的字段的值
可以有多个参数
得到的是queryset对象，列表套元组的格式

res = models.Books.objects.values_list('title','price')
print(res)

# <QuerySet [('三国演义', Decimal('222.66')), ('红楼梦', Decimal('888.99')), ('西游记', Decimal('444.66')), ('西游记', Decimal('666.22'))]>

（9）`order_by()` 排序

按照指定的字段排序
默认是升序
降序字段前面加负号

res = models.Books.objects.order_by('price')
res1 = models.Books.objects.all().order_by('-price')

（10）`reverse()` 颠倒顺序

前提是颠倒的对象必须有顺序(提前排序之后才能跌倒)

res1 = models.Books.objects.all().reverse()  # 没有作用
res2 = models.Books.objects.all().order_by('price')
res3 = models.Books.objects.all().order_by('price').reverse()

（11）`exclude()`

排除什么什么之外
得到的是queryset对象

查询除了title为三国演义以外的其他所有数据对象
res = models.Books.objects.all().exclude(title='三国演义')
print(res)

# <QuerySet [<Books: 红楼梦>, <Books: 西游记1>, <Books: 西游记2>]>

（12）`exists()`

判断查询结果是否有值，返回结果是一个布尔值
该方法其实不需要使用，因为数据本身自带布尔值

res = models.Books.objects.filter(pk=1).exists()
print(res)
# True

（13）`distinct()` 去重

对查询结果进行去重操作
去重的前提：数据必须是完全相同的情况下才能够去重，包括主键也要相同（你容易忽略主键）

res1 = models.Books.objects.values('title','price')
res2 = models.Books.objects.values('title','price').distinct()
print(res1, res2)

5. 双下划线查询

即有比较运算符的查询

    询价格大于500的书籍
    res = models.Books.objects.filter(price__gt=500)
    print(res)
    查询价格小于400 的书籍
    res = models.Books.objects.filter(price__lt=400)
    print(res)
    查询价格大于等于500
    res = models.Books.objects.filter(price__gte=444.66)  python对数字精确度不敏感
    res = models.Books.objects.filter(price__gte=500)
    print(res)
    查询价格小于等于500的书籍
    res = models.Books.objects.filter(price__lte=500)
    print(res)

    查询价格是222.66或者444.22或者500的书籍
    res = models.Books.objects.filter(price__in=[222,444,500])
    print(res)

    查询价格在200到800之间的书籍
    res = models.Books.objects.filter(price__range=(200,800))  # __range 顾头顾尾
    print(res)

    查询出版日期是2019年的书籍
    res = models.Books.objects.filter(publish_date__year='2019')
    print(res)
    查询出版日期是1月份的书籍
    res = models.Books.objects.filter(publish_date__month='1')
    print(res)

6. 模糊查询

MySQL中的模糊查询
        关键字 like
            模糊匹配的符号
                %:匹配任何个数的任意字符
                _:匹配一位任意的字符

模糊查询实例演示：

    查询书籍是以三开头的书
    res = models.Books.objects.filter(title__startswith='三')
    print(res)
    查询书籍是以义结尾的书
    res = models.Books.objects.filter(title__endswith='1')
    print(res)
    查询书籍名称中包含游字的书籍
    res = models.Books.objects.filter(title__contains='游')
    print(res)

    查询书籍名称中包含字母p的书籍
    res = models.Books.objects.filter(title__contains='p')  # 默认区分大小写
    res = models.Books.objects.filter(title__icontains='p')  # 忽略大小写 加i
    print(res)

7. 一对多关系字段的增删改

（1）7，8中一对多，多对多使用的模型类如下

图书表和出版社表是一对多的关系，图书表和作者表是多对多的关系，作者和作者详情是一对一的关系。

from django.db import models

# Create your models here.
class Books(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)
    publish_date = models.DateField()

    def __str__(self):
        return self.title


# 表查询 以图书管理系统为例
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)
    """
    auto_now:每次修改的数据的时候 都会自动更新修改书籍(展示最新的一次修改时间)
    auto_now_add:当数据创建出来的时候 会自动将创建时间记录下来
    """
    publish = models.ForeignKey(to='Publish')
    authors = models.ManyToManyField(to='Author')

class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=64)

    def __str__(self):
        return self.name


class Author(models.Model):
    name = models.CharField(max_length=32)
    email = models.EmailField()  # 对应到数据库中仅仅是varchar(254) 没有任何的限制条件 该字段只要是字符串就可以
    # 仅仅是为了表达语义   如何限制  后期需要借助于校验性组件
    author_detail = models.OneToOneField(to='AuthorDetail')

    def __str__(self):
        return self.name


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

    def __str__(self):
        return self.addr

（2）增

向图书表中添加一条记录

# 第一种直接放具体的值
models.Book.objects.create(title='三国演义',price=222.33,publish_id=1)  # 直接传表里面的实际字段，即 publish_id=1

# 第二种放数据对象
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.create(title='红楼梦',price=444.33,publish=publish_obj)  # 传虚拟字段，即 publish=publish_obj

（3）改

把图书表中主键为1的图书出版社改为publish_id=2对应的出版社

# 第一种直接放具体的值
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)

（4）删

删除出版社表中主键为1的出版社

models.Publish.objects.filter(pk=1).delete()  # 默认就是级联删除 级联更新

8. 多对多字段数据的增删改

对象点外键字段

# 点外键字段 

print(book_obj.publish)  # 获取到外键关联的数据对象
print(book_obj.authors)  # 已经跨到第三张表了

（1）增

用add()方法

    add方法 能够朝第三张关系表添加数据
        既支持传数字
            add(1,2)
        也支持传对象
            add(author_obj,author_obj1)
        并且两者都可以是多个

实例：

book_obj = models.Book.objects.filter(pk=2).first()
print(book_obj.authors)  # 已经跨到第三张表了

# 第一种：直接放具体的值
book_obj.authors.add(1)  # 在第三张表里面给主键为2书籍绑定一个主键为1的作者
book_obj.authors.add(1,2)  # 在第三张表里面给主键为2书籍绑定一个主键为1和2的作者

# 第二种：放数据对象
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
book_obj.authors.add(author_obj)  # 在第三张表里面给主键为2书籍绑定一个主键为1的作者
book_obj.authors.add(author_obj,author_obj1)  # 在第三张表里面给主键为2书籍绑定一个主键为1和2的作者

（2）改

用set()方法

set修改多对多关系表中的数据
        set修改数据的原理是先把原来的正行数据删除，再新增一行修改后的数据
        既可以传数字也可以传对象
        但是需要注意的是括号内必须是可迭代对象
        都支持多个
            set((1,3))
            set((author_obj,author_obj1))

实例：

book_obj = models.Book.objects.filter(pk=2).first()

# 第一种：
book_obj.authors.set((1,3))  # 将主键为2的图书的作者改为主键为1和3的作者
book_obj.authors.set([1,])  # 将主键为2的图书的作者改为主键为1的作者

# 第二种：
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
book_obj.authors.set((author_obj,author_obj1))

（3）删

用remove()方法

remove既可以传数字 也可以穿对象
        并且都支持传多个 不需要迭代
            remove(1,2)
            remove(author_obj,author_obj1)

实例：

book_obj = models.Book.objects.filter(pk=2).first()

# 第一种：
book_obj.authors.remove(100)  # 将主键为2的图书的作主键为100的作者，没有这个作者主键，就不操作。
book_obj.authors.remove(1,2)  # 将主键为2的图书的主键为1和2的作者删除

# 第二种：
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
book_obj.authors.remove(author_obj)
book_obj.authors.remove(author_obj,author_obj1)

（4）清空

使用clear()方法
删除某个数据在第三张表中的所有记录
clear清空书籍相关所有记录括号内不需要传递参数

book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.clear()  # 删除主键为2的图书在第三张表中的所有记录

9. 子查询式跨表查询

（1）正反向查询

正反向查询
            关系字段即外键字段在表1中 由表1查表2的内容就是正向
            否则 就是反向
        正向查询按字段
        反向查询按表名小写 + _set
    
    """
    什么时候需要加all()
    当正向查询点击外键字段数据有多个的情况下 需要.all()
    app01.Author.None  一旦看到该结果 只需要加.all()即可
    
    在写orm语句的时候跟你写sql语句一样 不要想着一次性写完
    写一点查一点再写一点
    """    
        
    """
    什么时候反向查询的时候表名小写需要加_set
        一对多
        多对多
    
        一对一不需要加_set
    """

（2）子查询（就是分步操作的来查询）

    # 正向查询：**********************
    1.查询书籍主键为2的出版社名称
    book_obj = models.Book.objects.filter(pk=2).first()
    print(book_obj.publish)  # 出版社对象
    print(book_obj.publish.name)
    2.查询书籍主键为4的作者姓名
    book_obj = models.Book.objects.filter(pk=4).first()
    print(book_obj.authors)  # app01.Author.None
    print(book_obj.authors.all())
    3.查询作者是jason的手机号码
    author_obj = models.Author.objects.filter(name='jason').first()
    print(author_obj.author_detail)
    print(author_obj.author_detail.phone)
    
    """
    什么时候需要加all()
    当正向查询点击外键字段数据有多个的情况下 需要.all()
    app01.Author.None  一旦看到该结果 只需要加.all()即可
    
    在写orm语句的时候跟你写sql语句一样 不要想着一次性写完
    写一点查一点再写一点
    """
    
    # 反向查询：**********************
    4.查询出版社是东方出版社出版过的书籍
    publish_obj = models.Publish.objects.filter(name='东方出版社').first()
    # print(publish_obj.book_set)  # app01.Book.None
    print(publish_obj.book_set.all())

    5.查询作者是jason写过的书籍
    author_obj = models.Author.objects.filter(name='jason').first()
    # print(author_obj.book_set)  # app01.Book.None
    print(author_obj.book_set.all())  # app01.Book.None

    6.查询手机号是120的作者姓名
    author_detail_obj = models.AuthorDetail.objects.filter(phone=120).first()
    print(author_detail_obj.author)
    print(author_detail_obj.author.email)

10. 双下划线式联表查询

（1）原理

    """
    inner join
    left join
    right join
    union
    """
    利用左连接和右连接等原理，把几张表组成一张大表，再在大表中进行查询

（2）两表联查实例：

# 正向查询：***************************

1.查询书籍pk为2的出版社名称
    正向
    res = models.Book.objects.filter(pk=2).values('publish__name')  # 写外键字段就相当于已经跨到外键字段所关联的表
    你想要改表的哪个字段信息 你只需要加__获取即可
    print(res)
    反向
    res = models.Publish.objects.filter(book__pk=2).values('name')
    print(res)

    2.查询书籍pk为2的作者姓名和邮箱
    res = models.Book.objects.filter(pk=2).values('authors__name','authors__email')
    print(res)
    res = models.Author.objects.filter(book__pk=2).values('name','email')
    print(res)
    
# 反向查询：*****************************

3.查询作者是egon的家庭地址
    res = models.Author.objects.filter(name='egon').values('author_detail__addr')
    print(res)
    res = models.AuthorDetail.objects.filter(author__name='egon').values('addr')
    print(res)


    4.查询出版社是东方出版社出版过的书的名字
    res = models.Publish.objects.filter(name='东方出版社').values('book__title')
    print(res)
    res = models.Book.objects.filter(publish__name='东方出版社').values('title')
    print(res)

（3）三表及以上联表查询实例：

通过外键关系，以顺藤摸瓜式的思想，从一张表到其他表。

查询书籍pk是2的作者的手机号
res = models.Book.objects.filter(pk=2).values('authors__author_detail__phone')
print(res)
res = models.Author.objects.filter(book__pk=2).values('author_detail__phone')
print(res)

来源：https://www.cnblogs.com/Mcoming/p/11945533.html

标签

django

publish

orm

Django模型层（各种表及表数据的操作）

一、Django模型层

1. 配置django测试脚本

（1）方式一

（2）方式二

2. orm表数据的两种增删改

（1）方式一：

（2）方式二：

3. orm表记录的查的两个方法

（1）filter

（2）get （不推荐使用）

4. orm表单操作必会13条

（1）all()查所有

（2）filter() 筛选

（3）get() 筛选

（4）first()

（5）last()

（6）count()

（7）values()

（8）values_list()

（9）order_by() 排序

（10）reverse() 颠倒顺序

（11）exclude()

（12）exists()

（13）distinct() 去重

5. 双下划线查询

6. 模糊查询

7. 一对多关系字段的增删改

（1）7，8中一对多，多对多使用的模型类如下

（2）增

（3）改

（4）删

8. 多对多字段数据的增删改

（1）增

（2）改

（3）删

（4）清空

9. 子查询式跨表查询

（1）正反向查询

（2）子查询（就是分步操作的来查询）

10. 双下划线式联表查询

（1）原理

（2）两表联查实例：

（3）三表及以上联表查询实例：

（1）`all()`查所有

（2）`filter()` 筛选

（3）`get()` 筛选

（4）`first()`

（5）`last()`

（6）`count()`

（7）`values()`

（8）`values_list()`

（9）`order_by()` 排序

（10）`reverse()` 颠倒顺序

（11）`exclude()`

（12）`exists()`

（13）`distinct()` 去重