Django学习day06随堂笔记

模型层(ORM语法):跟数据库打交道的 {单表查询(增删改查)，常见的十几种查询方法，神奇的双下划线查询，多表操作，外键字段的增删改查，跨表查询(子查询，联表查询)}

每日测验

"""
今日考题
1.什么是FBV与CBV，能不能试着解释一下CBV的运作原理
2.模版语法的传值需要注意什么，常见过滤器及标签有哪些
3.自定义过滤器，标签，inclusion_tag的流程
4.什么是模版的继承与导入，如何正确使用
"""

昨日内容回顾

• CBV源码

  # 能够根据请求方式的不同自动匹配触发对应的方法的执行(只要是视图函数都应该有一个形参request)
  
  # url			FBV与CBV在路由匹配上本质是一样的都是路由对应函数内存地址
  url(r'^index/',views.index)
  url(r'^login/',views.MyClass.as_view())
  # url(r'^login/',views.view)
  
  # 源码
  MyClass.as_view()
  
  @classonlymethod
  def as_view(cls,**initkwargs):
    def view(*args,**kwargs):
      self = cls(*args,**kwargs)
      ...
      return self.dispatch(*args,**kwargs)
    	"""
    	你在后面看python源码的时候 只要看到self点东西 
    	你一定要问你自己一些当前这个self到底是谁？？？
    		属性方法查找顺序
    			对象本身找
    			产生对象的类中
    			类的父类们
    	"""
    return view
  
  def dispatch(*args,**kwargs):
    if request.method.lower() in ['get','post',...]:
      	handler = getattr(self,request.method.lower(),'报错信息')
    else:
      	handler = '报错提示方法'
    return handler(request,*args,**kwargs)
  

• 模版语法的传值

  变量相关:{{}}

  逻辑相关:{%%}

  # 你要知道render支持两种给html文件传值的方式
  
  # python所有的基本数据类型 函数名 类名 对象都可以被传到html上
  # 针对函数名和类名 模版语法会自动加括号调用(但是不支持传递额外的参数)
  
  # 模版语法如何获取容器类型里面的数据  统一采用句点符 .
  .key
  .index
  .key.index.index.key
  

• 过滤器

  # 语法结构  最多只能有两个参数 
  {{ data|过滤器:'参数'}}
  
  |length
  |default
  |filesizeformat
  |date:'Y-m-d'
  |slice:'0:6:2'
  |truncatechars(包含三个点)
  |truncatewords(不包含三个点 按空格切)
  |add
  |cut
  |join
  |safe
  
  转义
  	# 前端
    	|safe
    # 后端
    	from django.utils.safestring import mark_safe
      res = mark_safe('<h1>baby</h1>')
  """
  前端代码不一定非要在html页面上书写，也可以在后端生成然后传递给html页面!!!
  """
  

• 标签

  # for循环
  {% for i in l %}
  	{{ forloop }}
    {% empty %}
    		可迭代对象里面没有元素 没法for循环的时候自动走empty
  {% endfor %}
  	counter
  	counter0
  	first
  	last
  
  # if判断
  {% if user %}
  	
  {% elif age %}
  	
  {% else %}
  
  {% endif %}
  
  # with起别名
  {% with data.0.name.1.password.2.heiheihei as t%}
  	{{ t }}
  {%endwith%}
  
  # 模版语法也支持对字典获取键 值 键值对操作
  .keys
  .values
  .items
  

• 自定义过滤器、标签、inclusion_tag

  """
  1.在对应的应用下创建一个名字必须叫templatetags文件夹
  2.该文件夹内创建一个任意名称的py文件	mytag.py
  3.在该py文件内需要先书写两句固定的代码
  	from django import template
  	register = template.Library()
  """
  # 自定义过滤器
  @register.filter(name='过滤器的名字')
  def index(v1,v2):
    return v1 + v2
  
  # 自定义标签
  @register.simple_tag(name='标签的名字')
  def func(*args):
    pass
  
  # 自定义inclusion_tag
  @register.inclusion_tag('html文件名')
  def bar(n):
    return locals()  # 传数据方式1
  	return {}	# 传数据方式2
  
  # 如何使用上述三者
  {% load mytag %}
  {{ data|过滤器的名字:'参数' }}
  {% 标签的名字 参数1 参数2 参数3 参数4%}
  {% bar %}
  

• 模版的继承

  """
  同一个html页面 想重复的使用大部分样式 只是局部修改
  """
  # 继承
  {% extends '模版页面名' %}
  
  # 局部修改
  	# 1.你需要先去模版页面中划定可以被修改的区域
    	{% block '名字' %}
      	模版内容（666）
      {% endblock %}
    # 2.子页面中即成了模版页面之后 就可以根据名字修改
    	{% block '名字' %}
      	子版内容
        
        子版页面吃了可以自己写自己的之外 还可以继续使用模版的内容
        {{ block.super }}  666
        {{ block.super }}  666
        {{ block.super }}  666
        {{ block.super }}  666
      {% endblock %}
  # 规律:一般情况下模版页面内至少应该有三块区域
  	css
    html
    js
    所有的子页面中 都可以有自己独立的css html 和js
  
  # 利用模版的继承 能够让你的页面更加的好维护
  

• 模版的导入

  {% include '模版文件名' %}
  

今日内容概要(重要)

模型层(ORM语法):跟数据库打交道的

• 单表查询(增删改查)
• 常见的十几种查询方法
• 神奇的双下划线查询
• 多表操作
• 外键字段的增删改查
• 跨表查询(重点)
  • 子查询
  • 联表查询

今日内容详细

单表操作

# django自带的sqlite3数据库对日期格式不是很敏感 处理的时候容易出错
# 增
    # res = models.User.objects.create(name='jason',age=18,register_time='2002-1-21')
    # print(res)
    # import datetime
    # ctime = datetime.datetime.now()
    # user_obj = models.User(name='egon',age=84,register_time=ctime)
    # user_obj.save()

    # 删
    # res = models.User.objects.filter(pk=2).delete()
    # print(res)
    """
    pk会自动查找到当前表的主键字段 指代的就是当前表的主键字段
    用了pk之后 你就不需要指代当前表的主键字段到底叫什么了
        uid
        pid
        sid
        ...
    """
    # user_obj = models.User.objects.filter(pk=1).first()
    # user_obj.delete()

    # 修改
    # models.User.objects.filter(pk=4).update(name='egonDSB')

    # user_obj = models.User.objects.get(pk=4)
    # user_obj = models.User.objects.filter(pk=6)
    """
    get方法返回的直接就是当前数据对象
    但是该方法不推荐使用
        一旦数据不存在该方法会直接报错
        而filter则不会
            所以我们还是用filter
    filter需要结合first() 一起使用                  
    """
    # user_obj.name = 'egonPPP'
    # user_obj.save()

必知必会13条

# 必知必会13条
    # 1.all()  查询所有数据

    # 2.filter()     带有过滤条件的查询
    # 3.get()        直接拿数据对象 但是条件不存在直接报错
    # 4.first()      拿queryset里面第一个元素
    # res = models.User.objects.all().first()
    # print(res)
    # 5.last()
    # res = models.User.objects.all().last()
    # print(res)

    # 6.values()  可以指定获取的数据字段  select name,age from ...     列表套字典
    # res = models.User.objects.values('name','age')  # <QuerySet [{'name': 'jason', 'age': 18}, {'name': 'egonPPP', 'age': 84}]>
    # print(res)
    # 7.values_list()  列表套元祖
    # res = models.User.objects.values_list('name','age')  # <QuerySet [('jason', 18), ('egonPPP', 84)]>
    # print(res)
    # """
    #  print(res.query)  查看内部封装的sql语句
    #  上述查看sql语句的方式  只能用于queryset对象
    #  只有queryset对象才能够点击query查看内部的sql语句
    #
    # """
    # 8.distinct()  去重
    # res = models.User.objects.values('name','age').distinct()
    # print(res)
    """
    去重一定要是一模一样的数据
    如果带有主键那么肯定不一样 你在往后的查询中一定不要忽略主键
    
    """
    # 9.order_by()
    # res = models.User.objects.order_by('age')  # 默认升序
    # res = models.User.objects.order_by('-age')  # 降序
    #
    # print(res)
    # 10.reverse()  反转的前提是 数据已经排过序了  order_by()
    # res = models.User.objects.all()
    # res1 = models.User.objects.order_by('age').reverse()
    # print(res,res1)

    # 11.count()  统计当前数据的个数
    # res = models.User.objects.count()
    # print(res)
    # 12.exclude()  排除在外
    # res = models.User.objects.exclude(name='jason')
    # print(res)

    # 13.exists()  基本用不到因为数据本身就自带布尔值  返回的是布尔值
    # res = models.User.objects.filter(pk=10).exists()
    # print(res)

测试脚本

"""
当你只是想测试django中的某一个py文件内容 那么你可以不用书写前后端交互的形式
而是直接写一个测试脚本即可

脚本代码无论是写在应用下的tests.py还是自己单独开设py文件都可以
"""
# 测试环境的准备 去manage.py中拷贝前四行代码(注意现在第三行已经变了，以下面的为准) 然后自己写两行
import os
import sys

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings")
    import django
    django.setup()
    # 在这个代码块的下面就可以测试django里面的单个py文件了

查看内部sql语句的方式

# 方式1
res = models.User.objects.values_list('name','age')  # <QuerySet [('jason', 18), ('egonPPP', 84)]>
print(res.query)
queryset对象才能够点击query查看内部的sql语句

# 方式2:所有的sql语句都能查看
# 去配置文件中配置一下即可
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

神奇的双下划线查询

# 神奇的双下划线查询
    # 1 年龄大于33岁的数据
    #res = models.User.objects.filter(age__gt=33) #gt = greater than 大于
    #print(res)

    # 2 年龄小于35岁的数据
    # res = models.User.objects.filter(age__lt=35)
    # print(res)

    # 大于等于 小于等于
    # res = models.User.objects.filter(age__gte=32)
    # print(res)
    # res = models.User.objects.filter(age__lte=32)
    # print(res)

    # 年龄是18 或者 32 或者40
    # res = models.User.objects.filter(age__in=[18,32,40])
    # print(res)

    # 年龄在18到40岁之间的  首尾都要
    # res = models.User.objects.filter(age__range=[18,40])
    # print(res)

    # 查询出名字里面含有k的数据  模糊查询
    # res = models.User.objects.filter(name__contains='k')
    # print(res)

    # 是否区分大小写  查询出名字里面含有p的数据  区分大小写
    # res = models.User.objects.filter(name__contains='p')
    # print(res)
    # 忽略大小写
    # res = models.User.objects.filter(name__icontains='p')
    # print(res)

    #查询以k开头的数据
    # res = models.User.objects.filter(name__startswith='k')
    # 查询以k结尾的数据
    # res = models.User.objects.filter(name__endswith='k')

    # 查询出注册时间为 1999 2月 22日 的数据
    # res = models.User.objects.filter(register_time__year='1999',
    #                                  register_time__month='2',
    #                                  register_time__day='23')
    # print(res)

一对多外键增删改查

# 一对多外键增删改查
    # 增
    # 方法1  直接写实际字段 id
    #models.Book.objects.create(title='论语',price=899.23,publish_id=1)
    # models.Book.objects.create(title='聊斋',price=444.23,publish_id=2)
    # models.Book.objects.create(title='老子',price=333.66,publish_id=1)

    # 方法2  虚拟字段 对象
    # publish_obj = models.Publish.objects.filter(pk=2).first()
    # models.Book.objects.create(title='红楼梦',price=666.23,publish=publish_obj)

    #删
    """
        删除的规则主要还是跟model中定义的on_delete的属性有关
        on_delete=None,               删除关联表中的数据时,当前表与其关联的field的行为
        on_delete=models.CASCADE,     删除关联数据,与之关联也删除
        on_delete=models.DO_NOTHING,  删除关联数据,什么也不做
    """
    #models.Publish.objects.filter(pk=1).delete()
    # 因为前面设置的是on_delete=models.CASCADE 所以此处为级联删除

    #修改
    #方式一
    #models.Book.objects.filter(pk=1).update(title='西游记')
    #方式二
    #book_obj = models.Book.objects.filter(pk=1).first()
    #models.Book.objects.create(title='红楼梦', price=666.23, publish=book_obj)

多对多外键增删改查

#多对多外键增删改查  就是在操作第三张表
    # 如何给书籍添加作者？ 方法一
    #book_obj = models.Book.objects.filter(pk=1).first()#先拿到一个书籍id为1的对象
    #print(book_obj.authors)#这时候就类似于你已经拿到了第三张关系表了
    #book_obj.authors.add(1)# 书籍id为1的书绑定一个主键为1的作者

    #因为书和作者之间的关系是多对多 所以可能存在一本书多个作者 或一个作者多本书
    #book_obj.authors.add(2,3)# 书籍id为1的书绑定一个主键为1和主键为2的两个作者

    #方法二
    # book_obj = models.Book.objects.filter(pk=2).first()  # 先拿到一个书籍id为2的对象
    # author_obj1 = models.Author.objects.filter(pk=2).first() #作者主键id为2的对象
    # author_obj2 = models.Author.objects.filter(pk=3).first()#作者主键id为3的对象
    #book_obj.authors.add(author_obj1,author_obj2)
    """
        add给第三张关系表添加数据
            括号内既可以传数字也可以传对象 并且都支持多个
    """

    #删 方法一
    #book_obj = models.Book.objects.filter(pk=1).first()  # 先拿到一个书籍id为1的对象
    #book_obj.authors.remove(2) #删除id为1的书籍的 id为2的作者  (支持传多个)
    #book_obj.authors.remove(1,3)  # 删除id为1的书籍的 id为2和id为3的作者
    #方法二
    # book_obj = models.Book.objects.filter(pk=2).first()  # 先拿到一个书籍id为2的对象
    # author_obj1 = models.Author.objects.filter(pk=2).first() #作者主键id为2的对象
    # author_obj2 = models.Author.objects.filter(pk=3).first()#作者主键id为3的对象
    # book_obj.authors.remove(author_obj1, author_obj2)  # 删除id为2的书籍的 id为2和id为3的作者
    """
        remove
            括号内既可以传数字也可以传对象 并且都支持多个
    """

    #修改 方法一
    #book_obj = models.Book.objects.filter(pk=1).first()  # 先拿到一个书籍id为1的对象
    #book_obj.authors.set([1,2]) # 将书籍id为1的书的作者更给为id为1和id为2的新作者
    #book_obj.authors.set([2])  # 将书籍id为1的书的作者更给为id为2的新作者
    #方法二
    # book_obj = models.Book.objects.filter(pk=2).first()  # 先拿到一个书籍id为2的对象
    # author_obj1 = models.Author.objects.filter(pk=2).first() #作者主键id为2的对象
    # author_obj2 = models.Author.objects.filter(pk=3).first()#作者主键id为3的对象
    # book_obj.authors.set([author_obj1, author_obj2]) # 将书籍id为2的书的作者更给为id为2和id为3的新作者
    """
       set
           括号内必须传一个可迭代对象[ ]，该对象内既可以数字也可以对象 并且都支持多个
    """

    # 清空
    # 在第三张关系表中清空某个书籍与作者的绑定关系
    book_obj = models.Book.objects.filter(pk=2).first()  # 先拿到一个书籍id为2的对象
    book_obj.authors.clear() #清空书籍id为2的书与所有作者的绑定关系
    """
    clear
        括号内不要加任何参数

    """

正反向的概念

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

多表查询

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

 #基于对象的跨表查询
    # 1.查询书籍主键为1的出版社
    # book_obj = models.Book.objects.filter(pk=1).first() # 先拿到一个书籍id为1的对象
    # # 书查出版社 正向
    # res = book_obj.publish #正向查询按字段  查询书籍id为1的书的出版社信息
    # print(res)  #对象:北方出版社 这里返回是因为在model.py中定义了class Publish的def __str__(self):的返回值
    # print(res.name) #北方出版社
    # print(res.addr) #北方

    #2.查询书籍主键为1的作者
    # book_obj = models.Book.objects.filter(pk=1).first() # 先拿到一个书籍id为1的对象
    # # 书查作者 正向查询按字段
    # # res = book_obj.authors  # app01.Author.None
    # res = book_obj.authors.all()  # <QuerySet [<Author: Author object (1)>, <Author: Author object (2)>]>
    # print(res)

    # 3.查询作者pdd的电话号码
    # author_obj = models.Author.objects.filter(name='pdd').first()# 先拿到一个作者name为pdd的对象
    # 作者查作者信息  正向查询按字段
    # res = author_obj.author_detail
    # print(res)
    # print(res.phone)
    # print(res.addr)

    """
        在书写orm语句的时候跟写sql语句一样的
        不要企图一次性将orm语句写完 如果比较复杂 就写一点看一点

        正向什么时候需要加.all()
            当你的结果可能有多个的时候就需要加.all()
            如果是一个则直接拿到数据对象
                book_obj.publish
                book_obj.authors.all()
                author_obj.author_detail
    """

    # 4.查询出版社是东方出版社出版的书
    # publish_obj = models.Publish.objects.filter(name='北方出版社').first()# 先拿到一个出版社name为北方出版社的对象
    # #出版社查书  反向查询按表名小写_set
    # res = publish_obj.book_set  # app01.Book.None
    # res = publish_obj.book_set.all()
    # print(res)

    # 5.查询作者是pdd写过的书
    # author_obj = models.Author.objects.filter(name='pdd').first()#先拿到作者对象
    # 作者查书      反向查询按表名小写_set
    # res = author_obj.book_set  # app01.Book.None
    # res = author_obj.book_set.all()
    # print(res)

    # 6.查询手机号是110的作者姓名
    # author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()#先拿到作者信息对象
    # 反向查询按表名小写
    # res = author_detail_obj.author
    # print(res.name)
    """
        基于对象 
            反向查询的时候
                当你的查询结果可以有多个的时候 就必须加_set.all()
                当你的结果只有一个的时候 不需要加_set.all()
            自己总结出 自己方便记忆的即可 每个人都可以不一样
    """

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

 # 基于双下划线的跨表查询
    # 1.查询pdd的手机号和作者姓名
    # 作者查手机号 正向查询按字段
    #res = models.Author.objects.filter(name='pdd').values('author_detail__phone','name')
    #print(res)
    # 反向 反向表名小写
    #res = models.AuthorDetail.objects.filter(author__name='pdd')  # 拿作者姓名是pdd的作者详情
    #作者信息查作者手机号和名字 手机号自己表里面有 作者名字需要进入到author中拿
    #res = models.AuthorDetail.objects.filter(author__name='pdd').values('phone','author__name') #表名小写__name
    #print(res)

    # 2.查询书籍主键为1的出版社名称和书的名称
    #书查出版社 正向 查询按字段
    # res = models.Book.objects.filter(pk=1).values('title','publish__name')
    # print(res)
    # 反向  出版社查书 反向表名小写 出版社名称自己有，书的名字在book表中
    # res = models.Publish.objects.filter(book__id=1).values('name','book__title')
    # print(res)

    # 3.查询书籍主键为1的作者姓名
    #书籍查作者 正向 查询按字段
    # res = models.Book.objects.filter(pk=1).values('authors__name')
    # print(res)
    # 反向 作者查书 反向表名小写
    # res = models.Author.objects.filter(book__id=1).values('name')
    # print(res)

    # 查询书籍主键是1的作者的手机号
    # book author authordetail 三张表
    #书跟作者详情没有关系 但是跟作者有关系  先去作者表然后再去表中的外键作者详情表然后就拿到手机号了
    #authors： authors是book表中的字段 通过它进入到作者表
    #author_detail： 是作者表中的字段  通过它进入到作者详情表
    #然后去phone值
    # res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
    # print(res)

    """
        你只要掌握了正反向的概念
        以及双下划线
        那么你就可以无限制的跨表
    """
    
    """

周末作业

"""
今日作业
必做题
1.整理今日内容 用自己的话术整理到博客中(切勿直接复制粘贴)
独立完成以下任务
2.自己手动创建图书管理系统表及数据录入  
3.独立完成单表查询N条方法，双下划线方法
4.将课上orm题目摘出来，自己完成orm语句书写，体会orm简便之处
选做题
1.图书管理系统		图书表的增删改查
	（只需要完成图书表的就可以）
"""