Django学习day07随堂笔记

今日考题

"""
今日考题
1.必知必会N条都有哪些，每个都是干啥使的
2.简述神奇的双下划线查询都有哪些方法，作用是什么
3.针对多对多外键字段的增删改查方法有哪些，各有什么特点？
4.什么是正反向的概念，及查询口诀，你能否总结一下正反向查询不同情况下点击不同字段的规律
"""

上周内容回顾

• 单表的增删改查

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

• 测试环境准备

  # 你如果只想测试django某一个py文件(大部分情况下就是models.py)
  
  # 在应用下的tests.py或者自己新建一个任意名称py文件(tests.py)
  """
  1.去manage.py拷贝前四行 （现在有变动 仔细看上一个文档）
  
  2.自己书写两行
  	import django
  	django.setup()
  """
  

• 如何查看orm内部的sql语句

  # 1.queryset对象可以直接点query查看
  	queryset对象.query
  
  # 2.配置文件配置日志相关代码即可(不要记 直接拷贝使用即可)
  	参考笔记或者博客自己保存好
  

• 必知必会N多条

  # 1.all()
  
  # 2.filter()
  	我们在利用数据的主键字段筛选数据的时候，可以不考虑主键字段叫什么，直接使用pk代替
  
  # 3.get()
  
  # 4.values()
  	获取指定字段对应的数据 返回的结果是一个queryset对象(列表套字典的形式)
  
  # 5.values_list()
  	获取指定字段对应的数据 返回的结果是一个queryset对象(列表套元祖的形式)
  
  # 6.count()
  	统计查询出来的数据个数
  
  # 7.first()
  
  # 8.last()
  
  # 9.order_by()
  	默认是升序，你可以在字段前面加一个负改为降序
  
  # 10.reverse()
  	前面必须是已经排序过了 才能生效
  
  # 11.exclude()
  	排除...在外
  
  # 12.distinct()
  	去重(主键一定不要忘了)
  
  # 13.exists()
  	判断数据集是否有值 返回布尔值
  

• 神奇的双下划线查询

  # 价格大于 小于 大于等于 小于等于
  price__gt
  price__lt
  price__gte
  price__lte
  
  # 成员查询
  price__in
  
  # 范围查询
  price__range
  
  # 模糊查询
  title__contains		默认是区分大小写的
  title__icontains	忽略大小写
  
  # 只按照年份或者月份或者...
  create_time__year
  craete_time__month
  

• 外键字段的增删改查

  # 一对多
  publish_id = 1
  punlish = publish_obj
  
  # 多对多
  add
  remove
  	上述两个方法括号内即可以传数字也可以传对象并且都支持多个
  set
  	括号内必须传一个可迭代对象 可迭代对象里面的元素可以数字也可以对象并且都支持多个
  clear
  	括号内无需给任何参数，直接清空对应的关系数据
  

• 多表查询

  # 正反向的概念
  	正向
    	外键字段就在我手中
    反向
    	外键字段不再我手中
  # 小口诀
  	正向查询按外键字段
    反向查询按表名小写
    								_set
      							.all()
  # 温馨提示
  	书写orm语句跟书写sql语句一样，不要试图一次性写完，可以分步书写
  
  """
  多表操作
  	1.子查询
  
  	2.联表操作
  		inner join
  		left join
  		right join
  		union
  
  Django orm中
  	1.基于对象的跨表查询
  		子查询
  			1.先拿到一个数据对象
  			2.对象点点点 
  
  	2.基于双下划线的跨表查询
  		联表操作
  """
  1.基于对象的跨表查询
  	book_obj.publish
    book_obj.authors.all()
    author_obj.author_detail
  
    publish_obj.book_set  # App01.Book.None
    publish_obj.book_set.all()
    author_obj.book_set.all()
    author_detail.author
  
  2.基于双下划线的跨表查询
  	models.Book.objects.filter(pk=1).values('title','publish__name')
    models.Publish.objects.filter(book__id=1).values('book__title','name')
  
    # 利用双下划线的跨表查询可以帮助你跨N多张表，只要有外键字段
    models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
  
  # 图书管理系统 图书的增删改查
  

今日内容概要

• 聚合查询(聚合函数的使用)aggregate

  max、min、sum、count、avg

• 分组查询(group by的使用)annotate

• F与Q查询

• django中如何开启事务

• orm中常用字段及参数

• 数据库查询优化(only与defer、select_related与prefetch_related)

• 图书管理系统作业讲解

今日内容详细

聚合查询

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

分组查询

     # 分组查询  annotate
    """
    MySQL分组查询都有哪些特点
        分组之后默认只能获取到分组的依据 组内其他字段都无法直接获取了
            严格模式
                ONLY_FULL_GROUP_BY
    """
    from django.db.models import Max, Min, Sum, Count, Avg
    # 1.统计每一本书的作者个数 (按书分组)  书查作者 正向查询按字段
    # res = models.Book.objects.annotate()  # models后面点什么 就是按什么分组
    #res = models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
    #author_num取别名，存放作者个数  Count计数  跨到作者表中(正向查询按字段)
    #print(res)

    # 2.统计每个出版社卖的最便宜的书的价格(作业:复习原生SQL语句 写出来)出版社查书(反向查询表名小写)
    #res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
    # name是出版社的名字
    #print(res)

    # 3.统计不止一个作者的图书
    # 1.先按照图书分组 求每一本书对应的作者个数
    # 2.过滤出不止一个作者的图书
    # res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title','author_num')
    # """
    # 只要你的orm语句得出的结果还是一个queryset对象
    # 那么它就可以继续无限制的点queryset对象封装的方法
    #
    # """
    # print(res)

    # 4.查询每个作者出的书的总价格
    # 先按每个作者分组  作者查书 反向表名小写
    # res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
    # name是作者的姓名
    # print(res)

    """
        如果我想按照指定的字段分组该如何处理呢？
            models.Book.objects.values('price').annotate() 这个就是按照书籍里面的价格来分组
        后续BBS作业会使用

        你们的机器上如果出现分组查询报错的情况
            你需要修改数据库严格模式
    """
    """

F与Q查询

# F查询
    # 1.查询卖出数大于库存数的书籍
    # F查询
    """
    能够帮助你直接获取到表中某个字段对应的数据
    """
    from django.db.models import F
    # res = models.Book.objects.filter(maichu__gt=F('kucun'))
    # print(res)

    # 2.将所有书籍的价格提升500块
    #models.Book.objects.update(price=F('price') + 500)

    # 3.将所有书的名称后面加上爆款两个字
    """
    在操作字符类型的数据的时候 F不能够直接做到字符串的拼接
    需要导入两个模块 Concat  Value
    """
    from django.db.models.functions import Concat
    from django.db.models import Value

    models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
    # models.Book.objects.update(title=F('title') + '爆款')  # 所有的名称会全部变成空白

# Q查询
    # 1.查询卖出数大于100或者价格小于600的书籍
    # res = models.Book.objects.filter(maichu__gt=100,price__lt=600)
    """filter括号内多个参数是and关系  所以上面打印出来是null"""
    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关系 卖出数小于等于100或价格小于600的书籍
    # print(res)

    # Q的高阶用法  能够将查询条件的左边也变成字符串的形式  也就是前端页面中的搜索功能
    q = Q()  #先用q产生一个空对象
    q.connector = 'or' #设置or关系 不设置默认还是and关系
    q.children.append(('maichu__gt', 100))
    q.children.append(('price__lt', 600))
    res = models.Book.objects.filter(q)
    print(res)

django中如何开启事务

"""
事务
	ACID
		原子性
			不可分割的最小单位
		一致性
			跟原子性是相辅相成
		隔离性
			事务之间互相不干扰
		持久性
			事务一旦确认永久生效

	事务的回滚
		rollback
	事务的确认
		commit
"""
# 目前你只需要掌握Django中如何简单的开启事务
# 事务
    from django.db import transaction
    try:
        with transaction.atomic():
            # sql1
            # sql2
            ...
            # 在with代码快内书写的所有orm操作都是属于同一个事务
    except Exception as e:
        print(e)
    print('执行其他操作')

orm中常用字段及参数

AutoField
	主键字段 primary_key=True

CharField				varchar
	verbose_name	字段的注释
  max_length		长度

IntegerField			int
BigIntegerField		bigint

DecimalField
	max_digits=8
  decimal_places=2

EmailFiled				varchar(254)

DateField					date
DateTimeField			datetime
	auto_now:每次修改数据的时候都会自动更新当前时间
  auto_now_add:只在创建数据的时候记录创建时间后续不会自动修改了

BooleanField(Field)				- 布尔值类型
	该字段传布尔值(False/True) 	数据库里面存0/1

TextField(Field)					- 文本类型
	该字段可以用来存大段内容(文章、博客...)  没有字数限制
  后面的bbs作业 文章字段用的就是TextField

FileField(Field)					- 字符类型
   upload_to = "/data"
  给该字段传一个文件对象，会自动将文件保存到/data目录下然后将文件路径保存到数据库中
  /data/a.txt
  后面bbs作业也会涉及

# 更多字段
直接参考博客:https://www.cnblogs.com/Dominic-Ji/p/9203990.html

# django除了给你提供了很多字段类型之外 还支持你自定义字段
class MyCharField(models.Field):
    def __init__(self,max_length,*args,**kwargs):
        self.max_length = max_length
        # 调用父类的init方法
        super().__init__(max_length=max_length,*args,**kwargs)  # 一定要是关键字的形式传入

    def db_type(self, connection):
        """
        返回真正的数据类型及各种约束条件
        :param connection:
        :return:
        """
        return 'char(%s)'%self.max_length

# 自定义字段使用
myfield = MyCharField(max_length=16,null=True)

# 外键字段及参数
unique=True 如果设置为unique=True则该字段在此表中必须是唯一的
	ForeignKey(unique=True)   ===			OneToOneField()
  # 你在用前面字段创建一对一 orm会有一个提示信息 orm推荐你使用后者但是前者也能用

db_index
	如果db_index=True 则代表着为此字段设置索引
  (复习索引是什么)

to_field
	设置要关联的表的字段  默认不写关联的就是另外一张的主键字段

on_delete
	当删除关联表中的数据时，当前表与其关联的行的行为。
  """
  django2.X及以上版本 需要你自己指定外键字段的级联更新级联删除
  """

数据库查询优化

#数据库查询优化
    # only与defer
    # res = models.Book.objects.all()
    # print(res)  # 要用数据了才会走数据库

    # 想要获取书籍表中所有数的名字
    #res = models.Book.objects.values('title')
    #for d in res:
        #    print(d)
        # {'title': '西游记爆款'}
        # {'title': '水浒传爆款'}
        # {'title': '红楼梦爆款'}

        #    print(d.get('title'))
        #   西游记爆款
        #   水浒传爆款
        #   红楼梦爆款

    # 你给我实现获取到的是一个数据对象 然后点title就能够拿到书名 并且没有其他字段
    #res = models.Book.objects.only('title')
    #res1 = models.Book.objects.all()
    #print(res)  # <QuerySet [<Book: 西游记爆款>, <Book: 水浒传爆款>, <Book: 红楼梦爆款>]>
    #print(res1) # <QuerySet [<Book: 西游记爆款>, <Book: 水浒传爆款>, <Book: 红楼梦爆款>]>
    #for i in res:
        #print(i.title)  # only括号内的字段 不会走数据库
        #print(i.price)  # only括号内没有的字段 会重新走数据库查询而all不需要走了

    # res = models.Book.objects.defer('title')  # 对象除了没有title属性之外其他的都有
    # for i in res:
    #     print(i.price)
    """
    defer与only刚好相反
        defer括号内放的字段不在查询出来的对象里面 查询该字段需要重新走数据库
        而如果查询的是非括号内的字段 则不需要走数据库了
    """

    # select_related与prefetch_related  跟跨表操作有关
    #拿到每一本书的出版社名称
    # res = models.Book.objects.all()
    # for i in res:
    #     print(i.publish.name)  # 每循环一次就要走一次数据库查询

    # res = models.Book.objects.select_related('publish')  # INNER JOIN 拼表
    # print(res)
    # for i in res:
    #    print(i.publish.name)  #走的数据库请求少了
    """
    select_related内部直接先将book与publish连起来 然后一次性将大表里面的所有数据
    全部封装给查询出来的对象
        这个时候对象无论是点击book表的数据还是publish的数据都无需再走数据库查询了

    select_related括号内只能放外键字段    一对多 一对一
        多对多也不行
    """

    res = models.Book.objects.prefetch_related('publish')  # 子查询
    # for i in res:
    #     print(i.publish.name)  # 每循环一次就要走一次数据库查询
    """
    prefetch_related该方法内部其实就是子查询
        将子查询查询出来的所有结果也给你封装到对象中
        给你的感觉好像也是一次性搞定的
    """
    for i in res:
        print(i.publish.name)

图书管理系统

作业

"""
1.整理今日内容到博客
2.熟练掌握数据库常用字段及参数以及应用场景
3.总结数据库查询优化的两组方法，尝试用自己的语言表述
4.完成图书管理系统
	书籍表的增删改查(尽量将之前的知识点全部融入进去)
"""