• Django 07

    今日考题

    1.必知必会N条都有哪些，每个都是干啥使的

    1. models.User.objects.all() # 查询所有数据
    2. models.User.objects.filter() # 带有过滤条件的查询
    3. models.User.objects.get() # 直接拿数据对象，条件不存在直接报错
    4. models.User.objects.all().first() # 拿queryset里面的第一个元素
    5. models.User.objects.all().last() # 拿queryset里面的最后一个元素
    6. models.User.objects.values('name') # 可以指定获取数据字段 相当于select name from ...
    7. models.User.objects.values('name','age').distinct() # 去重一定要去除一模一样的数据，如果带有主 
    8.                                                        键那么一定不一样数据
    9. models.User.objects.order_by('age') # 默认升序
    10. models.User.objects.order_by('-age') # 降序
    11. models.User.objects.order_by('age').reverse()# 反转的前提一定是已经排过序
    12. models.User.object.count() # 统计当前数据的个数
    13. models.User.object.exclude(name='jaosn')# 排除在外
    14. models.User.object.filter(pk=1).exist()# 返回布尔值 判断数据对象是否存在

    2.简述神奇的双下划线查询都有哪些方法，作用是什么

    1. 1、年龄大于35岁的数据
    2. res = models.User.objects.filter(age__gt=35)
    3. 2、年龄小于35岁的数据
    4. res = models.User.objects.filter(age__lt=35)
    5. 3、大于等于 小于等于
    6. res = models.User.objects.filter(age__gte=35)
    7. res = models.User.objects.filter(age__lte=35)
    8. 4、年龄是18 或者32 或者40
    9. res = models.User.objects.filter(age__in=[18,32,40])
    10. 5、年龄在18到40岁之间 首位都要
    11. res = models.User.objects.filter(age__range=[18,40])
    12. 6、查询名字带有s的数据 模糊查询 区分大小写
    13. res = models.User.objects.filter(name__contains='s')
    14. 不区分大小写
    15. res = models.User.object.filter(name__icontains='s')
    16. 7、查询名字开头结尾是否带有J
    17. res = models.User.objects.filter(name__startswith='j')
    18. res = models.User.objects.filter(name__endswith='j')
    19. 8、查新注册时间是2002年1月
    20. res = models.User.objects.filter(register_time__year='2002')
    21. res = models.User.object.filter(register_time__month='1')
    22.

    3.针对多对多外键字段的增删改查方法有哪些，各有什么特点？

    1. # 多对多外键表是第三方表\
    2. # 增
    3. 方法1：直接给定绑定编号
    4. book_obj = models.Book.objects.filter(pk=1).first() # 主键值为1的book对象
    5. book_obj.authors # 进入第三个虚拟表中
    6. book_obj.authors.add(1) # 给主键值为1的book对象绑定主键值为1的作者 （一本书一个作者）
    7. book_obj.authors.add(1,2)# 给主键值为1的book对象绑定主键值为1,2的作者（一本书两个作者）
    8. 方法二：虚拟字段，绑定对象
    9. author_obj = models.Author.objects.filter(pk=1).first() # 主键值为1的author对象
    10. book_obj.authors.add(author_obj)
    11. '''
    12. add() 给第三方表传数字也可以是对象，并且都支持多个
    14. '''
    15. # 删
    16. book_obj.authors.remove(1) # 删除给book对象绑定的单个作者
    17. book_obj.authors.remove(1,2) # 删除给book对象绑定的多个作者
    18. '''
    19. remove()就可以传对象 也可以传数字
    20. '''
    21. # 修改
    22. book_obj.authors.set([1,2]) # 括号内必须给一个可迭代对象
    23. 虚拟对象方式
    24. author_obj = models.Author.objects.filter(pk=2).first()
    25. book_obj.authors.set([author_obj]) 
    26. '''
    27. 括号内必须传一个可迭代对象，该对象既可以是数字，也可以是对象，并且都支持多个
    29. '''
    30. # 清空
    31. 清空第三方表中书籍与某些作者的第三方关系
    32. book_obj.authors.clear() # 清空主键字段为1的书籍与作者的绑定关系
    33. '''
    34. clear()括号内不加任何参数
    35. '''

    4.什么是正反向的概念，及查询口诀，你能否总结一下正反向查询不同情况下点击不同字段的规律

    1. # 正向
    2. 外键字段在我手上，我查你就是正向
    3. # 反向
    4. 外键字段不在我手上，我查你就是反向
    5. eg:
    6. Book 外键字段在书在（正向）>> Publish
    7. Publish 外键字段是书（反向）>>> Book
    8. '''
    9. 一对一和多对多的正反向查询也是如此
    10. 口诀：正向查询按字段 反向查询按表明小写 --set
    11. '''

    上周内容回顾

    单表的增删改查

    1. # 增
    2. 1.create()
    3. 2.对象.save()
    4. # 查
    5. 1. all() 查所有
    6. 2. 筛选条件，括号内多个参数之间逗号隔开 并且默认是and关系
    7. 3. get()  条件不存在直接报错 不推荐使用
    8. # 改
    9.  update()  queryset对象帮你封装的批量更新
    10. 对象.save()
    11. # 删
    12. delete() queryset对象帮你封装的批量删除
    13. 对象.delete()
    14. '''
    15. 在实际项目中数据是不可能真正删除的 一般情况下都用一个字段来标记是否删除
    16. '''

    测试环境准备

    1. # 你如果只想测试django某一py文件（大部分情况下就是models.py）
    2. # 在应用下的tests.py或者自己新建一个py文件
    3. '''
    4. 1.去manage.py拷贝前四行
    5. 2.自己书写两行
    6.     import django
    7.     django.setup()
    8. '''
    9.

    如何查看ORM内部的sql语句

    1. # 1.queryset对象可以直接点query查看
    2. queryset对象.query
    3. # 2.配置文件配置日志相关代码即可（不用记，直接复制粘贴）
    4. LOGGING = {
    5.     'version': 1,
    6.     'disable_existing_loggers': False,
    7.     'handlers': {
    8.         'console':{
    9.             'level':'DEBUG',
    10.             'class':'logging.StreamHandler',
    11.         },
    12.     },
    13.     'loggers': {
    14.         'django.db.backends': {
    15.             'handlers': ['console'],
    16.             'propagate': True,
    17.             'level':'DEBUG',
    18.         },
    19.     }
    20. }

    必知必会N多条

    1. # 1.all() 查看所有数据
    2. # 2.filter() 我们在利用主键字段筛选数据的时候，可以不考虑主键字段叫什么，直接使用pk代替
    3. # 3.get() 筛选条件不存在直接报错
    4. # 4.values() 获取指定字段的数据 返回结果是一个queryset对象（列表套字典的形式）
    5. # 5.values_list() 获取指定字段对应的数据 返回结果是一个queryset对象（列表套元组的形式）
    6. # 6.count() 统计查询出来的数据个数
    7. # 7.first()
    8. # 8.last()
    9. # 9.order_by() 默认是升序 你可以在字段前面加一个-变成降序
    10. # 10.reverse() 前面已经是排序过了 之后在反转
    11. # 11.exclude() 排除...在外
    12. # 12.distinct() 去重（主键一定不要忘记）
    13. # 13.exists() 判断数据值是否有值 返回布尔值
    14.  
    15.  
    16.

    神奇的双下划线查询

    1. # 价格大于 小于 大于等于 小于等于
    2. prince__gt
    3. prince__lt
    4. prince__gte
    5. prince__lte
    6.  
    7.  
    8. # 成员运算
    9. prince__in
    10.  
    11. # 范围查询
    12. prince__range
    13.  
    14. # 模糊查询
    15. title__contains 默认是区分大小写
    16. title__icontains 忽略大小写
    17.  
    18. # 只按照年份或者月份或者
    19. create_time__yaer
    20. cretae_time__month

    外键字段的增删改查

    U盘启动加载NVME驱动
    rar 0星 超过10%的资源 6.74MB
    下载
    1. # 一对多
    2. publish_id = 1
    3. publish = publish_obj
    4.  
    5. # 多对多
    6. add
    7. remove
    8. 上述两个方法括号内既可以传对象也可以传数字并且都支持多个
    9. set 括号内必须传一个可迭代对象 可迭代对象里面可以是数字也可以是对象并且都支持传多个
    10. clear 括号内无需给任何参数 直接清空对应的数据关系

    多表查询

    1. # 正反向概念
    2. 正向 外键字段就在我手中
    3. 反向 外键字段不在我手中
    4. #小口诀
    5. 正向查询按外键字段 反向查询按表明小写
    6. _set
    7. .all()
    8.  
    9. # 温馨提示
    10. 书写sql语句和orm语句一样 不要试图一次性写完 可以分步写
    11. '''
    12. 多表操作
    13. 1.子查询
    14. 2.联表操作
    15. inner join
    16. left join
    17. right join
    18. union
    21. Django orm中
    22. 1 基于对象的跨表查询
    23.     子查询
    24.         先拿到一个数据对象 然后点点点
    25. 2 基于双下划线的跨表查询
    26.     联表查询
    29. '''
    30. 1.基于对象的跨表查询
    31. book_obj.publish
    32. book_obj.authors.all()
    33. author_obj.author_detail
    34.  
    35.  
    36. publish_obj.book_set.all()
    37. author_obj.book_set.all()
    38.  
    39. 2.基于上下划线的跨表查询
    40. models.Book.objects.filter(pk=1).values('title','publish__name')
    41. models.Publish.objects.filter(pk=1).values('book_title','name')
    42. # 利用双下划线的跨表查询可以帮助你跨n多张表 只要有外键字段
    43. models.Book.objects.filter(pk=1).values('authors__author_detail__phone')

    今日内容概要

    • 聚合查询（聚合函数的使用）
    • 分组查询的使用
    • F与Q查询
    • django中如何开启事物
    • orm中常用字段及参数
    • 数据库查询优化（only与defer、select_related与prefetch_related）
    • 图书管理系统作业讲解

    今日内容详细

    聚合查询

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

    分组查询

    1. # 分组查询 annotate
    2. '''
    4. mysql分组查询有那些特点
    5. 分组之后默认只能获取到分组的依据 组内其他字段都无法直接获取
    6. 严格模式
    7.     ONLY_FULL_GROUP_BY
    9. '''
    10. # 1、统计每一本书的作者个数
    11.     res = models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
    12.     print(res)
    13. models后面点书就按照书分组，author_num是我们自己定义的字段 用来存储统计出来的每本书对应的作者个数
    14. '''
    15. 代码没有补全不要怕正常写 补全是pycharm给你的 后面到服务器上面直接书写代码 什么补全都没有
    16. '''
    17.  # 2.统计每个出版社卖的最便宜的书的价格
    18.     res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
    19.     print(res)
    20.  
    21.     # 3.统计不止一个作者的图书（先按照图书分组，求每一本书对应的作者个数，过滤出不止一个作者的图书）
    22.     res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title','author_num')
    23.     print(res)
    24.  
    25. '''
    26. 只要你的orm语句结果还是一个queryset对象那么他就可以无限制的点queryset对象封装的方法
    27. '''
    28.  
    29. # 4.查询每个作者出的书的总价格
    30.     res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
    31.     print(res)
    32.  
    33. '''
    34. 如果我想要按照指定的字段如何处理呢？
    35. models.Book.objects.values('price').annotate()
    36. '''
    测试方案说明书.doc
    doc 1星 超过10%的资源 69KB
    下载

    F与Q查询

    1. # F查询
    2.     from django.db.models import F
    3. '''
    4. 能帮助你直接获取表中的某个数据
    5. 在操作字符类型数据的时候 F不能够做到字符串的拼接
    6. '''
    7.  
    8.     # 1、查询卖出数大于库存数的书籍
    9.     res = models.Book.objects.filter(maichu__gt=F('kucun')).first()
    10.     print(res.title)
    11.  
    12.     # 2.将所有的书籍价格提高500元
    13.      res = models.Book.objects.update(price=F('price')+500)
    14.  
    15.     # 3.将所有书的后面名称都加上爆款两字
    16.     from django.db.models.functions import Concat
    17.     from django.db.models import Value
    18.  
    19.      res = models.Book.objects.update(title=Concat(F('title'),Value('爆款')))
    20.  
    21.      res = models.Book.objects.update(title=F('title')+'爆款') #所有名称都会变成空白
    22. # Q查询
    23.  
    24.  # 1.查询卖出数大于800 价格小于800的书籍
    25.     # res = models.Book.objects.filter(maichu__gt=800,price__lt=900)
    26.     # print(res)
    27.     '''
    28.     filter括号内多个参数之间是and关系
    29.     
    30.     '''
    31.     from django.db.models import Q
    32.     # res = models.Book.objects.filter(Q(maichu__gt=800),Q(price__lt=900)) #Q包裹逗号分割 还是and关系
    33.     # res = models.Book.objects.filter(Q(maichu__gt=800)|Q(price__lt=900)) #| or关系
    34.     # res = models.Book.objects.filter(~Q(maichu__gt=800)Q(price__lt=900)) #~ not关系
    35.     # print(res)
    36.     # Q的高阶用法 能够将查询条件的左边也变成字符串的形式
    37.     q = Q()
    38.     # q.connector = ’or‘ 修改默认关系变成or
    39.     q.children.append(('maichu__gt',800))
    40.     q.children.append(('price__lt',900))
    41.     res = models.Book.objects.filter(q) # 默认是and关系
    42.     print(res)

    django中如何开启事物

    1. '''
    2. 事物
    3. ACID
    4. 原子性：不可分割的最小单位
    5. 一致性：跟原子性相辅相成
    6. 隔离性：事物之间互相不干扰
    7. 持久性：事物一旦确定永久生效
    9. 事物的回滚  rollback
    10. 事物的确认 commit
    11. # 目前你只需要简单的开启事物
    12. from django.db import transaction
    13. transaction.atomic():
    14. sql语句
    15. 在with代码块内书写的所有orm操作都属于同一个事物

    orm中常用字段及参数

    1. AutoFiled int自增列 必须填入参数 primary_key=True。当model中没有自增列，则自动会创建一个列名为id的列
    2.  
    3. InterField   int
    4. BigInterField  bigint
    5.  
    6. CharField 字符类型varchar  必须提供max_length参数，表示长度
    7.  
    8. DateField 日期字段
    9. DateTimeField 日期时间字段 
    10. 参数：auto_now每次修改数据的时候都会更新时间
    11. auto_now_add 只在创建数据的时候记录创建时间后续不会自动修改
    12.  
    13. BooleanField(Field) 布尔值类型
    14. 该字段传布尔值（False/True） 数据库里面存1或0
    15.  
    16. TextField(Field)  文本类型
    17. 该字段可以用来存大段文本内容 没有字数限制
    18.  
    19. FileField(Field) 字符类型
    20. upload_to = '/data'
    21. 给该字段传一个文件对象，会自动将文件保存到/data目录下然后将文件路径保存到数据库中
    22. /data/a.txt
    23.  
    24. #django除了给你提供很多字段类型之外 还支持你自定义字段类型
    25.  
    26.  
    27. # 字段参数
    28. null 用于表示某个字段可以为空
    29.  
    30. unique 如果设置unique=True 表示该字段再此表中是唯一的
    31.  
    32. db_index 如果db_index=True 则代表着为此字段设置索引
    33.  
    34. default 为该字段设置默认值
    35.  
    36. # 关系字段
    37. ForeignKey
    38. 外键类型在ORM中用来表示外键关联关系，一般把ForeignKey字段设置在 '一对多'中'多'的一方。
    39.  
    40. ForeignKey可以和其他表做关联关系同时也可以和自身做关联关系。
    41. 字段参数
    42. to 设置要关联的表
    43. to_field 设置要关联表的字段
    44. on_delete 当删除关联表中的数据时
    45. db_constrains 是否在数据库中创建外键的约束，默认为True
    46. class MyModel(models.Model):
    47.     user = models.ForeignKey(
    48.         to="User",
    49.         to_field="id"，
    50.         on_delete=models.SET(func)
    51.     )
    52.  
    53. OneToOneFiled
    54. 一对一字段。
    55.  
    56. 通常一对一字段用来扩展已有字段。(通俗的说就是一个人的所有信息不是放在一张表里面的，简单的信息一张表，隐私的信息另一张表，之间通过一对一外键关联)
    57.  
    58.  
    59.

    数据库查询优化

    1. only 与 defer
    2. select_related与prefetch_related
    3. '''
    4. orm语句的特点
    5. 惰性查询
    6. 如果你仅仅只书写了orm语句 在后面根本没有用到该语句查询出来的参数 那么orm会自动识别 不执行
    7. '''
    8. # 想要获取书籍表中所有书的名字
    9.     # res = models.Book.objects.values('title')
    10.     # for d in res:
    11.     #     print(d.get('title'))
    12.     # 你给我实现获取到的是一个数据对象，然后点title就能拿到书名 并且没有其他字段
    13.     # res = models.Book.objects.only('title')
    14.     # print(res)
    15.     # for i in res:
    16.     #     print(i.title) # 点击only括号内的字段不会走数据库
    17.         # print(i.price) # 点击only括号外的字段会重新走数据库查询
    18.  
    19.     # res = models.Book.objects.defer('title') #对象除了没有title属性其他都有
    20.     # print(res)
    21.     # for i in res:
    22.     #     print(i.title) # 点击defer括号内的字段重新走数据库查询
    23.         # print(i.price) # 点击defer括号外的字段不会走数据库
    24.     '''
    25.     defer与only刚好相反
    26.     defer括号内放的字段不在查询出来的对象里面 查询该字段需要重新走数据库
    27.     而如果查询非括号内的字段不需要走数据库
    28.     '''
    29.     # res = models.Book.objects.all() # 每循环一次就要走一次数据库查询
    30.     # for i in res:
    31.     #     print(i.publish.name)
    32.     # res = models.Book.objects.select_related('publish')
    33.     '''
    34.     select_related内部现将book与publish连起来 然后将大表里面的所有数据对象全部封装给查询出来的对象
    35.     这个时候对象无论是点击book表中的数据还是publish表中的数据都无需再走数据库查询 网络请求越少延迟越低 也就是优化数据库查询
    36.     select_related括号内只能放外键字段 一对一 一对多 多对多也不行
    37.     '''
    38.     # print(res)
    39.     # for i in res:
    40.     #     print(i.publish.name)
    41.     res = models.Book.objects.prefetch_related('publish')
    42.     for i in res:
    43.         print(i.publish.name)
    44.     '''
    45.     prefetch_related该方法内部就是子查询
    46.     将子查询出来的所有结果也给你封装到对象中
    47.     给你的感觉也好像是一次性搞定
    48.     '''

  • 相关阅读:
    【什么是区块链】
    荷兰国旗问题到快排的实现
    《UnityShader入门精要》学习2
    Jsoup解析XML文件
    2023秋招，Java岗最全面试攻略，吃透25个技术栈Offer拿到手软！
    【网络通信】探索UDP与TCP协议、IP地址和端口号的奥妙
    算法通过村第十一关-位运算|白银笔记|高频题目
    数据结构栈和队列
    如何实现FinClip微信授权登录的三种方案
    vant实现Select效果--单选和多选
  • 原文地址：https://blog.csdn.net/m0_59882269/article/details/126153294