• Django框架之模型层（一）

    【一】前言

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

    【二】单表操作

    【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.     # (1)增加数据
    18.     # register_time (1)支持自己指定传值
    19.     res=models.User.objects.create(name='jason',age=18,register_time='2002-1-21')
    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(name='egon',age=84,register_time=ctime)
    28.     # 保存数据
    29.     user_obj.save()

    【2】数据的删除

    1. # 【2】删除数据
    2. # pk : 自动查找到当前表的主键字段，指代的就是当前表的主键字段
    3. # 使用 pk 后不需要知道当前表的主键字段 ， 他会自动帮我们查找并匹配
    4. # (1)方式一
    5. res = models.User.objects.filter(pk=2).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. # 【3】数据的更改
    2. # (1)方式一
    3. res = models.User.objects.filter(pk=4).update(name='egonDSB')
    4. print(res)  # 1
    5. # (2)方式二
    6. # 返回的就是当前的数据对象
    7. # 不推荐使用 ： 如果查询的数据不存在会直接报错 ，fileter不会
    8. user_onj = models.User.objects.get(pk=4)
    9. # user_obj = models.User.objects.filter(pk=6)
    10.    """
    11.     get方法返回的直接就是当前数据对象
    12.     但是该方法不推荐使用
    13.         一旦数据不存在该方法会直接报错
    14.         而filter则不会
    15.             所以我们还是用filter
    16.     """
    17. # 调用对象更改数据
    18. user_onj.name = 'egonPPP'
    19. user_onj.save()

    【三】常见的十几种查询方法

    1. # 必知必会13条
    2.     1.all()  查询所有数据
    3.  
    4.     2.filter()     带有过滤条件的查询
    5.  
    6.     3.get()        直接拿数据对象 但是条件不存在直接报错
    7.  
    8.     4.first()      拿queryset里面第一个元素
    9.     res = models.User.objects.all().first()
    10.     print(res)
    11.  
    12.     5.last()
    13.     res = models.User.objects.all().last()
    14.     print(res)
    15.  
    16.     6.values()  可以指定获取的数据字段  select name,age from ...    列表套字典
    17.     res = models.User.objects.values('name','age')  # 
    18.     print(res)
    19.  
    20.     7.values_list()  列表套元祖
    21.     res = models.User.objects.values_list('name','age')  # 
    22.     print(res)
    23.     """
    24.      查看内部封装的sql语句
    25.      上述查看sql语句的方式  只能用于queryset对象
    26.      只有queryset对象才能够点击query查看内部的sql语句
    27.    
    28.     """
    29.     8.distinct()  去重
    30.     res = models.User.objects.values('name','age').distinct()
    31.     print(res)
    32.     """
    33.     去重一定要是一模一样的数据
    34.     如果带有主键那么肯定不一样 你在往后的查询中一定不要忽略主键
    35.     
    36.     """
    37.     9.order_by()
    38.     res = models.User.objects.order_by('age')  # 默认升序
    39.     res = models.User.objects.order_by('-age')  # 降序
    40.     print(res)
    41.   
    42.     10.reverse()  反转的前提是 数据已经排过序了  order_by()
    43.     res = models.User.objects.all()
    44.     res1 = models.User.objects.order_by('age').reverse()
    45.     print(res,res1)
    46.  
    47.     11.count()  统计当前数据的个数
    48.     res = models.User.objects.count()
    49.     print(res)
    50.  
    51.     12.exclude()  排除在外
    52.     res = models.User.objects.exclude(name='jason')
    53.     print(res)
    54.  
    55.     13.exists()  基本用不到因为数据本身就自带布尔值  返回的是布尔值
    56.     res = models.User.objects.filter(pk=10).exists()
    57.     print(res)

    【四】测试脚本

    • 测试脚本

      • 当我们只想要测试Django中的某一个py文件的内容时，我们可以不需要书写前后端交互的形式，而是直接写一个测试脚本即可

    • 测试环境的准备

      • 在测试文件中书写下面内容

    • 这内容其实就是最外部 manage.py 文件中的上面几句话

      • 脚本代码无论是写在应用下的 tests.py文件还是自己新建文件，将内容写在新文件中，都会生效
    1. from django.test import TestCase
    2.  
    3.  
    4. import os
    5. import sys
    6.  
    7. if __name__ == "__main__":
    8.     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings")
    9.  
    10.     import django
    11.     django.setup()
    12.     
    13.     # 在下面书写我们需要测试的代码
    14.     # 即所有的测试代码都必须等待环境准备完毕之后才能书写

    【五】查看内部SQL语句的方式

    【1】方式一

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

    1. res = models.User.objects.values_list('name','age')  # 
    2. print(res.query)

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

    【七】多表查询引入

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

    【2】外键的增删改查

    (1)一对多外键的增删改查
    1.1 外键的增加
    1.     # 1  直接写实际字段 id
    2.     models.Book.objects.create(title='论语',price=899.23,publish_id=1)
    3.     models.Book.objects.create(title='聊斋',price=444.23,publish_id=2)
    4.     models.Book.objects.create(title='老子',price=333.66,publish_id=1)
    5.     # 2  虚拟字段 对象
    6.     publish_obj = models.Publish.objects.filter(pk=2).first()
    7.     models.Book.objects.create(title='红楼梦',price=666.23,publish=publish_obj)
    1.2 外键的删除
    1. # (2)一对多的外键的删除
    2. models.Publish.objects.filter(pk=1).delete()
    1.3 外键的修改
    1. # (2)一对多的外键的修改
    2. #  - 直接写实际字段
    3. models.Book.objects.filter(pk=1).update(publish_id=2)
    4. #  - 虚拟字段
    5. publish_obj = models.Publish.objects.filter(pk=1).first()
    6.  
    7. models.Book.objects.filter(pk=1).update(publish=publish_obj)
    (2)多对多外键的增删改查

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

    2.1 增加
    1.     book_obj = models.Book.objects.filter(pk=1).first()
    2.     print(book_obj.authors)  # 就类似于你已经到了第三张关系表了
    3.     book_obj.authors.add(1)  # 书籍id为1的书籍绑定一个主键为1 的作者
    4.     book_obj.authors.add(2,3)# 可以传多个参数
    5.  
    6.     author_obj = models.Author.objects.filter(pk=1).first()
    7.     author_obj1 = models.Author.objects.filter(pk=2).first()
    8.     author_obj2 = models.Author.objects.filter(pk=3).first()
    9.     book_obj.authors.add(author_obj)
    10.     book_obj.authors.add(author_obj1,author_obj2)
    11.     """
    12.     add给第三张关系表添加数据
    13.         括号内既可以传数字也可以传对象 并且都支持多个
    14.     """
    2.2 删除

        remove
            括号内既可以传数字也可以传对象 并且都支持多个

    1.     # 删
    2.     book_obj.authors.remove(2)
    3.     book_obj.authors.remove(1,3)
    4.  
    5.     author_obj = models.Author.objects.filter(pk=2).first()
    6.     author_obj1 = models.Author.objects.filter(pk=3).first()
    7.     book_obj.authors.remove(author_obj,author_obj1)
    2.3 更改

        set
            括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个

    1.     # 修改
    2.     book_obj.authors.set([1,2])  # 括号内必须给一个可迭代对象
    3.     book_obj.authors.set([3])  # 括号内必须给一个可迭代对象
    4.  
    5.     author_obj = models.Author.objects.filter(pk=2).first()
    6.     author_obj1 = models.Author.objects.filter(pk=3).first()
    7.     book_obj.authors.set([author_obj,author_obj1])  # 括号内必须给一个可迭代对象
    2.4 清空

        clear
            括号内不要加任何参数

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

    【补充】正反向的概念

    • 正向

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

    • 反向

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

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

    正向查询按外键字段
    反向查询按表名（小写）
                    _set

    【八】多表查询

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

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

    【补充】_set.all()(反向查询)

    • 查询结果是多个的时候需要加
    • 查询结果是多个的时候需要加

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

    1. # [2] 基于双下划线的跨表查询
    2. # (1)查询dream的手机号和作者的姓名
    3. # 正向：先查询到作者信息再 .value(需要查询信息的表__需要查询的字段,其他字段)
    4. res = models.Author.objects.filter(name="dream").values('author_detail__phone', 'name')
    5. print(res)  # 
    6. # 反向：先拿到详情，再用作者详情关联作者表，通过 __字段的方法 过滤出我们想要的指定数据
    7. res = models.AuthDetail.objects.filter(author__name="dream").values('phone', 'author__name')
    8. # AuthDetail.objects.filter(author__name="dream")
    9. print(res)  # ]>
    10. # AuthDetail.objects.filter(author__name="dream").values('phone','author__name')
    11. print(res)  # 
    12.  
    13. # (2)查询书籍主键ID为1的出版社名字和书的名字
    14. # 正向：先过滤出书籍ID为1的书籍对象，再去关联出版者表，利用__字段取值
    15. res = models.Book.objects.filter(pk=1).values('title', 'publish__name')
    16. print(res)  # 
    17. # 反向：先查询到指定出版社，再从出版社反向找到书籍名字
    18. res = models.Publish.objects.filter(book__id=1).values('name', 'book__title')
    19. print(res)  # 
    20.  
    21. # (3)查询书籍主键ID为1的作者姓名
    22. # 先拿到 书籍主键ID为1的对象，再关联作者信息表，通过__字段取值
    23. res = models.Book.objects.filter(pk=1).values('authors__name')
    24. print(res)  # 
    25. # 反向 : 先拿到 书籍ID为1的作者数据再去取作者的名字
    26. res = models.Author.objects.filter(book__id=1).values('name')
    27. print(res)  # 
    28.  
    29. # 查询书籍主键是1的作者的手机号
    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.     '''
    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) # {'price__avg': 1890.083333, 'price__max': Decimal('5959.25'), 'price__min': Decimal('555.25'), 'price__sum': Decimal('11340.50'), 'pk__count': 6}

    【十】分组查询

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

    【十一】F与Q查询

    【1】F查询

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

    【2】Q查询

    1.  # Q查询
    2.     # 1.查询卖出数大于100或者价格小于600的书籍
    3.     res = models.Book.objects.filter(maichu__gt=100,price__lt=600)
    4.     """filter括号内多个参数是and关系"""
    5.     from django.db.models import Q
    6.     res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600))  # Q包裹逗号分割 还是and关系
    7.     res = models.Book.objects.filter(Q(maichu__gt=100)|Q(price__lt=600))  # | or关系
    8.     res = models.Book.objects.filter(~Q(maichu__gt=100)|Q(price__lt=600))  # ~ not关系
    9.     print(res)  # 
    10.  
    11.     # Q的高阶用法  能够将查询条件的左边也变成字符串的形式
    12.     q = Q()
    13.     q.connector = 'or'
    14.     q.children.append(('maichu__gt',100))
    15.     q.children.append(('price__lt',600))
    16.     res = models.Book.objects.filter(q)  # 默认还是and关系
    17.     print(res)

  • 相关阅读:
    QTableWidget中cell 和 item区别
    cat命令应用
    解决uniapp组件uni-file-picker设置:disable-preview=“true“关闭预览不生效的问题 - 禁用图片预览无效的手动解决办法
    视频倒放怎么制作？快来学会这几个简单的方法
    一、【漏洞复现系列】Tomcat文件上传 (CVE-2017-12615)
    googletest简介
    股票预测和股票分析就用FineBI！
    UNIAPP实战项目笔记42 购物车页面新增收货地址
    文档管理软件中真正重要的 10 件事
    Nodered系列—使用mqtt写入国产数据库tDengine
  • 原文地址：https://blog.csdn.net/m0_71292438/article/details/134429632