Django基礎三之視圖函數

時間 2019-11-17

原文原文鏈接

目錄php

一Django的視圖函數view

一個視圖函數（類），簡稱視圖，是一個簡單的Python 函數（類），它接受Web請求而且返回Web響應。html

響應能夠是一張網頁的HTML內容，一個重定向，一個404錯誤，一個XML文檔，或者一張圖片。前端

　　不管視圖自己包含什麼邏輯，都要返回響應。代碼寫在哪裏也無所謂，只要它在你當前項目目錄下面。除此以外沒有更多的要求了——能夠說「沒有什麼神奇的地方」。爲了將代碼放在某處，你們約定成俗將視圖放置在項目（project）或應用程序（app）目錄中的名爲views.py的文件中。python

一個簡單的視圖ajax

下面是一個以HTML文檔的形式返回當前日期和時間的視圖：數據庫

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

讓咱們來逐行解釋下上面的代碼：django

首先，咱們從 django.http模塊導入了HttpResponse類，以及Python的datetime庫。編程
接着，咱們定義了current_datetime函數。它就是視圖函數。每一個視圖函數都使用HttpRequest對象做爲第一個參數，而且一般稱之爲request。json

注意，視圖函數的名稱並不重要；不須要用一個統一的命名方式來命名，以便讓Django識別它。咱們將其命名爲current_datetime，是由於這個名稱可以比較準確地反映出它實現的功能。瀏覽器
這個視圖會返回一個HttpResponse對象，其中包含生成的響應。每一個視圖函數都負責返回一個HttpResponse對象。

　　Django使用請求和響應對象來經過系統傳遞狀態。

　　當瀏覽器向服務端請求一個頁面時，Django建立一個HttpRequest對象，該對象包含關於請求的元數據。而後，Django加載相應的視圖，將這個HttpRequest對象做爲第一個參數傳遞給視圖函數。

　　每一個視圖負責返回一個HttpResponse對象。

![](https://img2018.cnblogs.com/blog/1596073/201909/1596073-20190925161830336-2051985135.jpg)

　　視圖層，熟練掌握兩個對象便可：請求對象(request)和響應對象(HttpResponse)

二CBA和FBV

FBV（function base views） 就是在視圖裏使用函數處理請求。

以前都是FBV模式寫的代碼，因此就不寫例子了。

CBV（class base views） 就是在視圖裏使用類處理請求。

Python是一個面向對象的編程語言，若是隻用函數來開發，有不少面向對象的優勢就錯失了（繼承、封裝、多態）。因此Django在後來加入了Class-Based-View。可讓咱們用類寫View。這樣作的優勢主要下面兩種：

提升了代碼的複用性，可使用面嚮對象的技術，好比Mixin（多繼承）
能夠用不一樣的函數針對不一樣的HTTP方法處理，而不是經過不少if判斷，提升代碼可讀性

若是咱們要寫一個處理GET方法的view，用函數寫的話是下面這樣。

from django.http import HttpResponse
def my_view(request):
     if request.method == 'GET':
            return HttpResponse('OK')

若是用class-based view寫的話，就是下面這樣

from django.http import HttpResponse
from django.views import View
class MyView(View):
      def get(self, request):
            return HttpResponse('OK')

Django的url是將一個請求分配給可調用的函數的，而不是一個class。針對這個問題，class-based view提供了一個as_view()靜態方法（也就是類方法），調用這個方法，會建立一個類的實例，而後經過實例調用dispatch()方法，dispatch()方法會根據request的method的不一樣調用相應的方法來處理request（如get(),post()等）。到這裏，這些方法和function-based view差很少了，要接收request，獲得一個response返回。若是方法沒有定義，會拋出HttpResponseNotAllowed異常。

注意：使用CBV時，urls.py中也作對應的修改：

# urls.py
from django.conf.urls import url
from myapp.views import MyView #引入咱們在views.py裏面建立的類
urlpatterns = [
     url(r'^index/$', MyView.as_view()),
]

CBV傳參，和FBV相似，有名分組，無名分組

url寫法：無名分組的

url(r'^cv/(\d{2})/', views.Myd.as_view(),name='cv'),
url(r'^cv/(?P<n>\d{2})/', views.Myd.as_view(name='xxx'),name='cv'),#若是想給類的name屬性賦值，前提你的Myd類裏面必須有name屬性（類屬性，定義init方法來接受屬性行不通，可是能夠自行研究一下，看看如何行通，意義不大），而且以前類裏面的name屬性的值會被覆蓋掉

類寫法：

class Myd(View):
    name = 'sb'
    def get(self,request,n):
        print('get方法執行了')
        print('>>>',n)
        return render(request,'cvpost.html',{'name':self.name})
    def post(self,request,n):
        print('post方法被執行了')
        return HttpResponse('post')

添加類的屬性能夠經過兩種方法設置，第一種是常見的Python的方法，能夠被子類覆蓋。

from django.http import HttpResponse
from django.views import View
class GreetingView(View):
    name = "yuan"
    def get(self, request):
         return HttpResponse(self.name)
# You can override that in a subclass
class MorningGreetingView(GreetingView):
    name= "alex"

第二種方法，你也能夠在url中指定類的屬性：

在url中設置類的屬性Python

urlpatterns = [
   url(r'^index/$', GreetingView.as_view(name="egon")), #類裏面必須有name屬性，而且會被傳進來的這個屬性值給覆蓋掉

三使用Mixin

我以爲要理解django的class-based-view（如下簡稱cbv），首先要明白django引入cbv的目的是什麼。在django1.3以前，generic view也就是所謂的通用視圖，使用的是function-based-view（fbv），亦即基於函數的視圖。有人認爲fbv比cbv更pythonic，竊覺得否則。python的一大重要的特性就是面向對象。而cbv更能體現python的面向對象。cbv是經過class的方式來實現視圖方法的。class相對於function，更能利用多態的特定，所以更容易從宏觀層面上將項目內的比較通用的功能抽象出來。關於多態，很少解釋，有興趣的同窗本身Google。總之能夠理解爲一個東西具備多種形態（的特性）。cbv的實現原理經過看django的源碼就很容易明白，大致就是由url路由到這個cbv以後，經過cbv內部的dispatch方法進行分發，將get請求分發給cbv.get方法處理，將post請求分發給cbv.post方法處理，其餘方法相似。怎麼利用多態呢？cbv裏引入了mixin的概念。Mixin就是寫好了的一些基礎類，而後經過不一樣的Mixin組合成爲最終想要的類。

　　因此，理解cbv的基礎是，理解Mixin。Django中使用Mixin來重用代碼，一個View Class能夠繼承多個Mixin，可是隻能繼承一個View（包括View的子類），推薦把View寫在最右邊，多個Mixin寫在左邊。

四給視圖加裝飾器

4.1使用裝飾器裝飾FBV

FBV自己就是一個函數，因此和給普通的函數加裝飾器無差：

def wrapper(func):
    def inner(*args, **kwargs):
        start_time = time.time()
        ret = func(*args, **kwargs)
        end_time = time.time()
        print("used:", end_time-start_time)
        return ret
    return inner
# FBV版添加班級
@wrapper
def add_class(request):
    if request.method == "POST":
        class_name = request.POST.get("class_name")
        models.Classes.objects.create(name=class_name)
        return redirect("/class_list/")
    return render(request, "add_class.html")

4.2使用裝飾器裝飾CBV

類中的方法與獨立函數不徹底相同，所以不能直接將函數裝飾器應用於類中的方法，咱們須要先將其轉換爲方法裝飾器。

Django中提供了method_decorator裝飾器用於將函數裝飾器轉換爲方法裝飾器。

from django.views import View
from django.utils.decorators import method_decorator
class AddClass(View):
    @method_decorator(wrapper)
    def get(self, request):
        return render(request, "add_class.html")
    def post(self, request):
        class_name = request.POST.get("class_name")
        models.Classes.objects.create(name=class_name)
        return redirect("/class_list/")

下面是擴展內容，你們看看就能夠了：

# 使用CBV時要注意，請求過來後會先執行dispatch()這個方法，若是須要批量對具體的請求處理方法，如get，post等作一些操做的時候，這裏咱們能夠手動改寫dispatch方法，這個dispatch方法就和在FBV上加裝飾器的效果同樣。
class Login(View): 
    def dispatch(self, request, *args, **kwargs):
        print('before')
        obj = super(Login,self).dispatch(request, *args, **kwargs)
        print('after')
        return obj
    def get(self,request):
        return render(request,'login.html')
    def post(self,request):
        print(request.POST.get('user'))
        return HttpResponse('Login.post')

另外給cbv添加裝飾器的時候（先做爲了解）：

直接添加在dispatch裏面，這樣每一個函數都會執行

from django.utils.decorators import method_decorator

@method_decorator(login_test)
def dispatch(self, request, *args, **kwargs):
res = super(IndexView, self).dispatch(request, *args, **kwargs)
return res
添加在每個函數中

from django.utils.decorators import method_decorator

@method_decorator(login_test)
def get(self, request, *args, **kwargs):
return render(request, 'index.html')
直接添加在類上，後面的name表示只給get添加裝飾器

from django.utils.decorators import method_decorator

@method_decorator(login_test, name='get') get是給get方法加（以這種方式若是想給多個方法加裝飾器，須要寫多層裝飾器，由於name這個參數的值必須是個字符串，而且不能同時寫兩個方法）

　　　@method_decorator(login_test, name='post') post是給post方法加
　　 class IndexView(View):

　　　　def get(self,request)：

　　　　　　pass

例子：views.py裏面的內容：

from django.shortcuts import render,redirect,HttpResponse
from django.urls import reverse
from django.utils.decorators import method_decorator
from django.views import View
def wrapper(fn):
    def inner(request,*args,**kwargs):
        print('xxxxx')
        ret = fn(request)
        print('xsssss')
        return ret
    return inner
# @method_decorator(wrapper,name='get')#CBV版裝飾器方式一
class BookList(View):
    @method_decorator(wrapper) #CBV版裝飾器方式二
    def dispatch(self, request, *args, **kwargs):
        print('請求內容處理開始')
        res = super().dispatch(request, *args, **kwargs)
        print('處理結束')
        return res
    def get(self,request):
        print('get內容')
        # all_books = models.Book.objects.all()
        return render(request,'login.html')
    @method_decorator(wrapper) #CBV版裝飾器方式三
    def post(self,request):
        print('post內容')
        return redirect(reverse('book_list'))
# @wrapper
def book_list(request):
    return HttpResponse('aaa')

url.py:

url(r'^book_list/', views.book_list,name='book_list'),
url(r'^booklist/', views.BookList.as_view(),name='booklist'),

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/booklist/" method="post">
    {% csrf_token %}
    用戶名：<input type="text" name="username">
    <input type="submit">
</form>
</body>
</html>

添加裝飾器前必須導入from django.utils.decorators import method_decorator
添加裝飾器的格式必須爲@method_decorator()，括號裏面爲裝飾器的函數名
給類添加是必須聲明name
注意csrf-token裝飾器的特殊性，在CBV模式下它只能加在dispatch上面(後面再說)

下面這是csrf_token的裝飾器：

　　@csrf_protect，爲當前函數強制設置防跨站請求僞造功能，即使settings中沒有設置csrfToken全局中間件。

　　@csrf_exempt，取消當前函數防跨站請求僞造功能，即使settings中設置了全局中間件。

　　注意：from django.views.decorators.csrf import csrf_exempt,csrf_protect

五request對象

當一個頁面被請求時，Django就會建立一個包含本次請求原信息（請求報文中的請求行、首部信息、內容主體等）的HttpRequest對象。
　　Django會將這個對象自動傳遞給響應的視圖函數，通常視圖函數約定俗成地使用 request 參數承接這個對象。

當一個頁面被請求時，Django就會建立一個包含本次請求原信息的HttpRequest對象。
　　Django會將這個對象自動傳遞給響應的視圖函數，通常視圖函數約定俗成地使用 request 參數承接這個對象。

官方文檔

請求相關的經常使用值**

path_info 返回用戶訪問url，不包括域名
method 請求中使用的HTTP方法的字符串表示，全大寫表示。
GET 包含全部HTTP GET參數的類字典對象
POST 包含全部HTTP POST參數的類字典對象
body 請求體，byte類型 request.POST的數據就是從body裏面提取到的

　　屬性

全部的屬性應該被認爲是隻讀的，除非另有說明。

屬性：
　　django將請求報文中的請求行、頭部信息、內容主體封裝成 HttpRequest 類中的屬性。
   除了特殊說明的以外，其餘均爲只讀的。
0.HttpRequest.scheme（後面再學）
   表示請求方案的字符串（一般爲http或https）
1.HttpRequest.body(後面再學)
　　一個字符串，表明請求報文的主體。在處理非 HTTP 形式的報文時很是有用，例如：二進制圖片、XML,Json等。
　　可是，若是要處理表單數據的時候，推薦仍是使用 HttpRequest.POST 。
　　另外，咱們還能夠用 python 的類文件方法去操做它，詳情參考 HttpRequest.read() 。
2.HttpRequest.path
　　一個字符串，表示請求的路徑組件（不含域名）。
　　例如："/music/bands/the_beatles/"
3.HttpRequest.method
　　一個字符串，表示請求使用的HTTP 方法。必須使用大寫。
　　例如："GET"、"POST"
4.HttpRequest.encoding
　　一個字符串，表示提交的數據的編碼方式（若是爲 None 則表示使用 DEFAULT_CHARSET 的設置，默認爲 'utf-8'）。
   這個屬性是可寫的，你能夠修改它來修改訪問表單數據使用的編碼。
   接下來對屬性的任何訪問（例如從 GET 或 POST 中讀取數據）將使用新的 encoding 值。
   若是你知道表單數據的編碼不是 DEFAULT_CHARSET ，則使用它。
5.HttpRequest.GET 
　　一個相似於字典的對象，包含 HTTP GET 的全部參數。詳情請參考 QueryDict 對象。
6.HttpRequest.POST
　　一個相似於字典的對象，若是請求中包含表單數據，則將這些數據封裝成 QueryDict 對象。
　　POST 請求能夠帶有空的 POST 字典 —— 若是經過 HTTP POST 方法發送一個表單，可是表單中沒有任何的數據，QueryDict 對象依然會被建立。
   所以，不該該使用 if request.POST  來檢查使用的是不是POST 方法；應該使用 if request.method == "POST" 
　　另外：若是使用 POST 上傳文件的話，文件信息將包含在 FILES 屬性中。
 7.HttpRequest.COOKIES
　　一個標準的Python 字典，包含全部的cookie。鍵和值都爲字符串。
8.HttpRequest.FILES
　　一個相似於字典的對象，包含全部的上傳文件信息。
   FILES 中的每一個鍵爲<input type="file" name="" /> 中的name，值則爲對應的數據。

　　注意，FILES 只有在請求的方法爲POST 且提交的<form> 帶有enctype="multipart/form-data" 的狀況下才會
   包含數據。不然，FILES 將爲一個空的相似於字典的對象。
9.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 鍵。
10.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。
11.HttpRequest.session
 　　一個既可讀又可寫的相似於字典的對象，表示當前的會話。只有當Django 啓用會話的支持時纔可用。
    完整的細節參見會話的文檔。

上傳文件示例

def upload(request):
    """
    保存上傳文件前，數據須要存放在某個位置。默認當上傳文件小於2.5M時，django會將上傳文件的所有內容讀進內存。從內存讀取一次，寫磁盤一次。
    但當上傳文件很大時，django會把上傳文件寫到臨時文件中，而後存放到系統臨時文件夾中。
    :param request: 
    :return: 
    """
    if request.method == "POST":
        # 從請求的FILES中獲取上傳文件的文件名，file爲頁面上type=files類型input的name屬性值
        filename = request.FILES["file"].name
        # 在項目目錄下新建一個文件
        with open(filename, "wb") as f:
            # 從上傳的文件對象中一點一點讀
            for chunk in request.FILES["file"].chunks():
                # 寫入本地文件
                f.write(chunk)
        return HttpResponse("上傳OK")

方法

1.HttpRequest.get_host()
　　根據從HTTP_X_FORWARDED_HOST（若是打開 USE_X_FORWARDED_HOST，默認爲False）和 HTTP_HOST 頭部信息返回請求的原始主機。
   若是這兩個頭部沒有提供相應的值，則使用SERVER_NAME 和SERVER_PORT，在PEP 3333 中有詳細描述。
　　USE_X_FORWARDED_HOST：一個布爾值，用於指定是否優先使用 X-Forwarded-Host 首部，僅在代理設置了該首部的狀況下，才能夠被使用。
　　例如："127.0.0.1:8000"
　　注意：當主機位於多個代理後面時，get_host() 方法將會失敗。除非使用中間件重寫代理的首部。
2.HttpRequest.get_full_path()
　　返回 path，若是能夠將加上查詢字符串。
　　例如："/music/bands/the_beatles/?print=true"
3.HttpRequest.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
　　返回簽名過的Cookie 對應的值，若是簽名再也不合法則返回django.core.signing.BadSignature。
　　若是提供 default 參數，將不會引起異常並返回 default 的值。
　　可選參數salt 能夠用來對安全密鑰強力攻擊提供額外的保護。max_age 參數用於檢查Cookie 對應的時間戳以確保Cookie 的時間不會超過max_age 秒。
        >>> request.get_signed_cookie('name')
        'Tony'
        >>> request.get_signed_cookie('name', salt='name-salt')
        'Tony' # 假設在設置cookie的時候使用的是相同的salt
        >>> request.get_signed_cookie('non-existing-cookie')
        ...
        KeyError: 'non-existing-cookie'    # 沒有相應的鍵時觸發異常
        >>> request.get_signed_cookie('non-existing-cookie', False)
        False
        >>> request.get_signed_cookie('cookie-that-was-tampered-with')
        ...
        BadSignature: ...    
        >>> request.get_signed_cookie('name', max_age=60)
        ...
        SignatureExpired: Signature age 1677.3839159 > 60 seconds
        >>> request.get_signed_cookie('name', False, max_age=60)
        False
4.HttpRequest.is_secure()
　　若是請求時是安全的，則返回True；即請求通是過 HTTPS 發起的。
5.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') 裝飾你的視圖以讓響應可以正確地緩存。

按照下面的方式打印一下看看：

from django.shortcuts import render,HttpResponse,redirect
# Create your views here.
def index(request):
    print(request.method) #請求方式
    print(request.path)   #請求路徑，不帶參數的
    print(request.POST)   #post請求數據  字典格式
    print(request.GET)    #get的請求數據  字典格式
    print(request.META)   #請求頭信息,未來用到哪一個我們再說哪一個
    print(request.get_full_path())   #獲取請求路徑帶參數的，/index/?a=1
    print(request.is_ajax())   #判斷是否是ajax發送的請求，True和False
    '''
        Django必定最後會響應一個HttpResponse的示例對象
        三種形式：
HttpResponse('字符串') 最簡單
render(頁面)   最重要
                2.1 兩個功能
                    -- 讀取文件字符串
                    -- 嵌入變量(模板渲染) html裏面：{{ name }} ， {'name':'chao'}做爲render的第三個參數，想寫多個變量{'name':'chao','hobby':['籃球','羽毛球']....}
redirect() 重定向  最難理解,某個網站搬家了，網址變了，訪問原來的網址就重定向到一個新網址，就叫作重定向，網站本身作的重定向，你訪問仍是訪問的你以前的，你本身啥也不用作，瀏覽器發送請求，而後服務端響應，而後服務端告訴瀏覽器，你直接跳轉到另一個網址上，那麼瀏覽器又自動發送了另一個請求，發送到服務端，服務端返回一個頁面，包含兩次請求，登錄成功後跳轉到網站的首頁，網站首頁的網址和你login登錄頁面的網址是不用的。          
    '''
    return render(request,'index.html',{'name':'chao'})
    # return HttpResponse('ok')

　注意：鍵值對的值是多個的時候,好比checkbox類型的input標籤，select標籤，須要用：

request.POST.getlist("hobby")

六 response對象

　　與由Django自動建立的HttpRequest對象相比，HttpResponse對象是咱們的職責範圍了。咱們寫的每一個視圖都須要實例化，填充和返回一個HttpResponse。

　　HttpResponse類位於django.http模塊中。

　　使用

　　　　傳遞字符串

from django.http import HttpResponse
response = HttpResponse("Here's the text of the Web page.")
response = HttpResponse("Text only, please.", content_type="text/plain")

　　　　設置或刪除響應頭信息

response = HttpResponse()
response['Content-Type'] = 'text/html; charset=UTF-8'
del response['Content-Type']

　　屬性

　　　　HttpResponse.content：響應內容

　　　　HttpResponse.charset：響應內容的編碼

　　　　HttpResponse.status_code：響應的狀態碼

6.1JsonResponse對象

JsonResponse是HttpResponse的子類，專門用來生成JSON編碼的響應。

from django.http import JsonResponse
response = JsonResponse({'foo': 'bar'})
print(response.content)
b'{"foo": "bar"}'

　　class JsonResponse(data, encoder=DjangoJSONEncoder, safe=True, json_dumps_params=None,**kwargs)

這個類是HttpRespon的子類，它主要和父類的區別在於：

它的默認Content-Type 被設置爲： application/json
第一個參數，data應該是一個字典類型，當 safe 這個參數被設置爲：False ,那data能夠填入任何能被轉換爲JSON格式的對象，好比list, tuple, set。默認的safe 參數是 True. 若是你傳入的data數據類型不是字典類型，那麼它就會拋出 TypeError的異常。
json_dumps_params參數是一個字典,它將調用json.dumps()方法並將字典中的參數傳入給該方法。

#若是這樣返回，ajax還須要進行json解析
#views.py
return HttpResponse(json.dumps({"msg":"ok!"}))
#index.html
var data=json.parse(data)
console.log(data.msg);

使用HttpResponse對象來響應數據的時候，還能夠經過content_type指定格式：

return HttpResponse(json.dumps(data),content_type="application/json")

前端調試窗口就能夠看到這個類型

若是不寫這個參數是這個類型：長得像json格式的字符串，固然也能夠轉換成json的

看下面這種，JsonResponse默認就是content_type="application/json"。

#若是這樣返回，兩邊都不須要進行json的序列化與反序列化，ajax接受的直接是一個對象
#views.py
from django.http import JsonResponse
return JsonResponse({"msg":"ok!"})
#index.html
console.log(data.msg);

默認只能傳遞字典類型，若是要傳遞非字典類型須要設置一下safe關鍵字參數。

response = JsonResponse([1, 2, 3], safe=False)

響應對象主要有三種形式：

HttpResponse()
render()
redirect()

　　HttpResponse()括號內直接跟一個具體的字符串做爲響應體，比較直接很簡單，因此這裏主要介紹後面兩種形式。

Django shortcut functions

　　　　render()　　　

　　　　　　結合一個給定的模板和一個給定的上下文字典，並返回一個渲染後的 HttpResponse 對象。

參數：

request：用於生成響應的請求對象。
template_name：要使用的模板的完整名稱，可選的參數
context：添加到模板上下文的一個字典。默認是一個空字典。若是字典中的某個值是可調用的，視圖將在渲染模板以前調用它。
content_type：生成的文檔要使用的MIME類型。默認爲 DEFAULT_CONTENT_TYPE 設置的值。默認爲'text/html'
status：響應的狀態碼。默認爲200。　　　　　　　　useing: 用於加載模板的模板引擎的名稱。

一個簡單的例子：

from django.shortcuts import render
def my_view(request):
    # 視圖的代碼寫在這裏
    return render(request, 'myapp/index.html', {'foo': 'bar'})

上面的代碼等於（瞭解）：

from django.http import HttpResponse
from django.template import loader

def my_view(request):
    # 視圖代碼寫在這裏
    t = loader.get_template('myapp/index.html')
    c = {'foo': 'bar'}
    return HttpResponse(t.render(c, request))

redirect() ：給瀏覽器了一個30x的狀態碼

參數能夠是：

一個模型：將調用模型的get_absolute_url() 函數
一個視圖，能夠帶有參數：將使用urlresolvers.reverse 來反向解析名稱
一個絕對的或相對的URL，將原封不動的做爲重定向的位置。

默認返回一個臨時的重定向；傳遞permanent=True 能夠返回一個永久的重定向。

示例:

你能夠用多種方式使用redirect() 函數。

傳遞一個具體的ORM對象（瞭解便可）

將調用具體ORM對象的get_absolute_url() 方法來獲取重定向的URL：

from django.shortcuts import redirect
def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object)

傳遞一個視圖的名稱

def my_view(request):
    ...
    return redirect('some-view-name', foo='bar')

傳遞要重定向到的一個具體的網址

def my_view(request):
    ...
    return redirect('/some/url/')

看一個例子index.html文件，內容以下　　　

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div>這是index頁面</div>
<h1>{{ name }}</h1>

</body>
</html>

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

<div>
    <form action="{% url 'xxx' %}" method="post">
        用戶名：<input type="text" name="username">
        密碼：<input type="password" name="password">
        <input type="submit">
    </form>

</div>

</body>
</html>

urls.py裏面的內容：

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    # url(r'^admin/', admin.site.urls),
    url(r'^index/', views.index),
    url(r'^login/', views.login,name='xxx'),
]

views.py視圖函數裏面的內容

from django.shortcuts import render,HttpResponse,redirect
# Create your views here.
def index(request):
    return render(request,'index.html',{'name':'chao'})
def login(request):
    method = request.method
    if method == 'GET':
        return render(request,'login.html')
    else:
        username = request.POST.get('username')
        password = request.POST.get('password')
        if username == 'chao' and password == '123':
            return redirect('/index/') #重定向到/index/路徑，這也是發送了一個請求，別忘了在上面引入這個redirect類，和render、Httpresponse在一個地方引入
            # return HttpResponse('success')
        else:
            return HttpResponse('失敗')

上面幾個文件搞好以後，咱們重啓Django項目，而後登錄頁面的輸入網址，注意，你輸入的網址端口要和你啓動的django項目的端口同樣。

一點擊提交按鈕，你看一下network裏面發送了幾個請求：兩個請求，一個是login請求，一個index請求。　　

若是沒有作重定向，那麼你登錄完以後，還須要本身去輸入首頁的地址去訪問網站首頁，你說對不對。

可是若是咱們在函數裏面寫的render來返回內容，二者有什麼不一樣呢？

from django.shortcuts import render,HttpResponse,redirect
# Create your views here.
def index(request):
    return render(request,'index.html',{'name':'chao'})
def login(request):
    method = request.method
    if method == 'GET':
        return render(request,'login.html')
    else:
        username = request.POST.get('username')
        password = request.POST.get('password')
        if username == 'chao' and password == '123':
            return redirect('/index/') #重定向到/index/路徑，這也是發送了一個請求，別忘了在上面引入這個redirect類，和render、Httpresponse在一個地方引入
            # return render(request,'index.html')#若是直接用render來返回頁面，是一次響應就返回了頁面，二者是有區別的，而且若是你用render返回index.html頁面，那麼這個頁面裏面的模板渲染語言裏面須要的數據你怎麼搞，若是這些數據就是人家index那個函數裏面獨有的呢，你怎麼搞，有人可能就響了，我把全部的數據都拿過來不就好了嗎，首先若是數據量很大的話，是否是都重複了，而且你想一想若是用戶登錄完成以後，大家有進行跳轉，那麼若是網速不太好，卡一下，你想刷新一下你的頁面，你是否是至關於又發送了一個login請求，你刷新完以後，是否是還要讓你輸入用戶名和密碼，你想一想是否是，全部我們通常在登錄以後都作跳轉。
            # 而且你們注意一個問題昂：redirect('/login/')若是你重定向到你當前這個函數對應的路徑下，你想一想是什麼想過，一直重定向本身的這個網址，瀏覽器會報錯，固然這個註冊登錄頁面不會出現這個報錯的狀況，由於須要你用戶點擊提交才發送請求。你能夠試試那個index函數，裏面返回一個redirect('/index/')
            #redirect本質上也是一個HttpResponse的操做，看看源碼就知道了
            # return HttpResponse('success')
        else:
            return HttpResponse('失敗')

固然也能夠是一個完整的網址

def my_view(request):
    ...
    return redirect('http://example.com/')

默認狀況下，redirect() 返回一個臨時重定向。以上全部的形式都接收一個permanent 參數；若是設置爲True，將返回一個永久的重定向：

def my_view(request):
    ...
    object = MyModel.objects.get(...) #學了orm以後再看吧
    return redirect(object, permanent=True)

擴展閱讀： key兩次請求，關於301和302：　　　　　

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頁面錯誤信息，訪問流量白白喪失；再者某些註冊了多個域名的
    網站，也須要經過重定向讓訪問這些域名的用戶自動跳轉到主站點等。

臨時重定向（響應狀態碼：302）和永久重定向（響應狀態碼：301）對普通用戶來講是沒什麼區別的，它主要面向的是搜索引擎的機器人。

A頁面臨時重定向到B頁面，那搜索引擎收錄的就是A頁面。

A頁面永久重定向到B頁面，那搜索引擎收錄的就是B頁面。

用redirect能夠解釋APPEND_SLASH的用法！這個不講~~