Django框架05

lucky-cat233

昨日内容回顾

  • 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到底是谁？？？

    
        属性方法查找顺序:
            1.对象本身找
            2.产生对象的类中
            3.类的父类们
        """
  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语法):跟数据库打交道的


    

  • 

    单表查询(增删改查)
    

    • 

  • 

    常见的十几种查询方法
    

    • 

  • 

    神奇的双下划线查询
    

    • 

  • 

    多表操作
    

    • 

  • 

    外键字段的增删改查
    

    • 

  • 

    跨表查询(重点)
    

      

    • 

      子查询
      

      • 

    • 

      联表查询
      

      • 

    

    • 

  • 

    聚合查询
    

    • 

  • 

    分组查询
    

    • 

  • 

    F与Q查询
    

    • 



 


 


今日内容详细


单表操作


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
    """
user_obj.name = \'egonPPP\'
user_obj.save()




 


 


 


***必知必会13条***




# 1.all()  　　查询所有数据
​
# 2.filter()     带有过滤条件的查询

# 3.get()       直接拿数据对象 但是条件不存在直接报错

# 4.first()      拿queryset里面第一个元素
res = models.User.objects.all().first()
print(res)

# 5.last()      拿queryset里面最后一个元素
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)

"""
 # 查看内部封装的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\',
        },
    }
}






神奇的双下划线__查询


    # 年龄大于35岁的数据gt
    res = models.User.objects.filter(age__gt=35)
    print(res)


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


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

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

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

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

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

​
    # 查询出以j开头的数据
　　res = models.User.objects.filter(name__startswith=\'j\')


    # 查询出以j结尾的数据
　　res1 = models.User.objects.filter(name__endswith=\'j\')
       print(res,res1)
​
​
    # 查询出注册时间是 2020 1月
    res = models.User.objects.filter(register_time__month=\'1\')
    res = models.User.objects.filter(register_time__year=\'2020\')






一对多外键增删改查


    # 增




    # 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)





  # 删
   models.Publish.objects.filter(pk=1).delete()  　　　　　　　　　　　　# 级联删除
​
   # 修改




    models.Book.objects.filter(pk=1).update(publish_id=2)
    publish_obj = models.Publish.objects.filter(pk=1).first()
    models.Book.objects.filter(pk=1).update(publish=publish_obj)











多对多外键增删改查


# 如何给书籍添加作者？增




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




​
    # 删




    book_obj.authors.remove(2)
    book_obj.authors.remove(1,3)
​
    author_obj = models.Author.objects.filter(pk=2).first()
    author_obj1 = models.Author.objects.filter(pk=3).first()
    book_obj.authors.remove(author_obj,author_obj1)
    """
    remove
        括号内既可以传数字也可以传对象 并且都支持多个
    """






    # 修改




    book_obj.authors.set([1,2])  # 括号内必须给一个可迭代对象
    book_obj.authors.set([3])  # 括号内必须给一个可迭代对象
​
    author_obj = models.Author.objects.filter(pk=2).first()
    author_obj1 = models.Author.objects.filter(pk=3).first()
    book_obj.authors.set([author_obj,author_obj1])  # 括号内必须给一个可迭代对象
​
    """
    set
        括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个
    """






    # 清空




    在第三张关系表中清空某个书籍与作者的绑定关系
    book_obj.authors.clear()
    """
    clear
        括号内不要加任何参数
    
    """






 






正反向的概念


  外键字段在我手上那么，我查你就是正向
  外键字段如果不在手上，我查你就是反向
  
关联字段存在于基表中,称为正向查询
  book(基表) >>>外键字段在书那儿(正向)>>> publish
publish(基表)   >>>外键字段在书那儿(反向)>>>book
  
  一对一和多对多正反向的判断也是如此
  

  正向查询按关联字段:publish
  反向查询按表名小写:_set
            
​





多表查询


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




# 1.查询书籍主键为1的出版社
book_obj = models.Book.objects.filter(pk=1).first()
# 书查出版社 正向
res = book_obj.publish
print(res)
print(res.name)
print(res.addr)
# 2.查询书籍主键为2的作者
book_obj = models.Book.objects.filter(pk=2).first()
# 书查作者 正向
# res = book_obj.authors            # app01.Author.None
res = book_obj.authors.all()            # <QuerySet [<Author: Author object>, <Author: Author object>]>

print(res)

# 3.查询作者jason的电话号码
author_obj = models.Author.objects.filter(name=\'jason\').first()
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()
出版社查书  反向
res = publish_obj.book_set                  # app01.Book.None
res = publish_obj.book_set.all()
print(res)

# 5.查询作者是jason写过的书
author_obj = models.Author.objects.filter(name=\'jason\').first()
# 作者查书      反向
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.查询jason的手机号和作者姓名
res = models.Author.objects.filter(name=\'jason\').values(\'author_detail__phone\',\'name\')
print(res)
# 反向
res = models.AuthorDetail.objects.filter(author__name=\'jason\')  # 拿作者姓名是jason的作者详情
res = models.AuthorDetail.objects.filter(author__name=\'jason\').values(\'phone\',\'author__name\')
print(res)


# 2.查询书籍主键为1的出版社名称和书的名称
res = models.Book.objects.filter(pk=1).values(\'title\',\'publish__name\')
print(res)
# 反向
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
res = models.Book.objects.filter(pk=1).values(\'authors__author_detail__phone\')
print(res)

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




 


 


 


 


 


 


 


 


 


 





	











    
    

    
    

    

    

    

    

        

    

    

    

    

    



 
                    
            
                

                  
 
        

	 
        

            

                                
分类：
 
                                                                
技术点：

                                            

        

        
相关文章：

        

      
            
 
                    
    
                                            

               
   
         

    


  






 
          

    
猜你喜欢 

        
    
                                 
  • 
                     
                    2022-12-23
                
    • 
                                     
  • 
                     
                    2022-12-23
                
    • 
                                     
  • 
                     
                    2021-12-23
                
    • 
                                     
  • 
                     
                    2022-01-23
                
    • 
                                     
  • 
                     
                    2021-04-29
                
    • 
                            

   
 



    
相关资源 

        
   

   
    

     
相似解决方案 

         
    
                          

    

  
   

    

 
   

    
热门标签  

    

                    Java
                        Python
                        linux
                        javascript
                        Mysql
                        C#
                        Docker
                        算法
                        前端
                        SpringBoot
                        Redis
                        Vue
                        spring
                        设计模式
                        .net core
                        .net
                        kubernetes
                        c++
                        数据库
                        数据结构
                        大数据
                        js
                        机器学习
                        微服务
                        Android
                        Go
                        程序员
                        面试
                        JVM
                        ASP.net core
                        云原生
                        人工智能
                        后端
                        PHP
                        git
                        CSS
                        golang
                        k8s
                        Nginx
                        Django
                        mybatis
                        深度学习
                        多线程
                        React
                        架构
                        devops
                        爬虫
                        云计算
                        Spring Boot
                        LeetCode