Django基础之视图(views)层、模板层

目录

• Django基础之视图(views)层、模板层
  • 一 视图函数
    • 响应对象(HttpResponse)
    • 二请求对象(HttpRequest)
  • JsonResponse
    • 向前端返回一个json格式字符串的两种方式
    • 重写Django中的json的某个方法
  • form表单上传文件
  • FBV与CBV
    • CBV
    • CBV最精髓的部分
  • Django settings源码分析及实际应用
• Django之模板层
  • 模板简介
    • django的模板=HTML代码+模板语法
  • 模板传值
  • 过滤器(|)
  • 标签
    • 前端if 标签
      • 案例
    • 前端for标签
    • 前端with标签
  • 自定义过滤器、标签
    • 自定义的过滤器
    • 自定义标签
    • 自定义的过滤器和自定义标签
  • 模板的继承
  • 模板的导入
  • Django请求生命周期

Django基础之视图(views)层、模板层

一 视图函数

视图函数，简称视图，属于Django的视图层，默认定义在views.py文件中，是用来处理web请求信息以及返回响应信息的函数，所以研究视图函数只需熟练掌握两个对象即可：请求对象(HttpRequest)和响应对象(HttpResponse)

• 响应对象(HttpResponse)

  响应可以是任何形式的内容，比如一个HTML文件的内容，一个重定向，一个404错误，一个XML文档，或者一张图片等。总之，无论视图本身包含什么逻辑，都要返回响应，具体的说，响应对象主要有三种形式:HttpResponse,render,redirect

• 二请求对象(HttpRequest)

  django将http协议请求报文中的请求行、首部信息、内容主体封装到了HttpRequest对象中（类似于我们自定义框架的environ参数）。 django会将HttpRequest对象当做参数传给视图函数的第一个参数request，在视图函数中，通过访问该对象的属性便可以提取http协议的请求数据

JsonResponse

返回一个json格式数据
​ 为什么要给前端返回一个json字符串？
​ 答：前后端分离就是基于json格式传输数据 前端调用接口 就能够拿到json格式的字符串，然后前端利用序列化（json.stringify）反序列化(json.parse)转换成前端对应的数据类型

向前端返回一个json格式字符串的两种方式

方式一：

import json

def my_view(request,ensure_ascii=True):
    data = ['jsaon','yjy']
    return HttpResponse(json.dumps(data))
#ensure_ascii=True可以不会把中文序列化，可以将中文正常显示

方式二：

from django.http import JsonResponse

def my_view(request):
    data = ['jsaon','yjy']
    return JsonResponse(data，safe=False)
    #默认safe=True代表只能序列化字典对象，safe=False可以序列化字典以外的对象

重写Django中的json的某个方法

重写Django中的json的某个方法让他也能够序列化datetime

class MyJsonClass(json.JSONENcoder):
    def default(self,o):
    if isinstance(o,datetime):
        return o.strftime('%Y-%m-%d')
    else:
        super().default(self,0)
d = {'ctime':datetime.today()}
print(json.dump(d,cls= MyJsonClass))

form表单上传文件

注意事项：

• 提交方式必须是post
• method属性需要由默认的get变成post
• enctype参数必须有默认的urlencoded变成formdata

视图层

def up(request):
    if request.method == "POST":
        print(request.POST)
        print(request.FILES)
        #获取文件对象
        fille_obj = request.FILES.get('myfile')
        print(file_obj.name)
        with open(file_obj.name,'wb') as f:
            for chunk in fille_obj.chunks():
                f.write(chunk)
     return render(request,'up.html')

前端页面

<form action="" method="post" enctype="multipart/form-data">
    <input type="file" name="myfile">
</form>

FBV与CBV

1、FBV基于函数的视图（Function base view），我们之前一直介绍的都是FBV
2、CBV基于类的视图(Class base view)

CBV

url(r'^reg/',views.MyReg.as_view())

基于类的视图
urls.py

from django.urls import path,register_converter
from app01 import views

url = [
    url('r^login/',view.MyReg.as_view())
]
#必须调用类下的方法as_view

views.py

from django.views import View
class MyReg(View):
    def get(self,request):
    return render(request,'reg.html')

    def post(self,request):
    return HttpResponse("我是MyReg类中post方法")

CBV最精髓的部分

def dispatch(self, request, *args, **kwargs):
        if request.method.lower() in self.http_method_names:  # 判断当前请求方式在不在默认的八个请求方式中
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
            # handler = getattr(自己写的类产生的对象,'小写的请求方法(getpost)','获取不到对应的方法就报错')
            # handler就是我们自己定义的跟请求方法相对应的方法的函数内存地址
        else:
            handler = self.http_method_not_allowed
        return handler(request, *args, **kwargs)  # 在调用获取到的方法

django settings源码分析及实际应用(你可以不掌握 但是我希望你掌握思路)
    
    django的配置文件有两个
        一个是暴露给用户可以自定义配置的
        一个是默认的全局配置文件
            用户指定了就用用户的
            用户没有指定就用默认的

Django settings源码分析及实际应用

Django的配置文件有两个
一个是暴露菇用户可以自定义的

一个是全局的配置文件
用户指定了就用用户的，没有指定就用全局的

from django.conf import settings
    settings = LazySettings()


 class LazySettings(LazyObject):
        
        def _setup(self, name=None):
     
            # os.environ你可以把它看成是一个全局的大字典
            settings_module = os.environ.get(ENVIRONMENT_VARIABLE)  # 从大字典中取值
            # settings_module = 'day59.settings'
  
            self._wrapped = Settings(settings_module)  # Settings('day59.settings')
    
    class Settings(object):
        def __init__(self, settings_module):  # settings_module = 'day59.settings'
            for setting in dir(global_settings):  # 循环获取global_settings文件中所有的名字
                if setting.isupper():  # 在判断名字是否是大写
                    # 如果是大写 利用反射 获取到大写的名字所对应的值  不停地添加到对象中
                    setattr(self, setting, getattr(global_settings, setting))
            # store the settings module in case someone later cares
            self.SETTINGS_MODULE = settings_module
            mod = importlib.import_module(self.SETTINGS_MODULE)  # 'day59.settings'
            # from day59 import settings
            # mod 指代的就是暴露给用户的配置文件模块名
           
            for setting in dir(mod):  # 循环获取暴露给用户配置文件中所有的名字
                if setting.isupper():  # 判断是否是大写
                    setting_value = getattr(mod, setting)  # 如果是大写 获取大写的变量名所对应的值
                    setattr(self, setting, setting_value)  # 不停的给对象设置值

Django之模板层

模板简介

在刚刚介绍完的视图层中我们提到，浏览器发送的请求信息会转发给视图函数进行处理，而视图函数在经过一系列处理后必须要有返回信息给浏览器。如果我们要返回html标签、css等数据给浏览器进行渲染，我们可以在视图函数中这么做

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

上例所示，我们直接将HTML代码放到视图函数里，然后进行返回，这可以使我们很直观地看清楚浏览器从发送请求到看到前端界面内容的这个过程中视图函数的基本工作原理，但是这种将前端代码与后端代码耦合到了一起开发方式，会存在以下问题

• 1、程序的可维护性与可扩展性问题
  前端界面一旦需要重新设计、修改，则必须对后端的Python代码进行相应的修改。 然而前端界面的修改往往比后端 Python 代码的修改要频繁得多，因此如果可以在不进行 Python 代码修改的情况下变更前端界面的设计，那将会方便得多。
• 2、开发效率问题
  Python 代码编写和 HTML 设计是两项不同的工作，大多数专业的网站开发环境都将它们分配给不同的人员（甚至不同部门）来完成。 专门的程序员去编写 Python代码、专门的设计人员去制作模板，这两项工作同时进行，效率才是最高的。

基于上述原因，将前端页面和Python的代码分离是一种不错的开发模式。将前端页面和Python的代码分离是一种不错的开发模式。 为此 Django专门提供了模板系统

django的模板=HTML代码+模板语法

存放于templates目录下的html文件称之为模板文件，如果我们想要返回的html页面中的数据是动态的，那么必须在html页面中嵌入变量，这便用到了django的模板语法，具体来说，django的模板语法有以下重点

• 一、变量：{{ 变量名 }}
  1.1 深度查询：句点符的应用
  1.2 过滤器
• 二、标签：{% 标签名 %}
• 三、自定义标签和过滤器
• 四、模板的导入和继承

模板传值

1.模板传值可以传数字、字符串、字典、集合、列表、函数、类等

def test(request):
    # 传给模板的变量值可以是任意python类型，如下
    msg='hello world'
    dic={'k1':1,'k2':2}
    class Person(object):
        def __init__(self,name,age):
            self.name=name
            self.age=age

    obj=Person('egon',18)
    li = [1,'aaa',obj]

    return render(request,'test.html',{'msg':msg,'dic':dic,'obj':obj,'li':li})
# 注意：
    # 1、render函数的第三个参数包含了要传给模板的变量值，是一个字典类型，该字典中的key必须与模板文件中的变量名相对应，render函数会去templates目录下找到模板文件，然后根据字典中的key对应到模板文件中的变量名进行赋值操作，最后将赋值后的模板文件内容返回给浏览器
    # 2、可以将render函数的第三个参数简写为locals(),如下
    return render(request,'test.html',locals()) 
#locals()会将函数test内定义的名字与值转换为字典中的k与v

2.深度查询之句点符的使用

当视图函数传给模板的值中包含多个元素时，若想取出其中的单个元素，就必须使用句点符了。
句点符既可以引用容器类型的元素，也可以引用对象的方法

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<!--调用字符串对象的upper方法，注意不要加括号-->
<p>{{ msg.upper }}</p>

<!--取字典中k1对应的值-->
<p>{{ dic.k1 }}</p>

<!--取对象的name属性-->
<p>{{ obj.name }}</p>

<!--取列表的第2个元素,然后变成大写-->
<p>{{ li.1.upper }}</p>

<!--取列表的第3个元素，并取该元素的age属性-->
<p>{{ li.2.age }}</p>


</body>
</html>

• 如果传递给 前端一个函数名，会直接加括号调用，将返回值展示到页面上
• Django模板语法不支持传参
• Django模板语法在获取容器类型内部元素的值得时候只能通过句点符取值

过滤器(|)

• 过滤器类似于python的内置函数，用来把视图传入的变量值加以修饰后再显示

• 过滤器有点类似于小的内置方法

• 特点：会将|左边的当做过滤器的第一个元素，会将|右边的当做过滤器的第二个元素
  eg：
  add：加

<p>{{n|add:100}}</p>

常用的过滤器

#1、default
#作用：如果一个变量值是False或者为空，使用default后指定的默认值，否则，使用变量本身的值，如果value=’‘则输出“nothing”
{{ value|default:"nothing" }}

#2、length
#作用：返回值的长度。它对字符串、列表、字典等容器类型都起作用，如果value是 ['a', 'b', 'c', 'd']，那么输出是4
{{ value|length }}

#3、filesizeformat
#作用：将值的格式化为一个"人类可读的"文件尺寸(如13KB、4.1 MB、102bytes等等），如果 value 是 12312312321，输出将会是 11.5 GB
{{ value|filesizeformat }}

#4、date
#作用：将日期按照指定的格式输出，如果value=datetime.datetime.now(),按照格式Y-m-d则输出2019-02-02
{{ value|date:"Y-m-d" }}　　

#5、slice
#作用：对输出的字符串进行切片操作，顾头不顾尾,如果value=“egon“，则输出"eg"
{{ value|slice:"0:2" }}　

#6、truncatechars
#作用：如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“...”）结尾，如果value=”hello world egon 嘎嘎“，则输出"hello...",注意8个字符也包含末尾的3个点
{{ value|truncatechars:8 }}

#7、truncatewords
#作用：同truncatechars，但truncatewords是按照单词截断，注意末尾的3个点不算作单词，如果value=”hello world egon 嘎嘎“，则输出"hello world ..."
{{ value|truncatewords:2 }}

#8、safe
#作用：出于安全考虑，Django的模板会对HTML标签、JS等语法标签进行自动转义,例如value="<script>alert(123)</script>"，模板变量{{ value }}会被渲染成<script>alert(123)</script>交给浏览器后会被解析成普通字符”<script>alert(123)</script>“，失去了js代码的语法意义，但如果我们就想让模板变量{{ value }}被渲染的结果又语法意义，那么就用到了过滤器safe，比如value='<a href="https://www.baidu.com">点我啊</a>'，在被safe过滤器处理后就成为了真正的超链接，不加safe过滤器则会当做普通字符显示’<a href="https://www.baidu.com">点我啊</a>‘
{{ value|safe }}

注意：

模板语法的符号就两种
          {{}}  变量相关
          {%%}  逻辑相关

标签

标签是为了在模板中完成一些特殊功能,语法为{% 标签名 %}，一些标签还需要搭配结束标签 {% endtag %}

前端if 标签

{% if n %}
    <p>n有值</p>
{% else %}
    <p>n没有值</p>
{% endif %}

if语句支持 and 、or、==、>、<、!=、<=、>=、in、not in、is、is not判断。

案例

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>

<h3>首页</h3>
<!--
如果用户已经登录，则current_user变量有值，if判断结果为真，会打印变量current_user的值，为当前登录的用户名
如果用户没有登录，则current_user变量无值，if判断结果为假，会打印a标签要求用户先登录
-->
{% if current_user %}
    <p>当前登录用户为：{{ current_user }}</p>
{% else %}
    <p><a href="/login/">请先登录</a></p>
{% endif %}

</body>
</html>

前端for标签

遍历每一个元素

{% for person in person_list %}
    <p>{{ person.name }}</p>
{% endfor %}

• 循环序号可以通过{{ forloop }}显示　

forloop.counter            当前循环的索引值（从1开始）
forloop.counter0           当前循环的索引值（从0开始）
forloop.revcounter         当前循环的倒序索引值（从1开始）
forloop.revcounter0        当前循环的倒序索引值（从0开始）
forloop.first              当前循环是第一次循环则返回True，否则返回False
forloop.last               当前循环是最后一次循环则返回True，否则返回False
forloop.parentloop         本层循环的外层循环

eg:

{% for foo in l %}
    {% if forloop.first %}   #forloop.first为True的时候
        <p>这是我的第一次</p>
    {% elif forloop.last %}    #forloop.last为True的时候
        <p>这是最后一次了啊</p>
    {% else %}
        <p>嗨起来 大宝贝~</p>
    {% endif %}
{% endfor %}

• for标签可以带有一个可选的{% empty %} 从句，在变量xo为空或者没有被找到时，则执行empty子句

{% for foo in xo %}
    <p>{{ forloop.counter }}:{{ foo }}</p>
    {% empty %}
    <p>你给我的对象是个空的没法进行for循环</p>
{% endfor %}

• 还可以循环字典中的键值对，键、值

{% for foo in d.items %}
    <p>{{ foo }}</p>
{% endfor %}

{% for foo in d.keys %}
    <p>{{ foo }}</p>
{% endfor %}

{% for foo in d.values %}
    <p>{{ foo }}</p>
{% endfor %}

text.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<hr>
{% for name in names %}
    <p>{{ forloop.counter0 }} {{ name }}</p>
{% endfor %}
<!--
输出结果为：
0 egon
1 kevin
-->

<hr>
{% for name in names reversed %}
    <p>{{ forloop.revcounter0 }} {{ name }}</p>
{% endfor %}
<!--
输出结果为：
1 kevin
0 egon
-->

<hr>
{% for k,v in dic.items %}
    <p>{{ forloop.counter }} {{ k }} {{ v }}</p>
{% endfor %}
<!--
输出结果为：
1 name egon
2 age 18
3 sex male
-->

<hr>
{% for item in list1 %}
    <p>{{ item }}</p>
    {% empty %}
        <p>sorry,no value here</p>
{% endfor %}
<!--
输出结果为：
sorry,no value here
-->

</body>
</html>

前端with标签

with标签用来为一个复杂的变量名起别名,如果变量的值来自于数据库，在起别名后只需要使用别名即可，无需每次都向数据库发送请求来重新获取变量的值，如果你要重复利用一个很复杂的值，你就可以给这个值起一个别名，到时候直接用别名就好了

{% with li.1.upper as v %}
    {{ v }}
{% endwith %}

自定义过滤器、标签

当内置的过滤器或标签无法满足我们需求时，我们可以自定义

步骤:(******)

• 在应用名下面新建一个templatetags文件夹（必须）
• 在该文件夹下新建一个任意名称的py文件
• 在该py文件内 固定先写两行代码

from Django.template import Library

register = Library()

自定义的过滤器

自己新建的文件

@registe.filter(name = 'myplus'
def index(a,b):               )# 自定义的过滤器只能定义最多两个参数
    return a+b

前端页面

{% load my_tag %}
{{123|myplus:123 }}

自定义标签

自己新建的文件

@registe.simple_tag(name = 'mysm')
def login(a b c d):              # 自定义的标签可以定义多个参数
    return '%s %s %s %s'%(a b c d)

前端页面

{% mysm 1 2 3 4 %}

自定义的过滤器和自定义标签

自定义的过滤器可以在if中使用，自定义标签不能在if中使用。
eg:

{% if 0|myplus:123 %}  可以用
            <p>有值</p>
        {% endif %}

{% if mysm 1 2 3 4 %}  不能用
           <p>有值</p>
       {% endif %}

模板的继承

事先需要在模板中通过block划定区域

{% block 区域名字 %}
    标签。。。
{% endblock %}

子板中先继承模板

{% extends '想要继承的页面名字'%}

{% block 区域名字 %}
    <h1>登录页面</h1>
        。。。
{% endblock %}

一个页面上 block块越多 页面的扩展性越高，通常情况下，都应该有三片区域

{% block css %}

{% endblock %}

            
{% block content %}

{% endblock %}

            
{% block js %}

{% endblock %}

子板中还可以通过{{ block.super }} 继续使用母板的内容

模板的导入

当你写了一个特别好看的form表单，你想再多个页面上都使用这个form表单，你就可以将你写的form表单当作模块的形式导入 ，导入过来之后，就可以直接展示

{% include 'good_page.html' %}

Django请求生命周期