day 69 Django 视图层（views）and 模板层（templates）

视图层（views）:

　　一个视图函数，简称视图，是一个简单的python函数。他接受web请求并返回web响应。响应可以是一张网页的内容，也可以是一个重定向，一个404错误，

　　约定是将视图放置在项目或应用程序目录中的名为views.py的文件中。

视图会返回一个HttpResponse对象，其中包含生成的响应。每个视图函数都负责返回一个HttpResponse对象。

视图层，熟练掌握两个对象即可：请求对象(request)和响应对象(HttpResponse)

 

HttpRequest对象：

　　request属性：

request属性 　　

django将请求报文中的请求行、首部信息、内容主体封装成 HttpRequest 类中的属性。 除了特殊说明的之外，其他均为只读的。

复制代码
/*

1.HttpRequest.GET

　　一个类似于字典的对象，包含 HTTP GET 的所有参数。详情请参考 QueryDict 对象。

2.HttpRequest.POST

　　一个类似于字典的对象，如果请求中包含表单数据，则将这些数据封装成 QueryDict 对象。

　　POST 请求可以带有空的 POST 字典 —— 如果通过 HTTP POST 方法发送一个表单，但是表单中没有任何的数据，QueryDict 对象依然会被创建。
   因此，不应该使用 if request.POST  来检查使用的是否是POST 方法；应该使用 if request.method == "POST"
　　另外：如果使用 POST 上传文件的话，文件信息将包含在 FILES 属性中。
   
   注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：
        request.POST.getlist("hobby")

3.HttpRequest.body

　　一个字符串，代表请求报文的主体。在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML,Json等。
　　但是，如果要处理表单数据的时候，推荐还是使用 HttpRequest.POST 。


4.HttpRequest.path

　　一个字符串，表示请求的路径组件（不含域名）。
　　例如："/music/bands/the_beatles/"

5.HttpRequest.method

　　一个字符串，表示请求使用的HTTP 方法。必须使用大写。
　　例如："GET"、"POST"


6.HttpRequest.encoding

　　一个字符串，表示提交的数据的编码方式（如果为 None 则表示使用 DEFAULT_CHARSET 的设置，默认为 'utf-8'）。
   这个属性是可写的，你可以修改它来修改访问表单数据使用的编码。
   接下来对属性的任何访问（例如从 GET 或 POST 中读取数据）将使用新的 encoding 值。
   如果你知道表单数据的编码不是 DEFAULT_CHARSET ，则使用它。


7.HttpRequest.META

 　　一个标准的Python 字典，包含所有的HTTP 首部。具体的头部信息取决于客户端和服务器，下面是一些示例：

    CONTENT_LENGTH —— 请求的正文的长度（是一个字符串）。
    CONTENT_TYPE —— 请求的正文的MIME 类型。
    HTTP_ACCEPT —— 响应可接收的Content-Type。
    HTTP_ACCEPT_ENCODING —— 响应可接收的编码。
    HTTP_ACCEPT_LANGUAGE —— 响应可接收的语言。
    HTTP_HOST —— 客服端发送的HTTP Host 头部。
    HTTP_REFERER —— Referring 页面。
    HTTP_USER_AGENT —— 客户端的user-agent 字符串。
    QUERY_STRING —— 单个字符串形式的查询字符串（未解析过的形式）。
    REMOTE_ADDR —— 客户端的IP 地址。
    REMOTE_HOST —— 客户端的主机名。
    REMOTE_USER —— 服务器认证后的用户。
    REQUEST_METHOD —— 一个字符串，例如"GET" 或"POST"。
    SERVER_NAME —— 服务器的主机名。
    SERVER_PORT —— 服务器的端口（是一个字符串）。
 　　从上面可以看到，除 CONTENT_LENGTH 和 CONTENT_TYPE 之外，请求中的任何 HTTP 首部转换为 META 的键时，
    都会将所有字母大写并将连接符替换为下划线最后加上 HTTP_  前缀。
    所以，一个叫做 X-Bender 的头部将转换成 META 中的 HTTP_X_BENDER 键。

8.HttpRequest.FILES

　　一个类似于字典的对象，包含所有的上传文件信息。
   FILES 中的每个键为<input type="file" name="" /> 中的name，值则为对应的数据。
　　注意，FILES 只有在请求的方法为POST 且提交的<form> 带有enctype="multipart/form-data" 的情况下才会
   包含数据。否则，FILES 将为一个空的类似于字典的对象。


9.HttpRequest.COOKIES

　　一个标准的Python 字典，包含所有的cookie。键和值都为字符串。



10.HttpRequest.session

 　　一个既可读又可写的类似于字典的对象，表示当前的会话。只有当Django 启用会话的支持时才可用。
    完整的细节参见会话的文档。


11.HttpRequest.user(用户认证组件下使用)

　　一个 AUTH_USER_MODEL 类型的对象，表示当前登录的用户。

　　如果用户当前没有登录，user 将设置为 django.contrib.auth.models.AnonymousUser 的一个实例。你可以通过 is_authenticated() 区分它们。

    例如：

    if request.user.is_authenticated():
        # Do something for logged-in users.
    else:
        # Do something for anonymous users.


     　　user 只有当Django 启用 AuthenticationMiddleware 中间件时才可用。

     -------------------------------------------------------------------------------------

    匿名用户
    class models.AnonymousUser

    django.contrib.auth.models.AnonymousUser 类实现了django.contrib.auth.models.User 接口，但具有下面几个不同点：

    id 永远为None。
    username 永远为空字符串。
    get_username() 永远返回空字符串。
    is_staff 和 is_superuser 永远为False。
    is_active 永远为 False。
    groups 和 user_permissions 永远为空。
    is_anonymous() 返回True 而不是False。
    is_authenticated() 返回False 而不是True。
    set_password()、check_password()、save() 和delete() 引发 NotImplementedError。
    New in Django 1.8:
    新增 AnonymousUser.get_username() 以更好地模拟 django.contrib.auth.models.User。

*/
复制代码

 

request常用方法

复制代码
/*

1.HttpRequest.get_full_path()

　　返回 path，如果可以将加上查询字符串。

　　例如："/music/bands/the_beatles/?print=true"


2.HttpRequest.is_ajax()

　　如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'。

　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。

　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cache middleware，
   你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存。

*/
复制代码

 

 

HttpResponse对象

响应对象主要有三种形式：

　　HttpResponse()    #返回字符串

　　render()　　　　# 返回指定模板

　　redirect()　　　　# 重定向到另一个路径

使用：

　　HttpResponse(‘xxx’)    

　　render(request,'视图函数',{'模板字符'：‘将要替换的值’，…………})

　　redirect()

　　　　1.需要先导入reverse 使用反转reverse('别名') 传一个别名，这个别名就是将要跳转到的页面的路径

　　　　2.然后使用重定向redirect（url） 传一个反转之后的路径就OK了。

 

两次请求

1）301和302的区别。

　　301和302状态码都表示重定向，就是说浏览器在拿到服务器返回的这个状态码后会自动跳转到一个新的URL地址，这个地址可以从响应的Location首部中获取
  （用户看到的效果就是他输入的地址A瞬间变成了另一个地址B）——这是它们的共同点。

　　他们的不同在于。301表示旧地址A的资源已经被永久地移除了（这个资源不可访问了），搜索引擎在抓取新内容的同时也将旧的网址交换为重定向之后的网址；

　　302表示旧地址A的资源还在（仍然可以访问），这个重定向只是临时地从旧地址A跳转到地址B，搜索引擎会抓取新的内容而保存旧的网址。 SEO302好于301

 

2）重定向原因：
（1）网站调整（如改变网页目录结构）；
（2）网页被移到一个新地址；
（3）网页扩展名改变(如应用需要把.php改成.Html或.shtml)。
        这种情况下，如果不做重定向，则用户收藏夹或搜索引擎数据库中旧地址只能让访问客户得到一个404页面错误信息，访问流量白白丧失；再者某些注册了多个域名的
    网站，也需要通过重定向让访问这些域名的用户自动跳转到主站点等。

 

APPEND_SLASH 机制

一般：我们在导航栏输入页面的地址，有时候会忘记给URL的末尾加上一个“/”符号（如果我们定义的路径中存在末尾的/符），回车后，第一次向浏览器提交，

其实Django 会检测到这个错误，浏览器在收到信息时并没有报错，Django会告诉浏览器重新再发一次请求，并在路径的末尾添加上未写的‘/’符号，然后成功访问页面。

 

总结：所以如果我们输错的话，等于是浏览器向服务器发送了两次请求，才访问到页面，

　　而这件事就是Django中的APPEND_SLASH=True做的。

　　如果我们想要去掉这个机制，可以在全局路径（settings）中设置 APPEND_SLASH = Flase 即可。

 

 

Django的模板层（templates）:

　　我们在设计代码时，为了提高代码的可读性，对代码进行了解耦。将页面的设计和Python的代码分离开会更干净简洁更容易维护。

 

推荐写法：

import datetime
    now=datetime.datetime.now()
    return render(request, 'current_datetime.html', {'current_date':str(now)[:19]})
复制代码

采用 render(request,'相应页面/信息',{'模板字符'：‘将要被替换的字符’，……})的格式来书写代码，提高代码的可读性

 

一。模板语法之变量

在Django中变量复杂数据结构的关键时句点字符：语法{{ var_name }}

views:

 

 index:

 

 

 

views.py：

复制代码
def index(request):
    import datetime
    s="hello"
    l=[111,222,333]    # 列表
    dic={"name":"yuan","age":18}  # 字典
    date = datetime.date(1993, 5, 2)   # 日期对象
 
    class Person(object):
        def __init__(self,name):
            self.name=name
 
    person_yuan=Person("yuan")  # 自定义类对象
    person_egon=Person("egon")
    person_alex=Person("alex")
 
    person_list=[person_yuan,person_egon,person_alex]
 
 
    return render(request,"index.html",{"l":l,"dic":dic,"date":date,"person_list":person_list})　
复制代码

template： 

<h4>{{s}}</h4>
<h4>列表:{{ l.0 }}</h4>
<h4>列表:{{ l.2 }}</h4>
<h4>字典:{{ dic.name }}</h4>
<h4>日期:{{ date.year }}</h4>
<h4>类对象列表:{{ person_list.0.name }}</h4>

 

注意：句点符也可以用来引用对象的方法(无参数方法):
　　<h4>字典:{{ dic.name.upper }}</h4>

 

 

 

模板之过滤器(filter)：

1.default

如果一个变量是false或者为空或者是0，使用给定的默认值。否则使用变量的值。

{{value|default:'nothing'}}

 

2.length

返回值的长度。它对字符串和列表都起作用。

实例：

{{value|length}}

如果value是['a','b','c'],那么输出是3.

 

3.filesizeformat

将值格式化为一个‘人类可读的’文件尺寸（例如‘13KB’,'4.1MB','102bytes'）and so on 诸如此类。

例如：

{{value|filesizeformat}}

如果value是123456789，输出将会是117.7MB。

 

4.date:

如果value = datetime.datetime.now()

{{value|date:'Y-m-d'}}

 

5.slice

如果value = 'hell0 world'

{{value|slice:'2:-1'}}

 

6.truncatechars

如果字符串多于指定的字符数量，那么会被截断。截断的字符将以可翻译的省略好序列（‘...’）结尾。

例如：

{{value|truncatechar:9}}

比如 截取 ‘hello’ 这个字符串，如果截取为3或小于3，则会是‘...’三个省略号。

如果为4，会返回 ‘h...’

 

7.safe

Django的模板中会对HTML标签和JS等语法标签进行自动转义，原因显而易见，这样是为了安全。但是有的时候我们可能不希望这些HTML元素被转义，比如我们做一个内容管理系统，后台添加的文章中是经过修饰的，这些修饰可能是通过一个类似于FCKeditor编辑加注了HTML修饰符的文本，如果自动转义的话显示的就是保护HTML标签的源文件。为了在Django中关闭HTML的自动转义有两种方式，如果是一个单独的变量我们可以通过过滤器“|safe”的方式告诉Django这段代码是安全的不必转义。比如：

value="<a href="">点击</a>"
{{ value|safe}}

这里简单介绍一些常用的模板的过滤器，更多详见

 

3 模板之标签　

标签看起来像是这样的： {% tag %}。标签比变量更加复杂：一些在输出中创建文本，一些通过循环或逻辑来控制流程，一些加载其后的变量将使用到的额外信息到模版中。一些标签需要开始和结束标签 （例如{% tag %} ...标签 内容 ... {% endtag %}）。

for标签

遍历每一个元素：

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

可以利用{% for obj in list reversed %}反向完成循环。

遍历一个字典：

{% for key,val in dic.items %}
    <p>{{ key }}:{{ val }}</p>
{% endfor %}

注：循环序号可以通过｛｛forloop｝｝显示　　

forloop.counter            The current iteration of the loop (1-indexed)
forloop.counter0           The current iteration of the loop (0-indexed)
forloop.revcounter         The number of iterations from the end of the loop (1-indexed)
forloop.revcounter0        The number of iterations from the end of the loop (0-indexed)
forloop.first              True if this is the first time through the loop
forloop.last               True if this is the last time through the loop

 

for ... empty

for 标签带有一个可选的{% empty %} 从句，以便在给出的组是空的或者没有被找到时，可以有所操作。

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

{% empty %}
    <p>sorry,no person here</p>
{% endfor %}

 

if 标签

{% if %}会对一个变量求值，如果它的值是“True”（存在、不为空、且不是boolean类型的false值），对应的内容块会输出。

复制代码
{% if num > 100 or num < 0 %}
    <p>无效</p>
{% elif num > 80 and num < 100 %}
    <p>优秀</p>
{% else %}
    <p>凑活吧</p>
{% endif %}
复制代码

 

with

使用一个简单地名字缓存一个复杂的变量，当你需要使用一个“昂贵的”方法（比如访问数据库）很多次的时候是非常有用的

例如：

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

 

csrf_token

这个标签用于跨站请求伪造保护

 

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

1、在settings中的INSTALLED_APPS配置当前app，不然django无法找到自定义的simple_tag.

2、在app中创建templatetags模块(模块名只能是templatetags)

3、创建任意 .py 文件，如：my_tags.py

from django import template
from django.utils.safestring import mark_safe
 
register = template.Library()   #register的名字是固定的,不可改变
 
 
@register.filter
def filter_multi(v1,v2):
    return  v1 * v2



@register.simple_tag
def simple_tag_multi(v1,v2):
    return  v1 * v2



@register.simple_tag
def my_input(id,arg):
    result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
    return mark_safe(result)

 

4、在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py

{% load my_tags %}　

 

5、使用simple_tag和filter（如何调用）

-------------------------------.html
{% load xxx %}  
      
# num=12
{{ num|filter_multi:2 }} #24
 
{{ num|filter_multi:"[22,333,4444]" }}
 
{% simple_tag_multi 2 5 %}  参数不限,但不能放在if for语句中
{% simple_tag_multi num 5 %}

注意：filter可以用在if等语句后，simple_tag不可以

{% if num|filter_multi:30 > 100 %}
    {{ num|filter_multi:30 }}
{% endif %}

 

 也可以这样写：

from django import template

register = template.Library()


@register.filter(name='sb')  # filter名字叫做sb
def add_sb(arg):
    return "{}sb".format(arg)


'''
使用filter“sb”的方法：
    在template顶部：{{ load 'myfilter' }}
    在需要使用的地方：
        {{ name|sb }}

simple_tag的使用方法类似，
定义好了之后：
    {{ 函数名 参数 参数 xx}}  在template中这样调用
'''

 

5 模板继承 (extend)

Django模版引擎中最强大也是最复杂的部分就是模版继承了。模版继承可以让您创建一个基本的“骨架”模版，它包含您站点中的全部元素，并且可以定义能够被子模版覆盖的 blocks 。

复制代码
<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>

　　　　　　{% block title %}My amazing site{%/span> endblock %}

　　</title>
</head>

<body>
    <div id="sidebar">

        {% block sidebar %}
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
        {% endblock %}

    </div>

    <div id="content">

        {% block content %}{% endblock %}

    </div>
</body>
</html>
复制代码

这个模版，我们把它叫作 base.html，“子模版”的工作是用它们的内容填充空的blocks。

 

 

模板继承--include

写一个空的html文件继承base.html文件然后，在空文件中写base.html中的
    block,只要是base.html种存在的block，就会达到替换的效果

 

子模版可能看起来是这样的（继承base.html中的东西，保留自己中的block）：

{% extends "base.html" %}
 
{% block title %}My amazing blog{% endblock %}
 
{% block content %}
{% for entry in blog_entries %}
    <h2>{{ entry.title }}</h2>
    <p>{{ entry.body }}</p>
{% endfor %}
{% endblock %}

 

 

extends 标签

　　它将定位父模版就是“base.html”并。用子模版中的内容来替换这些block。

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>My amazing blog</title>
</head>
 
<body>
    <div id="sidebar">
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
    </div>
 
    <div id="content">
        <h2>Entry one</h2>
        <p>This is my first entry.</p>
 
        <h2>Entry two</h2>
        <p>This is my second entry.</p>
    </div>
</body>
</html>

　　子模版并没有定义 sidebar block，所以系统使用了父模版中的值。

　　父模版的 {% block %} 标签中的内容总是被用作备选内容（fallback）。

　　这种方式使代码得到最大程度的复用

 

 

 

这里是使用继承的一些提示：

  • 如果你在模版中使用 {% extends %} 标签，它必须是模版中的第一个标签。

  • 为了更好的可读性，你也可以给你的 {% endblock %} 标签一个 名字 。

  • {% block content %}
...
{% endblock content %}
  • 不能在一个模版中定义多个相同名字的 block 标签。

 

posted @ 2018-06-25 21:28  Coca-Mirinda  阅读(173)  评论(0)  编辑  收藏  举报