• Django之模型层

    目录

    一、前言 

    【1】测试脚本

    【2】数据准备

    二、单表操作

    【1】数据的增加

    【2】数据的删除

    【3】数据的更改

    三、常见的十几种查询方法

    四、查看内部sql语句的方式

    【1】方式一

    【2】方式二

    五、基于双下划线的查询

    六、多表查询引入

    【1】数据准备

    【2】外键的增删改查

    (1)一对多外键的增删改查

    (2)多对多外键的增删改查

    【补充】正反向的概念

    七、多表查询

    【1】子查询(基于对象的跨表查询)

    【2】联表查询(基于双下划线的跨表查询)

    八、聚合查询

    九、分组查询

    十、F与Q查询

    【1】F查询

    【2】Q查询

    一、前言 

    Django自带的sqlite3数据对日期格式不敏感，处理的时候容易出错

    【1】测试脚本

    • 测试脚本
      • 当我们只想要测试Django中的某一个py文件的内容时，我们可以不需要书写前后端交互的形式，而是直接写一个测试脚本即可
    • 测试环境的准备
      • 在测试文件中书写下面内容
    • 这内容其实就是最外部 manage.py 文件中的上面几句话
      • 脚本代码无论是写在应用下的 tests.py文件还是自己新建文件，将内容写在新文件中，都会生效
    1. from django.test import TestCase
    2.  
    3. # Create your tests here.
    4. import os
    5.  
    6. if __name__ == "__main__":
    7.     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day07.settings")
    8.  
    9.     import django
    10.     django.setup()
    11.     
    12.     # 在下面书写我们需要测试的代码
    13.     # 即所有的测试代码都必须等待环境准备完毕之后才能书写

    【2】数据准备

    • 在models里面创建我们需要的数据库中的表
    1. from django.db import models
    2.  
    3.  
    4. # Create your models here.
    5.  
    6. class User(models.Model):
    7.     name = models.CharField(verbose_name="姓名", help_text="姓名", max_length=32)
    8.     age = models.IntegerField(verbose_name="年龄", help_text="年龄")
    9.     register_time = models.DateTimeField(verbose_name="注册时间", help_text="注册时间")
    10.     '''
    11.     DateField
    12.     DateTimeField
    13.         两个关键参数
    14.             auto_now ： 每次操作数据的时候该字段会自动将当前时间更新
    15.             auto_now_add ： 在创建数据的时候会自动将当前创建时间记录下来，只要不是人为修改，就不会发生更改
    16.     '''
    • 配置数据库文件(settings.py)
    1. DATABASES = {
    2.     'default': {
    3.         'ENGINE': 'django.db.backends.mysql',
    4.         # 数据库名字
    5.         'NAME': 'django_day10',
    6.         # 用户
    7.         "USER": "root",
    8.         # 密码
    9.         "PASSWORD": "123",
    10.         # IP
    11.         "HOST": "127.0.0.1",
    12.         # 端口
    13.         "PORT": 3306,
    14.         # 编码集
    15.         "CHARSET": "utf8",
    16.     }
    17. }
    • 在项目下的 init.py 中声明数据库类型
    1. import pymysql
    2.  
    3. pymysql.install_as_MySQLdb()

    二、单表操作

    【1】数据的增加

    1. from django.test import TestCase
    2.  
    3. # Create your tests here.
    4. import os
    5.  
    6. if __name__ == "__main__":
    7.     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day07.settings")
    8.  
    9.     import django
    10.  
    11.     django.setup()
    12.  
    13.     # 在下面书写我们需要测试的代码
    14.     # 即所有的测试代码都必须等待环境准备完毕之后才能书写
    15.     from app01 import models
    16.  
    17.     # 增加数据
    18.     # register_time (1)支持自己指定传值
    19.     res = models.User.objects.create(name="jerry", age=20, register_time='2023-11-15')
    20.     # 返回值为对象本身
    21.     print(res)  # User object
    22.     
    23.     # register_time (2)支持传入日期对象
    24.     import datetime
    25.     # 生成一个当前的时间对象
    26.     c_time = datetime.datetime.now()
    27.     user_obj = models.User.objects.create(name="egon", age=20, register_time=c_time)
    28.     # 保存数据
    29.     user_obj.save()

    【2】数据的删除

    1. # 删除数据
    2. """pk : 自动查找到当前表的主键字段，指代的就是当前表的主键字段
    3. 使用 pk 后不需要知道当前表的主键字段，它会自动帮我们查找并匹配"""
    4. # (1)方式一
    5. res = models.User.objects.filter(pk=4).delete()
    6. print(res) # (1, {'app01.User': 1})
    7. # (2)方式二
    8. # 拿到当前用户对象
    9. user_obj = models.User.objects.filter(pk=1).first()
    10. # 利用对象的方法进行删除
    11. user_obj.delete()

    【3】数据的更改

    1. # 数据的更改
    2. # (1)方式一
    3. res = models.User.objects.filter(pk=5).update(name="mengmeng")
    4. print(res)  # 1
    5. # (2)方式二
    6. """get方法返回的直接就是当前数据对象;
    7. 但是该方法不推荐使用：如果查询的数据不存在会直接报错 ，fileter不会"""
    8. user_onj = models.User.objects.get(pk=5)
    9. # 调用对象更改数据
    10. user_onj.name = "xiaomeng"
    11. user_onj.save()

    三、常见的十几种查询方法

    1.     ################必知必会十三条################
    2.     # (1) all() - 查询所有数据
    3.     # (2) filter() - 带有过滤条件的查询
    4.     # (3) get() - 根据条件拿数据对象，但是条件不存在会直接抛出异常
    5.     # (4) first() - 拿queryset中的第一个元素
    6.     res = models.User.objects.all().first()
    7.     print(res)
    8.     # (5) last() - 拿queryset中的最后一个元素
    9.     res = models.User.objects.all().last()
    10.     print(res)
    11.  
    12.     # (6) values() - 可以指定获取的数据字段
    13.     res = models.User.objects.values('name')
    14.     # 返回的数据格式为列表套字典 - 本质上是一个 QuerySet 对象 ，而不是真的列表
    15.     print(res)  # 
    16.     # (7) values_list() - 可以指定获取的数据字段
    17.     res_list = models.User.objects.values_list('name', 'age')
    18.     # 返回的数据格式为列表套元祖 - 本质上是一个 QuerySet 对象 ，而不是真的列表
    19.     print(res_list)  # 
    20.     # 该语句可以查看当前执行命令的 SQL 语句 - 只有queryset对象才能使用该方法
    21.     print(res_list.query)  
    22.     # SELECT `app01_user`.`name`, `app01_user`.`age` FROM `app01_user`
    23.  
    24.     # (8) distinct() - 去重(带有主键就意味着数据存在不一样的地方，
    25.     # 所以一定要去除主键后再去重；去重一定要是一模一样的数据)
    26.     res = models.User.objects.values('name', 'age').distinct()
    27.     print(res)
    28.     # (9) order_by() - 排序
    29.     # 默认升序
    30.     res = models.User.objects.order_by('age')
    31.     print(res)
    32.     # 降序
    33.     res = models.User.objects.order_by('-age')
    34.     print(res)
    35.  
    36.     # (10) reverse() - 反转的前提是数据已经经过排序过的数据
    37.     # 只能对有序的数据进行反转
    38.     res = models.User.objects.order_by('age').reverse()
    39.     print(res)
    40.  
    41.     # (11) count() - 统计当前数据的个数
    42.     res = models.User.objects.count()
    43.     print(res)
    44.  
    45.     # (12) exclude() - 排出在外
    46.     # 将某个数据排出在结果之外
    47.     res = models.User.objects.exclude(user="dream")
    48.  
    49.     # (13) exists() - 是否存在 - 返回布尔值 - 用处不大，因为数据本身就有布尔值的状态
    50.     res = models.User.objects.filter(pk=5).exists()
    51.     print(res)

    四、查看内部sql语句的方式

    【1】方式一

    只有queryset对象才能使用该方法

    1. res_list = models.User.objects.values_list('name', 'age')
    2.     # 返回的数据格式为列表套元祖 - 本质上是一个 QuerySet 对象 ，而不是真的列表
    3.     print(res_list)  # 
    4.     # 该语句可以查看当前执行命令的 SQL 语句 - 只有queryset对象才能使用该方法
    5.     print(res_list.query)  
    6.     # SELECT `app01_user`.`name`, `app01_user`.`age` FROM `app01_user`

    【2】方式二

    所有 SQL语句 都可以使用

    • 在项目的settings.py文件中增加默认配置
    1. LOGGING = {
    2.     'version': 1,
    3.     'disable_existing_loggers': False,
    4.     'handlers': {
    5.         'console':{
    6.             'level':'DEBUG',
    7.             'class':'logging.StreamHandler',
    8.         },
    9.     },
    10.     'loggers': {
    11.         'django.db.backends': {
    12.             'handlers': ['console'],
    13.             'propagate': True,
    14.             'level':'DEBUG',
    15.         },
    16.     }
    17. }

    五、基于双下划线的查询

    1.     # 神奇的双下划线查询
    2.     # (1)年龄大于35岁的数据
    3.     res = models.User.objects.filter(age__gt=35)
    4.     print(res)
    5.     # (2)年龄小于35岁的数据
    6.     res = models.User.objects.filter(age__lt=35)
    7.     print(res)
    8.     # (3)年龄大于等于32岁的数据
    9.     res = models.User.objects.filter(age__gte=32)
    10.     print(res)
    11.     # (4)年龄小于等于30岁的数据
    12.     res = models.User.objects.filter(age__lte=30)
    13.     print(res)
    14.     # (5)年龄是18或者32或者40
    15.     res = models.User.objects.filter(age__in=(18, 32, 40))
    16.     print(res)
    17.     # (6)年龄是18-40之间 - 首尾都要
    18.     res = models.User.objects.filter(age__range=(18, 40))
    19.     print(res)
    20.     # (7)查询出名字中含有 s 的数据  -- 模糊查询
    21.     res = models.User.objects.filter(name__contains='s')
    22.     print(res)
    23.     # (7.1)是否区分大小写？
    24.     res = models.User.objects.filter(name__contains='N')
    25.     print(res)
    26.     # 默认区分大小写
    27.     # (7.2)忽略大小写
    28.     res = models.User.objects.filter(name__icontains='N')
    29.     print(res)
    30.     # (8)以什么开头/结尾
    31.     res = models.User.objects.filter(name__startswith='d')
    32.     print(res)
    33.     res = models.User.objects.filter(name__endswith='m')
    34.     print(res)
    35.     # (9)查询出注册时间是2020年1月份的数据/年/月/日
    36.     res = models.User.objects.filter(register_time__month='1')
    37.     print(res)
    38.     res = models.User.objects.filter(register_time__year='2020')
    39.     print(res)
    40.     res = models.User.objects.filter(register_time__day='28')
    41.     print(res)

    六、多表查询引入

    【1】数据准备

    1. class Book(models.Model):
    2.     title = models.CharField(max_length=32)
    3.     price = models.DecimalField(max_digits=8,decimal_places=2)
    4.     publish_date = models.DateField(auto_now_add=True)
    5.  
    6.     # 一对多
    7.     publish = models.ForeignKey(to='Publish')
    8.     # 多对多
    9.     authors = models.ManyToManyField(to='Author')
    10.  
    11.  
    12. class Publish(models.Model):
    13.     name = models.CharField(max_length=32)
    14.     addr = models.CharField(max_length=64)
    15.    
    16.     # varchar(254)  该字段类型不是给models看的，而是给后面我们会学到的校验性组件看的
    17.  
    18.     def __str__(self):
    19.         return self.name
    20.  
    21.  
    22. class Author(models.Model):
    23.     name = models.CharField(max_length=32)
    24.     age = models.IntegerField()
    25.     # 一对一
    26.     author_detail = models.OneToOneField(to='AuthorDetail')
    27.  
    28.  
    29. class AuthorDetail(models.Model):
    30.     phone = models.BigIntegerField()  
    31.     # 电话号码用BigIntegerField或者直接用CharField
    32.     addr = models.CharField(max_length=64)
    • 重载数据库
    1. python36 manage.py makemigrations
    2.  
    3. python36 manage.py migrate

     【2】外键的增删改查

    (1)一对多外键的增删改查

    1.1 外键的增加

    1. # (1)外键的增加 - 直接写实际字段
    2. models.Book.objects.create(title="三国演义", price=1369.25, publish_id=1)
    3. # (2)外键的增加 - 虚拟字段
    4. publish_obj = models.Publish.objects.filter(pk=2).first()
    5. models.Book.objects.create(title="红楼梦", price=1569.25, publish=publish_obj)

    1.2 外键的删除

    1. # (2)一对多的外键的删除
    2. models.Publish.objects.filter(pk=1).delete()  # 级联删除

    1.3 外键的修改

    1. #  - 直接写实际字段
    2. models.Book.objects.filter(pk=1).update(publish_id=2)
    3. #  - 虚拟字段
    4. publish_obj = models.Publish.objects.filter(pk=1).first()
    5. models.Book.objects.filter(pk=1).update(publish=publish_obj)

    (2)多对多外键的增删改查

    多对多增删改查就是在操作第三张表 

    2.1 增加

    1. # (1)如何给书籍添加作者
    2. book_obj = models.Book.objects.filter(pk=1).first()
    3. # book_obj.authors - 这样我们就已经能操作第三张关系表了
    4. # 书籍ID为1的书籍绑定了一个主键为1的作者
    5. book_obj.authors.add(1)
    6. # 可以传多个参数
    7. book_obj.authors.add(2,3)
    8. # 支持参数传对象 - 且支持多个对象
    9. book_obj.authors.add(author_obj)

    2.2 删除(remove)

    支持多个参数/支持对象

    1. # (2)删除
    2. book_obj = models.Book.objects.filter(pk=1).first()
    3. # 支持多个参数 - 支持多个对象
    4. book_obj.authors.remove(2)

    2.3 更改(set)

    先删除后增加

    1. # (3)修改
    2. book_obj = models.Book.objects.filter(pk=1).first()
    3. # 括号内必须给一个可迭代对象
    4. # 把 1 删掉 替换成 2
    5. book_obj.authors.set([1, 2]) # 括号内必须给一个可迭代对象
    6. # 把原来都删掉 ， 替换成 3
    7. book_obj.authors.set([3]) # 括号内必须给一个可迭代对象
    8. # 支持放对象
    9. book_obj.authors.set([author_obj])

    2.4 清空

    1. # (4) 清空
    2. # 在第三张表中清除某一本书和作者的绑定关系
    3. book_obj = models.Book.objects.filter(pk=1).first()
    4. # clear：括号内不要加任何参数
    5. book_obj.authors.clear()

    【补充】正反向的概念

    • 正向

      • 外键字段在我手上，那么我查你就是正向
      • book >>>> 外键字段在书这边(正向) >>>> 出版社

    • 反向

      • 外键字段不在我手上，那么我查你就是反向
      • 出版社>>>> 外键字段在书这边(反向) >>>> book

    • 一对一和一对多的判断也是这样

    正向查询按字段

    反向查询按表明名(小写)

    ​ __set

    ​ ...

    七、多表查询

    【1】子查询(基于对象的跨表查询)

    1. # (1)查询书籍主键为1的出版社
    2. book_obj = models.Book.objects.filter(pk=1).first()
    3. # 书查出版社 - 正向 - 按字段查
    4. res = book_obj.publish
    5. print(res)  # Publish object
    6. print(res.name)  # 东方出版社
    7. print(res.addr)  # 东方
    8.  
    9. # (2)查询书籍主键为2的作者
    10. book_obj = models.Book.objects.filter(pk=1).first()
    11. # 书查作者 - 正向查询按字段
    12. res = book_obj.authors
    13. print(res)  # app01.Author.None
    14. # 列表中存放的是作者对象
    15. print(res.all())  # ]>
    16.  
    17. # (3)查询作者 的 电话号码
    18. author_obj = models.Author.objects.filter(name="dream").first()
    19. # 作者查询作者详情 - 正向查询按字段
    20. res = author_obj.author_detail
    21. print(res)  # AuthDetail object
    22. print(res.phone)  # 110
    23. print(res.addr)  # 山东
    24.  
    25. '''
    26.     在书写ORM语句的时候跟写SQL语句一样的
    27.     不要企图一次性将ORM语句写完，如果比较复杂，需要写一些看一些
    28.     正向 什么时候需要加 .all()
    29.         当查询返回的结果是多个的时候就需要用 .all()
    30.         当查询的结果只有一个的时候直接拿到数据对象
    31.             book_obj.publish
    32.             book_obj.authors.all()
    33.             author_obj.author_detail
    34.     '''
    35.  
    36. # (4)查询出版社是东方出版社出版的书
    37. # 先拿到出版社对象
    38. publish_obj = models.Publish.objects.filter(name="东方出版社").first()
    39. # 出版社查书 - 主键字段在书 - 反向查询
    40. res = publish_obj.book_set.all()
    41. # publish_obj.book_set
    42. # print(res) # app01.Book.None
    43. # publish_obj.book_set.all()
    44. print(res)  
    45. # , , ]>
    46.  
    47. # (5)查询作者是dream写过的书
    48. # 先拿到作者对象
    49. author_obj = models.Author.objects.filter(name="dream").first()
    50. # 作者查书 - 主键在书 - 反向
    51. res = author_obj.book_set.all()
    52. print(res)  # ]>
    53.  
    54. # (6)查询手机号是 110的作者姓名
    55. # 先拿到作者详情的对象
    56. author_detail_obj = models.AuthDetail.objects.filter(phone=110).first()
    57. # 详情查作者 - 主键在作者 - 反向
    58. res = author_detail_obj.author
    59. print(res)  # Author object
    60. print(res.name)  # dream

    基于对象

    • 反向查询的时候
      • 当你的查询结果可以有多个的时候 就必须加_set.all()
      • 当你的结果只有一个的时候 不需要加_set.all() 

    【2】联表查询(基于双下划线的跨表查询)

    1. # (1)查询dream的手机号和作者的姓名
    2. # 正向：先查询到作者信息再 .value(需要查询信息的表__需要查询的字段,其他字段)
    3. res = models.Author.objects.filter(name="dream").values('author_detail__phone', 'name')
    4. print(res)  
    5. # 
    6.  
    7. # 反向：先拿到详情，再用作者详情关联作者表，通过 __字段的方法 过滤出我们想要的指定数据
    8. res = models.AuthDetail.objects.filter(author__name="dream").values('phone', 'author__name')
    9. # AuthDetail.objects.filter(author__name="dream")
    10. print(res)  # ]>
    11. # AuthDetail.objects.filter(author__name="dream").values('phone','author__name')
    12. print(res)  # 
    13.  
    14. # (2)查询书籍主键ID为1的出版社名字和书的名字
    15. # 正向：先过滤出书籍ID为1的书籍对象，再去关联出版者表，利用__字段取值
    16. res = models.Book.objects.filter(pk=1).values('title', 'publish__name')
    17. print(res)  
    18. # 
    19.  
    20. # 反向：先查询到指定出版社，再从出版社反向找到书籍名字
    21. res = models.Publish.objects.filter(book__id=1).values('name', 'book__title')
    22. print(res)  # 
    23.  
    24. # (3)查询书籍主键ID为1的作者姓名
    25. # 先拿到 书籍主键ID为1的对象，再关联作者信息表，通过__字段取值
    26. res = models.Book.objects.filter(pk=1).values('authors__name')
    27. print(res)  # 
    28.  
    29. # 反向 : 先拿到 书籍ID为1的作者数据再去取作者的名字
    30. res = models.Author.objects.filter(book__id=1).values('name')
    31. print(res)  # 
    32.  
    33. # 查询书籍主键是1的作者的手机号
    34. # book author authordetail
    35. res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
    36. print(res)  #  
    37. '''
    38.     只要掌握了正反向的概念
    39.     以及双下划线查询
    40.     就可以无限跨表
    41.     '''

    八、聚合查询

    1. # 聚合查询
    2.     # 聚合查询通常情况下都是配合分组一起使用的
    3.     '''
    4.     只要是和数据库相关的模块
    5.         基本上都在 django.db.models 里面
    6.         如果这里面没有 那大概率可能在 django.db 里面
    7.     '''
    8.     from django.db.models import Max, Min, Sum, Count, Avg
    9.  
    10.     # (1)所有书的平均价格
    11.     # 正常情况下，我们是需要先进行分组再进行聚合函数运算的
    12.     # 但是Django给我们提供了一种方法 ：aggregate--> 可以不分组进行某个字段的聚合函数
    13.     res = models.Book.objects.aggregate(Avg('price'))
    14.     print(res)  # {'price__avg': 1890.083333}
    15.  
    16.     # (2)一次性使用
    17.     res = models.Book.objects.aggregate(Avg('price'), Max('price'), Min('price'), Sum('price'), Count('pk'))
    18.     print(res) 
    19.     # {'price__avg': 1890.083333, 'price__max': Decimal('5959.25'), 'price__min': Decimal('555.25'), 'price__sum': Decimal('11340.50'), 'pk__count': 6}

    九、分组查询

    1. # 分组查询   annotate
    2. '''
    3.     MySQL中的分组查询
    4.         分组之后只能获取到分组的依据，组内其他字段都无法获取
    5.             严格模式中可以修改
    6.             ONLY_FULL_GROUP_BY
    7.             set global sql_mode='ONLY_FULL_GROUP_BY'
    8.     '''
    9. from django.db.models import Max, Min, Sum, Count, Avg
    10. # (1)统计每一本书的作者个数
    11. # models 后面跟的是什么，就是按什么分组
    12. # res = models.Book.objects.annotate()
    13. res = models.Book.objects.annotate(author_number=Count('authors')).values('title','author_number')
    14. '''
    15. author_number 是我们自己定义的字段，用来存储统计出来的每本书的作者个数
    16. '''
    17. # 等价于
    18. # res = models.Book.objects.annotate(author_number=Count('authors__pk')).values('title','author_number')
    19. # print(res) 
    20. # 
    21.  
    22. # (2)统计每个出版社最便宜的书的价格
    23. res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name', 'min_price')
    24. print(res) 
    25. # 
    26.  
    27. # (3)统计不止一个作者的图书
    28. # (3.1)先按照图书分组
    29. # (3.2)过滤出不止一个作者的图书
    30. # 我的数据有限，我统计的是大于0的作者的图书
    31. res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=0).values('title', 'author_num')                                                                             
    32. '''
    33. 只要ORM语句得到的是 一个 queryset 对象
    34. 那么就可以继续无限制的调用封装 的方法
    35. '''
    36. print(res)  # 
    37.  
    38. # (4)查询每个作者出的书的总价格
    39. res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name', 'sum_price')
    40. print(res)  
    41. # 
    42.  
    43. '''
    44.     如果想按照指定的字段分组该如何处理
    45.     如果 annotate 前面没东西 则会按照 Book 分组 ，如果前面有参数 就会按照前面的参数进行分组 price
    46.     models.Book.objects.values('price').annotate()
    47.     机器上如果出现分组查询报错的情况
    48.     需要修改数据库严格模式
    49. '''

    十、F与Q查询

    【1】F查询

    1. from django.db.models import F
    2.  
    3. # (1)查出卖出数大于库存数的书籍
    4. # F 查询 : 帮助我们直接获取到表中的某个字段对应的数据
    5. res = models.Book.objects.filter(sales__gt=F('stock'))
    6. print(res)  # ]>
    7.  
    8. # (2).将所有书籍的价格提升500块
    9. res = models.Book.objects.update(price=F('price') + 500)
    10. print(res)  # 6 - 影响到了 6 条数据
    11.  
    12. # (3)将所有书的名称后边加上爆款两个字
    13. # 在操作字符串的时候，F查询不能够直接坐到字符串的拼接
    14. from django.db.models.functions import Concat
    15. from django.db.models import Value
    16.  
    17. res = models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
    18. print(res)
    19. # models.Book.objects.update(title=F('title') + '爆款')  # 所有的名称会全部变成空白

    【2】Q查询

    1. # F与Q查询
    2.  
    3. from django.db.models import Q
    4.  
    5. # (1)查询卖出数大于100或者价格小于500的书籍
    6.  
    7. # (1.1)直接使用 filter 查询数据，逗号隔开,里面放的参数是 and 关系
    8. res = models.Book.objects.filter(sales__gt=100, price__lt=500)
    9. print(res)  # 
    10.  
    11. # (1.2)直接使用 Q 查询数据，逗号隔开,里面放的参数还是 and 关系
    12. res = models.Book.objects.filter(Q(sales__gt=100), Q(price__lt=500))
    13. print(res)  # 
    14.  
    15. # (1.3)直接使用 Q 查询数据，逗号可以换成其他连接符达到效果
    16. res = models.Book.objects.filter(Q(sales__gt=100) or Q(price__lt=500))
    17. # 二者等价 (| ：或关系) (~  ： 取反 not 关系)
    18. res = models.Book.objects.filter(Q(sales__gt=100) | Q(price__lt=500))
    19. print(res)  
    20. # , , , ]>
    21.  
    22. # (2) Q的高阶用法 能够将查询条件的左边也变成 字符串形式
    23. # 产生 Q 对象
    24. q = Q()
    25. # 修改Q查询的默认连接条件
    26. q.connector = 'or'
    27. q.children.append('sales', 100)
    28. q.children.append('stock', 600)
    29. # filter 参数支持Q对象，默认还是 and 关系
    30. res = models.Book.objects.filter(q)
    31. print(res)
  • 相关阅读:
    Leetcode 222. 完全二叉树的节点个数
    讯飞离线语音合成新版(Aikit)-android sdk合成 demo（Java版本）
    jeecgboot-3.5.5本地安装部署
    java进阶—集合
    新知实验室_初探腾讯云音视频
    文心一言 VS 讯飞星火 VS chatgpt （82）-- 算法导论8.1 1题
    [附源码]Python计算机毕业设计高校教材网上征订系统
    Java高级编程day25【谷】
    MySQL-事务、日志
    Rust You Don’t Know
  • 原文地址：https://blog.csdn.net/qq_53842456/article/details/134422601