Django之视图

 

Django的View（视图）

一个视图函数（类），简称视图，是一个简单的Python 函数（类），它接受Web请求并且返回Web响应。

响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片。

无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你当前项目目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了将代码放在某处，大家约定成俗将视图放置在项目（project）或应用程序（app）目录中的名为views.py的文件中。

一个简单的视图

下面是一个以HTML文档的形式返回当前日期和时间的视图：
  1. from django.http import HttpResponse
  2. import datetime
  3.  
  4. def current_datetime(request):
  5.     now = datetime.datetime.now()
  6.     html = "<html><body>It is now %s.</body></html>" % now
  7.     return HttpResponse(html)

让我们来逐行解释下上面的代码：

  • 首先，我们从 django.http模块导入了HttpResponse类，以及Python的datetime库。

  • 接着，我们定义了current_datetime函数。它就是视图函数。每个视图函数都使用HttpRequest对象作为第一个参数，并且通常称之为request。

    注意，视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它。我们将其命名为current_datetime，是因为这个名称能够比较准确地反映出它实现的功能。

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

Django使用请求和响应对象来通过系统传递状态。

当浏览器向服务端请求一个页面时，Django创建一个HttpRequest对象，该对象包含关于请求的元数据。然后，Django加载相应的视图，将这个HttpRequest对象作为第一个参数传递给视图函数。

每个视图负责返回一个HttpResponse对象。

CBV和FBV

我们之前写过的都是基于函数的view，就叫FBV。还可以把view写成基于类的。

就拿我们之前写过的添加班级为例：

FBV版：

  1. # FBV版添加班级
  2. def add_class(request):
  3.     if request.method == "POST":
  4.         class_name = request.POST.get("class_name")
  5.         models.Classes.objects.create(name=class_name)
  6.         return redirect("/class_list/")
  7.     return render(request, "add_class.html")

CBV版：

  1. # CBV版添加班级
  2. from django.views import View
  3.  
  4. class AddClass(View):
  5.  
  6.     def get(self, request):
  7.         return render(request, "add_class.html")
  8.  
  9.     def post(self, request):
  10.         class_name = request.POST.get("class_name")
  11.         models.Classes.objects.create(name=class_name)
  12.         return redirect("/class_list/")

注意：

使用CBV时，urls.py中也做对应的修改：

  1. # urls.py中
  2. url(r'^add_class/$', views.AddClass.as_view()),

给视图加装饰器

使用装饰器装饰FBV

FBV本身就是一个函数，所以和给普通的函数加装饰器无差：

  1. def wrapper(func):
  2.     def inner(*args, **kwargs):
  3.         start_time = time.time()
  4.         ret = func(*args, **kwargs)
  5.         end_time = time.time()
  6.         print("used:", end_time-start_time)
  7.         return ret
  8.     return inner
  9.  
  10. # FBV版添加班级
  11. @wrapper
  12. def add_class(request):
  13.     if request.method == "POST":
  14.         class_name = request.POST.get("class_name")
  15.         models.Classes.objects.create(name=class_name)
  16.         return redirect("/class_list/")
  17.     return render(request, "add_class.html")

使用装饰器装饰CBV

类中的方法与独立函数不完全相同，因此不能直接将函数装饰器应用于类中的方法 ，我们需要先将其转换为方法装饰器。

Django中提供了method_decorator装饰器用于将函数装饰器转换为方法装饰器。

  1. # CBV版添加班级
  2. from django.views import View
  3. from django.utils.decorators import method_decorator
  4.  
  5. class AddClass(View):
  6.  
  7.     @method_decorator(wrapper)
  8.     def get(self, request):
  9.         return render(request, "add_class.html")
  10.  
  11.     def post(self, request):
  12.         class_name = request.POST.get("class_name")
  13.         models.Classes.objects.create(name=class_name)
  14.         return redirect("/class_list/")
 关于CBV的扩展阅读

Request对象和Response对象

request对象

当一个页面被请求时，Django就会创建一个包含本次请求原信息的HttpRequest对象。
Django会将这个对象自动传递给响应的视图函数，一般视图函数约定俗成地使用 request 参数承接这个对象。

官方文档

请求相关的常用值

  • path_info     返回用户访问url，不包括域名
  • method        请求中使用的HTTP方法的字符串表示，全大写表示。
  • GET              包含所有HTTP  GET参数的类字典对象
  • POST           包含所有HTTP POST参数的类字典对象
  • body            请求体，byte类型 request.POST的数据就是从body里面提取到的

属性

所有的属性应该被认为是只读的，除非另有说明。

  1. Django之视图
  2. Django的View（视图）
  3. 一个视图函数（类），简称视图，是一个简单的Python 函数（类），它接受Web请求并且返回Web响应。
  4.  
  5. 响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片。
  6.  
  7. 无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你当前项目目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了将代码放在某处，大家约定成俗将视图放置在项目（project）或应用程序（app）目录中的名为views.py的文件中。
  8.  
  9. 一个简单的视图
  10. 下面是一个以HTML文档的形式返回当前日期和时间的视图：
  11. 复制代码
  12. from django.http import HttpResponse
  13. import datetime
  14.  
  15. def current_datetime(request):
  16.     now = datetime.datetime.now()
  17.     html = "<html><body>It is now %s.</body></html>" % now
  18.     return HttpResponse(html)
  19. 复制代码
  20. 让我们来逐行解释下上面的代码：
  21.  
  22. 首先，我们从 django.http模块导入了HttpResponse类，以及Python的datetime库。
  23.  
  24. 接着，我们定义了current_datetime函数。它就是视图函数。每个视图函数都使用HttpRequest对象作为第一个参数，并且通常称之为request。
  25.  
  26. 注意，视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它。我们将其命名为current_datetime，是因为这个名称能够比较准确地反映出它实现的功能。
  27.  
  28. 这个视图会返回一个HttpResponse对象，其中包含生成的响应。每个视图函数都负责返回一个HttpResponse对象。
  29.  
  30. Django使用请求和响应对象来通过系统传递状态。
  31.  
  32. 当浏览器向服务端请求一个页面时，Django创建一个HttpRequest对象，该对象包含关于请求的元数据。然后，Django加载相应的视图，将这个HttpRequest对象作为第一个参数传递给视图函数。
  33.  
  34. 每个视图负责返回一个HttpResponse对象。
  35.  
  36. CBV和FBV
  37. 我们之前写过的都是基于函数的view，就叫FBV。还可以把view写成基于类的。
  38.  
  39. 就拿我们之前写过的添加班级为例：
  40.  
  41. FBV版：
  42. 复制代码
  43. # FBV版添加班级
  44. def add_class(request):
  45.     if request.method == "POST":
  46.         class_name = request.POST.get("class_name")
  47.         models.Classes.objects.create(name=class_name)
  48.         return redirect("/class_list/")
  49.     return render(request, "add_class.html")
  50. 复制代码
  51. CBV版：
  52. 复制代码
  53. # CBV版添加班级
  54. from django.views import View
  55.  
  56. class AddClass(View):
  57.  
  58.     def get(self, request):
  59.         return render(request, "add_class.html")
  60.  
  61.     def post(self, request):
  62.         class_name = request.POST.get("class_name")
  63.         models.Classes.objects.create(name=class_name)
  64.         return redirect("/class_list/")
  65. 复制代码
  66. 注意：
  67.  
  68. 使用CBV时，urls.py中也做对应的修改：
  69.  
  70. # urls.py中
  71. url(r'^add_class/$', views.AddClass.as_view()),
  72. 给视图加装饰器
  73. 使用装饰器装饰FBV
  74. FBV本身就是一个函数，所以和给普通的函数加装饰器无差：
  75.  
  76. 复制代码
  77. def wrapper(func):
  78.     def inner(*args, **kwargs):
  79.         start_time = time.time()
  80.         ret = func(*args, **kwargs)
  81.         end_time = time.time()
  82.         print("used:", end_time-start_time)
  83.         return ret
  84.     return inner
  85.  
  86. # FBV版添加班级
  87. @wrapper
  88. def add_class(request):
  89.     if request.method == "POST":
  90.         class_name = request.POST.get("class_name")
  91.         models.Classes.objects.create(name=class_name)
  92.         return redirect("/class_list/")
  93.     return render(request, "add_class.html")
  94. 复制代码
  95. 使用装饰器装饰CBV
  96. 类中的方法与独立函数不完全相同，因此不能直接将函数装饰器应用于类中的方法 ，我们需要先将其转换为方法装饰器。
  97.  
  98. Django中提供了method_decorator装饰器用于将函数装饰器转换为方法装饰器。
  99.  
  100. 复制代码
  101. # CBV版添加班级
  102. from django.views import View
  103. from django.utils.decorators import method_decorator
  104.  
  105. class AddClass(View):
  106.  
  107.     @method_decorator(wrapper)
  108.     def get(self, request):
  109.         return render(request, "add_class.html")
  110.  
  111.     def post(self, request):
  112.         class_name = request.POST.get("class_name")
  113.         models.Classes.objects.create(name=class_name)
  114.         return redirect("/class_list/")
  115. 复制代码
  116.  关于CBV的扩展阅读
  117. Request对象和Response对象
  118. request对象
  119. 当一个页面被请求时，Django就会创建一个包含本次请求原信息的HttpRequest对象。
  120. Django会将这个对象自动传递给响应的视图函数，一般视图函数约定俗成地使用 request 参数承接这个对象。
  121.  
  122. 官方文档
  123.  
  124. 请求相关的常用值
  125. path_info     返回用户访问url，不包括域名
  126. method        请求中使用的HTTP方法的字符串表示，全大写表示。
  127. GET              包含所有HTTP  GET参数的类字典对象
  128. POST           包含所有HTTP POST参数的类字典对象
  129. body            请求体，byte类型 request.POST的数据就是从body里面提取到的
  130. 属性
  131. 所有的属性应该被认为是只读的，除非另有说明。

request属性相关

  1. Django之视图
  2. Django的View（视图）
  3. 一个视图函数（类），简称视图，是一个简单的Python 函数（类），它接受Web请求并且返回Web响应。
  4.  
  5. 响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片。
  6.  
  7. 无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你当前项目目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了将代码放在某处，大家约定成俗将视图放置在项目（project）或应用程序（app）目录中的名为views.py的文件中。
  8.  
  9. 一个简单的视图
  10. 下面是一个以HTML文档的形式返回当前日期和时间的视图：
  11. 复制代码
  12. from django.http import HttpResponse
  13. import datetime
  14.  
  15. def current_datetime(request):
  16.     now = datetime.datetime.now()
  17.     html = "<html><body>It is now %s.</body></html>" % now
  18.     return HttpResponse(html)
  19. 复制代码
  20. 让我们来逐行解释下上面的代码：
  21.  
  22. 首先，我们从 django.http模块导入了HttpResponse类，以及Python的datetime库。
  23.  
  24. 接着，我们定义了current_datetime函数。它就是视图函数。每个视图函数都使用HttpRequest对象作为第一个参数，并且通常称之为request。
  25.  
  26. 注意，视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它。我们将其命名为current_datetime，是因为这个名称能够比较准确地反映出它实现的功能。
  27.  
  28. 这个视图会返回一个HttpResponse对象，其中包含生成的响应。每个视图函数都负责返回一个HttpResponse对象。
  29.  
  30. Django使用请求和响应对象来通过系统传递状态。
  31.  
  32. 当浏览器向服务端请求一个页面时，Django创建一个HttpRequest对象，该对象包含关于请求的元数据。然后，Django加载相应的视图，将这个HttpRequest对象作为第一个参数传递给视图函数。
  33.  
  34. 每个视图负责返回一个HttpResponse对象。
  35.  
  36. CBV和FBV
  37. 我们之前写过的都是基于函数的view，就叫FBV。还可以把view写成基于类的。
  38.  
  39. 就拿我们之前写过的添加班级为例：
  40.  
  41. FBV版：
  42. 复制代码
  43. # FBV版添加班级
  44. def add_class(request):
  45.     if request.method == "POST":
  46.         class_name = request.POST.get("class_name")
  47.         models.Classes.objects.create(name=class_name)
  48.         return redirect("/class_list/")
  49.     return render(request, "add_class.html")
  50. 复制代码
  51. CBV版：
  52. 复制代码
  53. # CBV版添加班级
  54. from django.views import View
  55.  
  56. class AddClass(View):
  57.  
  58.     def get(self, request):
  59.         return render(request, "add_class.html")
  60.  
  61.     def post(self, request):
  62.         class_name = request.POST.get("class_name")
  63.         models.Classes.objects.create(name=class_name)
  64.         return redirect("/class_list/")
  65. 复制代码
  66. 注意：
  67.  
  68. 使用CBV时，urls.py中也做对应的修改：
  69.  
  70. # urls.py中
  71. url(r'^add_class/$', views.AddClass.as_view()),
  72. 给视图加装饰器
  73. 使用装饰器装饰FBV
  74. FBV本身就是一个函数，所以和给普通的函数加装饰器无差：
  75.  
  76. 复制代码
  77. def wrapper(func):
  78.     def inner(*args, **kwargs):
  79.         start_time = time.time()
  80.         ret = func(*args, **kwargs)
  81.         end_time = time.time()
  82.         print("used:", end_time-start_time)
  83.         return ret
  84.     return inner
  85.  
  86. # FBV版添加班级
  87. @wrapper
  88. def add_class(request):
  89.     if request.method == "POST":
  90.         class_name = request.POST.get("class_name")
  91.         models.Classes.objects.create(name=class_name)
  92.         return redirect("/class_list/")
  93.     return render(request, "add_class.html")
  94. 复制代码
  95. 使用装饰器装饰CBV
  96. 类中的方法与独立函数不完全相同，因此不能直接将函数装饰器应用于类中的方法 ，我们需要先将其转换为方法装饰器。
  97.  
  98. Django中提供了method_decorator装饰器用于将函数装饰器转换为方法装饰器。
  99.  
  100. 复制代码
  101. # CBV版添加班级
  102. from django.views import View
  103. from django.utils.decorators import method_decorator
  104.  
  105. class AddClass(View):
  106.  
  107.     @method_decorator(wrapper)
  108.     def get(self, request):
  109.         return render(request, "add_class.html")
  110.  
  111.     def post(self, request):
  112.         class_name = request.POST.get("class_name")
  113.         models.Classes.objects.create(name=class_name)
  114.         return redirect("/class_list/")
  115. 复制代码
  116.  关于CBV的扩展阅读
  117. Request对象和Response对象
  118. request对象
  119. 当一个页面被请求时，Django就会创建一个包含本次请求原信息的HttpRequest对象。
  120. Django会将这个对象自动传递给响应的视图函数，一般视图函数约定俗成地使用 request 参数承接这个对象。
  121.  
  122. 官方文档
  123.  
  124. 请求相关的常用值
  125. path_info     返回用户访问url，不包括域名
  126. method        请求中使用的HTTP方法的字符串表示，全大写表示。
  127. GET              包含所有HTTP  GET参数的类字典对象
  128. POST           包含所有HTTP POST参数的类字典对象
  129. body            请求体，byte类型 request.POST的数据就是从body里面提取到的
  130. 属性
  131. 所有的属性应该被认为是只读的，除非另有说明。

上传文件示例

方法

  1. Django之视图
  2. Django的View（视图）
  3. 一个视图函数（类），简称视图，是一个简单的Python 函数（类），它接受Web请求并且返回Web响应。
  4.  
  5. 响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片。
  6.  
  7. 无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你当前项目目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了将代码放在某处，大家约定成俗将视图放置在项目（project）或应用程序（app）目录中的名为views.py的文件中。
  8.  
  9. 一个简单的视图
  10. 下面是一个以HTML文档的形式返回当前日期和时间的视图：
  11. 复制代码
  12. from django.http import HttpResponse
  13. import datetime
  14.  
  15. def current_datetime(request):
  16.     now = datetime.datetime.now()
  17.     html = "<html><body>It is now %s.</body></html>" % now
  18.     return HttpResponse(html)
  19. 复制代码
  20. 让我们来逐行解释下上面的代码：
  21.  
  22. 首先，我们从 django.http模块导入了HttpResponse类，以及Python的datetime库。
  23.  
  24. 接着，我们定义了current_datetime函数。它就是视图函数。每个视图函数都使用HttpRequest对象作为第一个参数，并且通常称之为request。
  25.  
  26. 注意，视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它。我们将其命名为current_datetime，是因为这个名称能够比较准确地反映出它实现的功能。
  27.  
  28. 这个视图会返回一个HttpResponse对象，其中包含生成的响应。每个视图函数都负责返回一个HttpResponse对象。
  29.  
  30. Django使用请求和响应对象来通过系统传递状态。
  31.  
  32. 当浏览器向服务端请求一个页面时，Django创建一个HttpRequest对象，该对象包含关于请求的元数据。然后，Django加载相应的视图，将这个HttpRequest对象作为第一个参数传递给视图函数。
  33.  
  34. 每个视图负责返回一个HttpResponse对象。
  35.  
  36. CBV和FBV
  37. 我们之前写过的都是基于函数的view，就叫FBV。还可以把view写成基于类的。
  38.  
  39. 就拿我们之前写过的添加班级为例：
  40.  
  41. FBV版：
  42. 复制代码
  43. # FBV版添加班级
  44. def add_class(request):
  45.     if request.method == "POST":
  46.         class_name = request.POST.get("class_name")
  47.         models.Classes.objects.create(name=class_name)
  48.         return redirect("/class_list/")
  49.     return render(request, "add_class.html")
  50. 复制代码
  51. CBV版：
  52. 复制代码
  53. # CBV版添加班级
  54. from django.views import View
  55.  
  56. class AddClass(View):
  57.  
  58.     def get(self, request):
  59.         return render(request, "add_class.html")
  60.  
  61.     def post(self, request):
  62.         class_name = request.POST.get("class_name")
  63.         models.Classes.objects.create(name=class_name)
  64.         return redirect("/class_list/")
  65. 复制代码
  66. 注意：
  67.  
  68. 使用CBV时，urls.py中也做对应的修改：
  69.  
  70. # urls.py中
  71. url(r'^add_class/$', views.AddClass.as_view()),
  72. 给视图加装饰器
  73. 使用装饰器装饰FBV
  74. FBV本身就是一个函数，所以和给普通的函数加装饰器无差：
  75.  
  76. 复制代码
  77. def wrapper(func):
  78.     def inner(*args, **kwargs):
  79.         start_time = time.time()
  80.         ret = func(*args, **kwargs)
  81.         end_time = time.time()
  82.         print("used:", end_time-start_time)
  83.         return ret
  84.     return inner
  85.  
  86. # FBV版添加班级
  87. @wrapper
  88. def add_class(request):
  89.     if request.method == "POST":
  90.         class_name = request.POST.get("class_name")
  91.         models.Classes.objects.create(name=class_name)
  92.         return redirect("/class_list/")
  93.     return render(request, "add_class.html")
  94. 复制代码
  95. 使用装饰器装饰CBV
  96. 类中的方法与独立函数不完全相同，因此不能直接将函数装饰器应用于类中的方法 ，我们需要先将其转换为方法装饰器。
  97.  
  98. Django中提供了method_decorator装饰器用于将函数装饰器转换为方法装饰器。
  99.  
  100. 复制代码
  101. # CBV版添加班级
  102. from django.views import View
  103. from django.utils.decorators import method_decorator
  104.  
  105. class AddClass(View):
  106.  
  107.     @method_decorator(wrapper)
  108.     def get(self, request):
  109.         return render(request, "add_class.html")
  110.  
  111.     def post(self, request):
  112.         class_name = request.POST.get("class_name")
  113.         models.Classes.objects.create(name=class_name)
  114.         return redirect("/class_list/")
  115. 复制代码
  116.  关于CBV的扩展阅读
  117. Request对象和Response对象
  118. request对象
  119. 当一个页面被请求时，Django就会创建一个包含本次请求原信息的HttpRequest对象。
  120. Django会将这个对象自动传递给响应的视图函数，一般视图函数约定俗成地使用 request 参数承接这个对象。
  121.  
  122. 官方文档
  123.  
  124. 请求相关的常用值
  125. path_info     返回用户访问url，不包括域名
  126. method        请求中使用的HTTP方法的字符串表示，全大写表示。
  127. GET              包含所有HTTP  GET参数的类字典对象
  128. POST           包含所有HTTP POST参数的类字典对象
  129. body            请求体，byte类型 request.POST的数据就是从body里面提取到的
  130. 属性
  131. 所有的属性应该被认为是只读的，除非另有说明。

注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：

  1. request.POST.getlist("hobby")

Response对象

与由Django自动创建的HttpRequest对象相比，HttpResponse对象是我们的职责范围了。我们写的每个视图都需要实例化，填充和返回一个HttpResponse。

HttpResponse类位于django.http模块中。

使用

传递字符串

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

设置或删除响应头信息

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

属性

HttpResponse.content：响应内容

HttpResponse.charset：响应内容的编码

HttpResponse.status_code：响应的状态码

JsonResponse对象

JsonResponse是HttpResponse的子类，专门用来生成JSON编码的响应。

  1. from django.http import JsonResponse
  2.  
  3. response = JsonResponse({'foo': 'bar'})
  4. print(response.content)
  5.  
  6. b'{"foo": "bar"}'

默认只能传递字典类型，如果要传递非字典类型需要设置一下safe关键字参数。

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

Django shortcut functions

官方文档

render()

结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。

  1. 参数：
  2.      request： 用于生成响应的请求对象。
  3.  
  4.      template_name：要使用的模板的完整名称，可选的参数
  5.  
  6.      context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。
  7.  
  8.      content_type：生成的文档要使用的MIME类型。默认为 DEFAULT_CONTENT_TYPE 设置的值。默认为'text/html'
  9.  
  10.      status：响应的状态码。默认为200。
  11.  
  12. 　　　useing: 用于加载模板的模板引擎的名称。
  13.  
  14. 一个简单的例子：
  1. from django.shortcuts import render
  2.  
  3. def my_view(request):
  4.     # 视图的代码写在这里
  5.     return render(request, 'myapp/index.html', {'foo': 'bar'})

上面的代码等于：

  1. from django.http import HttpResponse
  2. from django.template import loader
  3.  
  4. def my_view(request):
  5.     # 视图代码写在这里
  6.     t = loader.get_template('myapp/index.html')
  7.     c = {'foo': 'bar'}
  8.     return HttpResponse(t.render(c, request))

redirect()

参数可以是：

  • 一个模型：将调用模型的get_absolute_url() 函数
  • 一个视图，可以带有参数：将使用urlresolvers.reverse 来反向解析名称
  • 一个绝对的或相对的URL，将原封不动的作为重定向的位置。

默认返回一个临时的重定向；传递permanent=True 可以返回一个永久的重定向。

示例:

你可以用多种方式使用redirect() 函数。

传递一个具体的ORM对象（了解即可）

将调用具体ORM对象的get_absolute_url() 方法来获取重定向的URL：

  1. from django.shortcuts import redirect
  2.  
  3. def my_view(request):
  4.     ...
  5.     object = MyModel.objects.get(...)
  6.     return redirect(object)

传递一个视图的名称

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

传递要重定向到的一个具体的网址

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

当然也可以是一个完整的网址

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

默认情况下，redirect() 返回一个临时重定向。以上所有的形式都接收一个permanent 参数；如果设置为True，将返回一个永久的重定向：

  1. def my_view(request):
  2.     ...
  3.     object = MyModel.objects.get(...)
  4.     return redirect(object, permanent=True)　　

扩展阅读：

临时重定向（响应状态码：302）和永久重定向（响应状态码：301）对普通用户来说是没什么区别的，它主要面向的是搜索引擎的机器人。

A页面临时重定向到B页面，那搜索引擎收录的就是A页面。

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

Django之视图的更多相关文章

  1. 【Django】 视图层说明

    [Django视图层] 视图层的主要工作是衔接HTTP请求,Python程序和HTML模板,使他们能够有机互相合作从模型层lou到数据并且反馈.说到视图层的工作就有以下几个方面要说 ■ URL映射 对 ...

  2. Django基本视图

    Django基本视图 下面这三个类也许不能提供项目所需的所有的功能,这些应用于基于类的视图或Mixins情形下. 大多数Django的内建视图继承于其他基于类的视图或者各种mixins中,因为继承链是 ...

  3. Django通用视图APIView和视图集ViewSet的介绍和使用

    原 Django通用视图APIView和视图集ViewSet的介绍和使用 2018年10月21日 14:42:14 不睡觉假扮古尔丹 阅读数:630   1.APIView DRF框架的视图的基类是 ...

  4. Django之视图函数总结

    Django之视图函数总结 HttpRequest与HttpResponse http请求中产生两个核心对象: HttpRequest对象:用户请求相关的所有信息(对象) HttpResponse对象 ...

  5. Django _VIEW视图_源码分析

    Django _VIEW视图: 1. 点击as_view方法. 第二步: as_view () 为VIEW 类里定义的,到时候我们定义业务逻辑的类就继承这个VIEW类. view方法内返回的是disp ...

  6. Django的视图层简介

    Django的视图层 视图函数 所谓视图函数,其实就是我们Django项目中各个应用中的views.py文件中定义的每个用来处理URL路由映射到这里的逻辑函数.一个视图函数简称视图,它是个简单的Pyt ...

  7. django views视图函数返回值 return redirect httpresponse总结

    django views视图函数返回值 return redirect  render httpresponse总结

  8. Django的视图流式响应机制

    Django的视图流式响应机制 Django的响应类型:一次性响应和流式响应. 一次性响应,顾名思义,将响应内容一次性反馈给用户.HttpResponse类及子类和JsonResponse类属于一次性 ...

  9. Django的视图响应类型

    Django的视图响应类型 一. 视图函数编写原则 视图函数接受HTTP请求并返回响应,可以放在任何地方,可以是任何功能:视图函数可以返回Web文本,页面.重定向.错误.图片等任何内容:视图函数通过H ...

随机推荐

  1. Fish 下报错 Unsupported use of '||'. In fish, please use 'COMMAND; or COMMAND'.

    在用fish激活virualenv虚拟环境时,使用命令: source ./venv/bin/activate 报错 ./venv/bin/activate (line 23): Unsupporte ...

  2. transmission跳过文件校验功能实现

    贴吧链接:https://tieba.baidu.com/p/4839039900 GitHub:https://github.com/superlukia/transmission-2.92_ski ...

  3. zabbix 4.2 支持 timescledb 了

    zabbix 4.2 已经发布了, 添加了好多新功能 支持prometheus 数据收集 支持timescaledb 支持http header 处理 更加友好的邮件通知格式 添加远程监控组件 简化标 ...

  4. Spring BOOT的学习笔记

    1,静态文件夹src/main/resources/static下的,图片必须放在images文件夹下才能访问,直接放在static下不能访问 2,配置热部署,否则修改下Html,图片都得重启 htt ...

  5. 利用类的反射导入excel示例

    直接上代码 1.页面展示 <div class="panel-heading font-bold text-center"> <i class="fa ...

  6. netty原理解析

    netty主要采用的是reactor模式(事件)驱动模型,以下主要对reactor进行总结: C/S架构可以抽象为如下模型: C就是Client(客户端),上面的B是Browser(浏览器) S就是S ...

  7. ELK + Filebeat 日志分析系统

    ELK + Filebeat 日志分析系统 架构图 环境 OS:CentOS 7.4 Filebeat: 6.3.2 Logstash: 6.3.2 Elasticsearch 6.3.2 Kiban ...

  8. 2018-2019-2 20175227张雪莹《Java程序设计》 实验二《Java面向对象程序设计》

    2018-2019-2 20175227张雪莹<Java程序设计> 实验二<Java面向对象程序设计> 实验报告封面 课程:Java程序设计 班级:1752班 姓名:张雪莹 学 ...

  9. UHF RFID，高频RFID开发参考资料

    ISO18000-6C电子标签百科  http://baike.baidu.com/item/ISO18000-6C%E7%94%B5%E5%AD%90%E6%A0%87%E7%AD%BE/80500 ...

  10. 一、新建springBoot项目

    三种方式新建SpringBoot项目:  官网,  myeclipse,  idea 1.官方网站新建(https://start.spring.io/) 1)打开官网,选择自己需要的springBo ...