• 11.16 知识总结（模型层更多内容）

    一、 多表查询（跨表查询）


    子查询：分步查询
    链表查询：把多个有关系的表拼接成一个大表(虚拟表)
        inner join 
        left join
        right join

     1.1 基于双下划线的查询

    1.  # 1 年龄大于35岁的数据
    2.      res = models.User.objects.filter(age__gt=35)
    3.      print(res)
    4.      2 年龄小于35岁的数据
    5.      res = models.User.objects.filter(age__lt=35)
    6.      print(res)
    7.      大于等于 小于等于
    8.      res = models.User.objects.filter(age__gte=32)
    9.      print(res)
    10.      res = models.User.objects.filter(age__lte=32)
    11.      print(res)
    12.  
    13.      年龄是18 或者 32 或者40
    14.      res = models.User.objects.filter(age__in=[18,32,40])
    15.      print(res)
    16.  
    17.      年龄在18到40岁之间的  首尾都要
    18.      res = models.User.objects.filter(age__range=[18,40])
    19.      print(res)
    20.  
    21.      查询出名字里面含有s的数据  模糊查询
    22.      res = models.User.objects.filter(name__contains='s')
    23.      print(res)
    24.     
    25.      是否区分大小写  查询出名字里面含有p的数据  区分大小写
    26.      res = models.User.objects.filter(name__contains='p')
    27.      print(res)
    28.      忽略大小写
    29.      res = models.User.objects.filter(name__icontains='p')
    30.      print(res)
    31.  
    32.      res = models.User.objects.filter(name__startswith='j')
    33.      res1 = models.User.objects.filter(name__endswith='j')
    34.     
    35.      print(res,res1)
    36.  
    37.  
    38.      查询出注册时间是 2020 1月
    39.      res = models.User.objects.filter(register_time__month='1')
    40.      res = models.User.objects.filter(register_time__year='2020')

    12 多表查询前期表准备

    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()  # 电话号码用BigIntegerField或者直接用CharField
    31.     addr = models.CharField(max_length=64)

    1.3   一对多外键增删改查

    1.  一对多外键增删改查
    2.      增
    3.      1  直接写实际字段 id
    4.      models.Book.objects.create(title='论语',price=899.23,publish_id=1)
    5.      models.Book.objects.create(title='聊斋',price=444.23,publish_id=2)
    6.      models.Book.objects.create(title='老子',price=333.66,publish_id=1)
    7.     2  虚拟字段 对象
    8.      publish_obj = models.Publish.objects.filter(pk=2).first()
    9.      models.Book.objects.create(title='红楼梦',price=666.23,publish=publish_obj)
    10.  
    11.      删
    12.      models.Publish.objects.filter(pk=1).delete()  # 级联删除
    13.  
    14.      修改
    15.      models.Book.objects.filter(pk=1).update(publish_id=2)
    16.      publish_obj = models.Publish.objects.filter(pk=1).first()
    17.      models.Book.objects.filter(pk=1).update(publish=publish_obj)

    1.4  多对多外键增删改查

    1.  如何给书籍添加作者？
    2.     book_obj = models.Book.objects.filter(pk=1).first()
    3.      print(book_obj.authors)  # 就类似于你已经到了第三张关系表了
    4.      book_obj.authors.add(1)  # 书籍id为1的书籍绑定一个主键为1 的作者
    5.      book_obj.authors.add(2,3)
    6.  
    7.      author_obj = models.Author.objects.filter(pk=1).first()
    8.      author_obj1 = models.Author.objects.filter(pk=2).first()
    9.      author_obj2 = models.Author.objects.filter(pk=3).first()
    10.      book_obj.authors.add(author_obj)
    11.      book_obj.authors.add(author_obj1,author_obj2)
    12.     """
    13.     add给第三张关系表添加数据
    14.         括号内既可以传数字也可以传对象 并且都支持多个
    15.     """
    16.  
    17.      删
    18.      book_obj.authors.remove(2)
    19.      book_obj.authors.remove(1,3)
    20.  
    21.      author_obj = models.Author.objects.filter(pk=2).first()
    22.      author_obj1 = models.Author.objects.filter(pk=3).first()
    23.      book_obj.authors.remove(author_obj,author_obj1)
    24.     """
    25.     remove
    26.         括号内既可以传数字也可以传对象 并且都支持多个
    27.     """
    28.  
    29.  
    30.      修改
    31.      book_obj.authors.set([1,2])  # 括号内必须给一个可迭代对象
    32.      book_obj.authors.set([3])  # 括号内必须给一个可迭代对象
    33.  
    34.      author_obj = models.Author.objects.filter(pk=2).first()
    35.      author_obj1 = models.Author.objects.filter(pk=3).first()
    36.      book_obj.authors.set([author_obj,author_obj1])  # 括号内必须给一个可迭代对象
    37.  
    38.     """
    39.     set
    40.         括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个
    41.     """
    42.  
    43.  
    44.     # 清空
    45.     # 在第三张关系表中清空某个书籍与作者的绑定关系
    46.     book_obj.authors.clear()
    47.     """
    48.     clear
    49.         括号内不要加任何参数
    50.     
    51.     """

    1.5 正反向的概念 

    # 正向
    # 反向
        外键字段在我手上那么，我查你就是正向
          外键字段如果不在手上，我查你就是反向
      
      book >>>外键字段在书那儿(正向)>>> publish
      publish    >>>外键字段在书那儿(反向)>>>book
      
      一对一和多对多正反向的判断也是如此
      
    """
    正向查询按外键字段
    反向查询按表名小写
                    _set
                    ...
    """

    二、子查询(基于对象的跨表查询)

    1. # 1.查询书籍主键为1的出版社
    2.      book_obj = models.Book.objects.filter(pk=1).first()
    3.      # 书查出版社 正向
    4.      res = book_obj.publish
    5.     # print(res)
    6.      print(res.name)
    7.      print(res.addr)
    8.  
    9.      2.查询书籍主键为2的作者
    10.      book_obj = models.Book.objects.filter(pk=2).first()
    11.       书查作者 正向
    12.       res = book_obj.authors  # app01.Author.None
    13.      res = book_obj.authors.all()  # , ]>
    14.     
    15.      print(res)
    16.  
    17.      3.查询作者jason的电话号码
    18.      author_obj = models.Author.objects.filter(name='jason').first()
    19.      res = author_obj.author_detail
    20.      print(res)
    21.      print(res.phone)
    22.      print(res.addr)
    23.  
    24.     """
    25.     在书写orm语句的时候跟写sql语句一样的
    26.     不要企图一次性将orm语句写完 如果比较复杂 就写一点看一点
    27.     
    28.     正向什么时候需要加.all()
    29.         当你的结果可能有多个的时候就需要加.all()
    30.         如果是一个则直接拿到数据对象
    31.             book_obj.publish
    32.             book_obj.authors.all()
    33.             author_obj.author_detail
    34.     """
    35.      4.查询出版社是东方出版社出版的书
    36.      publish_obj = models.Publish.objects.filter(name='东方出版社').first()
    37.      出版社查书  反向
    38.      res = publish_obj.book_set  # app01.Book.None
    39.      res = publish_obj.book_set.all()
    40.      print(res)
    41.  
    42.      5.查询作者是jason写过的书
    43.      author_obj = models.Author.objects.filter(name='jason').first()
    44.      作者查书      反向
    45.      res = author_obj.book_set  # app01.Book.None
    46.      res = author_obj.book_set.all()
    47.      print(res)
    48.  
    49.      6.查询手机号是110的作者姓名
    50.      author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
    51.      res = author_detail_obj.author
    52.      print(res.name)
    53.     """
    54.     基于对象 
    55.         反向查询的时候
    56.             当你的查询结果可以有多个的时候 就必须加_set.all()
    57.             当你的结果只有一个的时候 不需要加_set.all()
    58.         自己总结出 自己方便记忆的即可 每个人都可以不一样
    59.     """

       三、 联表查询(基于双下划线的跨表查询)

    1. # 基于双下划线的跨表查询
    2.  
    3.  
    4.      1.查询jason的手机号和作者姓名
    5.      res = models.Author.objects.filter(name='jason').values('author_detail__phone','name')
    6.      print(res)
    7.      反向
    8.      res = models.AuthorDetail.objects.filter(author__name='jason')  # 拿作者姓名是jason的作者详情
    9.      res = models.AuthorDetail.objects.filter(author__name='jason').values('phone','author__name')
    10.      print(res)
    11.  
    12.  
    13.      2.查询书籍主键为1的出版社名称和书的名称
    14.      res = models.Book.objects.filter(pk=1).values('title','publish__name')
    15.      print(res)
    16.      反向
    17.      res = models.Publish.objects.filter(book__id=1).values('name','book__title')
    18.      print(res)
    19.  
    20.      3.查询书籍主键为1的作者姓名
    21.      res = models.Book.objects.filter(pk=1).values('authors__name')
    22.      print(res)
    23.      反向
    24.      res = models.Author.objects.filter(book__id=1).values('name')
    25.      print(res)
    26.  
    27.  
    28.      查询书籍主键是1的作者的手机号
    29.     
    30.      book author authordetail
    31.      res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
    32.      print(res)
    33.     """
    34.     你只要掌握了正反向的概念
    35.     以及双下划线
    36.     那么你就可以无限制的跨表
    37.     
    38.     """

    四、  聚合查询

    常见的统计总数，计算平均值的操作，可以用聚合函数来实现，常见的聚合函数有

    1.   聚合查询通常情况下都是配合分组一起使用的
    2.     只要是跟数据库相关的模块 
    3.         基本上都在django.db.models里面
    4.         如果上述没有那么应该在django.db里面
    5.     """
    6.     from app01 import models
    7.     from django.db.models import Max,Min,Sum,Count,Avg
    8.     # 1 所有书的平均价格
    9.     # res = models.Book.objects.aggregate(Avg('price'))
    10.     # print(res)
    11.     # 2.上述方法一次性使用
    12.     res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('pk'),Avg('price'))
    13.     print(res)

    五、  分组查询

    1.  MySQL分组查询都有哪些特点
    2.         分组之后默认只能获取到分组的依据 组内其他字段都无法直接获取了
    3.             严格模式
    4.                 ONLY_FULL_GROUP_BY
    5.             set global sql_mode='ONLY_FULL_GROUP_BY'
    6.                 
    7.     """
    8.     from django.db.models import Max, Min, Sum, Count, Avg
    9.      1.统计每一本书的作者个数
    10.      res = models.Book.objects.annotate()  # models后面点什么 就是按什么分组
    11.      res = models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
    12.     """
    13.     author_num是我们自己定义的字段 用来存储统计出来的每本书对应的作者个数
    14.     """
    15.      res1 = models.Book.objects.annotate(author_num=Count('authors__id')).values('title','author_num')
    16.      print(res,res1)
    17.     """
    18.     代码没有补全 不要怕 正常写
    19.     补全给你是pycharm给你的 到后面在服务器上直接书写代码 什么补全都没有 颜色提示也没有
    20.     
    21.     """
    23.      2.统计每个出版社卖的最便宜的书的价格(作业:复习原生SQL语句 写出来)
    24.      res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
    25.      print(res)
    27.      3.统计不止一个作者的图书
    28.          1.先按照图书分组 求每一本书对应的作者个数
    29.          2.过滤出不止一个作者的图书
    30.      res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title','author_num')
    31.      """
    32.      只要你的orm语句得出的结果还是一个queryset对象
    33.      那么它就可以继续无限制的点queryset对象封装的方法
    34.     
    35.      """
    36.      print(res)
    38.      4.查询每个作者出的书的总价格
    39.     
    40.  res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
    41.     # print(res)
    43.     
    44. """
    45.     如果我想按照指定的字段分组该如何处理呢？
    46.         models.Book.objects.values('price').annotate()
    47.     后续BBS作业会使用
    48.     
    49.     
    50.     你们的机器上如果出现分组查询报错的情况
    51.         你需要修改数据库严格模式

     六、 F与Q查询

    3. 1 F查询

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

      6.2   Q查询

    Q查询
        # 1.查询卖出数大于100或者价格小于600的书籍
        # res = models.Book.objects.filter(maichu__gt=100,price__lt=600)
        """filter括号内多个参数是and关系"""
        from django.db.models import Q
        # res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600))  # Q包裹逗号分割 还是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)  #

        # Q的高阶用法  能够将查询条件的左边也变成字符串的形式
        q = Q()
        q.connector = 'or'
        q.children.append(('maichu__gt',100))
        q.children.append(('price__lt',600))
        res = models.Book.objects.filter(q)  # 默认还是and关系
        print(res)

  • 相关阅读:
    在Linux安装nginx
    java中如何让1+1=3
    极大似然法
    力扣 8. 字符串转换整数 (atoi)
    【苹果家庭推送iMessage】软件安装应用程序访问HealthKit HomeKit
    Java多态
    iwebsec靶场 文件包含漏洞通关笔记8-php://input伪协议利用
    Ubuntu 20.04安装绿联PL2303串口驱动
    java:数组缩减
    MSPG3507——蓝牙接收数据显示在OLED，滴答定时器延时500MS
  • 原文地址：https://blog.csdn.net/weixin_66010453/article/details/134442538