django基础之Django视图

URL详解

URL是Uniform Resource Loator的缩写, 统一资源定位符

一个URL由以下几部分组成:

secheme://host:port/path/?query-string=xxx#anchor

注意: URL中的所有字符都是ASCII字符集, 如果出现非ASCII字符, 比如中文, 浏览器会进行编码再进行传输

secheme: 代表的是访问的协议, 一般为http或者https以及ftp等
Host: 主机号, 域名, 比如www.baidu.com
Port: 端口号. 当你访问一个网站的时候, 浏览器默认使用80端口
Path: 查看路径, 比如:www.jianshu.com/trending/now, 后面的trebding/now就是path
Query-string: 查询字符串, 比如www.baidu.com/s?wd=python, 后面的wd=python就是查询字符串
anthor: 锚点, 后台一般不用管, 前端用来做页面定位的

视图与URL分发器

视图

视图一般都写在app的views.py中。并且视图的第一个参数永远都是request(一个HttpRequest)对象。这个对象存储了请求过来的所有信息, 包括携带的参数以及一些同步信息等。在视图中, 一般是完成逻辑相关的操作。比如这个请求是添加一篇博客, 那么可以通过request来接收这些数据, 然后存储到数据库中, 最后再把执行的结果返回给浏览器。视图函数的返回结果必须是HttpReponse对象或者子类对象。示例代码如下:

from django.http import Httpresponse

def book_list(request):
    return HttpResponse('书籍列表:')

URL映射

视图写完后, 要与URL进行映射, 也即用户在浏览器输入什么url的时候可以请求到这个视图函数。在用户输入了某个url, 请求到我们的网站的时候, django会从项目的urls.py文件中寻找对应的视图, 在urls.py文件中有一个urlpatterns变量, 以后django就会从这个变量中读取所有的匹配规则。匹配规则需要使用django.urls.path函数进行包裹, 这个函数会根据传入的参数返回URLPattern或者URLResolver的对象。示例代码如下:

from django.contrib import admin
from django.urls import path
from book import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('book/', views.book_list)
]

1. 为什么会去urls.py文件中寻找映射呢？

是因为在settings.py文件中配置了ROOT_URLCONF为urls.py。所有的django会去urls.py中寻找

2. 在urls.py中我们所有的映射, 都应该放在urlpatterns这个变量中

3. 所有的映射都不是随便写的, 而是使用path函数或者re_path函数进行包装的

URL中添加参数

有时候, url中包含了一些参数需要动态调整。比如简书某篇文章的详情页的url, 是https://www.jianshu.com/p/a5aab9c4978e后面的a5aab9c4978e就是这篇文章的id, 那么简书的文章详情页面的url就可以写成https://www.jianshu.com/p/<id>, 其中id就是文章的id, 那么如何在djang中实现这种需求呢。这时候可以在path函数中, 使用尖括号的形式来定义一个参数。比如我现在响应获取一本书籍的详细信息, 那么应该在url中指定这个参数。示例代码如下:

from django.contrib import admin
from django.urls import path
from book import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('book/', views.book_list),
    path('book/<book_id>', views.book_detail)
]

而views.py中的代码如下:

def book_detail(request, book_id):
    text = '您输入的数据的id是:%s'%book_id
    
    return HttpResponse(text)

当然, 也可以通过查询字符串的方式传递一个参数过去, 实例代码如下:

from django.contrib import admin
from django.urls import path
from book import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('book/', views.book_list),
    path('book/<book_id>', views.book_detail)
]

在views.py中的代码如下:

def book_detail(request):
    book_id = requests.GET.get('id')
    text = '您输入的数据的id是:%s' % book_id
    
    return HttpResponse(text)

以后在访问的时候就是通过/book/detail/?id=1即可将参数传递过去

因为查询字符串使用的是GET请求, 所以我们通过request.GET来获取参数。

并且因为GET请求是一个类似于字典的数据类型, 所以获取值跟字典的方式都是一样的

指定默认参数

使用path或者re_path后, 在route中都可以包含参数, 而有时候想指定默认的参数, 这时候可以通过以下方式来完成。示例代码如下：

from django import path

from . import views

urlpatterns = [
    path('blog/', views.page),
    path('blog/page<int:num>', views.page)
]

# View(in blog/views.py)
def page(request, num=1):
    # Output the appropriate page of blog entries, according to num.
    ...

当访问blog/的时候, 因为没有传递num参数, 所以会匹配第一个url, 这时候就执行view.page这个视图函数, 而在page函数中, 又有num=1这个默认参数。因此这时候就可以不用传递参数。而如果访问blog/1的时候, 因为在传递参数的时候传递了num, 因此会匹配第二个url, 这时候也会执行views.page, 然后把传递进来的参数传给page函数中的num。

URL中包含另外一个urls模块

在我们的项目中, 不可能只有一个app, 如果把所有的app的views中的视图都放在urls.py中进行映射, 肯定会让代码显得非常乱, 因此django给我们提供了一个方法, 可以在app内部包含自己的url匹配规则, 而在项目的urls.py中再统一包含这个app的urls。使用这个技术需要借助include函数, 示例代码如下:

# first_project/urls.py文件:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', index),
    path('book/', include('book.urls'))
]

在urls.py文件中把所有的和book这个app相关的url都移动到app/urls.py中了。然后在first_project/urls.py中, 通过include函数包含book.urls, 以后在请求book相关的url的时候都需要加一个book前缀

# book/urls.py文件:

from django.urls import path
from . import views

urlpatterns = [
    path('list/', views.book_list),
    path('detail/<book_id>', view.book_detail)
]

以后在访问书的列表的url的时候, 就通过/book/list来访问, 访问数据详情页面的url的时候就通过/book/detail/<id>来访问

注意:

1. 应该使用include函数包含自urls.py, 并且这个urls.py的路径是相对于项目的路径

2. 在app中的urls.py中, 所有的url匹配也要放在一个叫做urlpatterns的变量中, 否则找不到

3. url是会根据主urls.py和app中的urls.py进行拼接的, 因此注意不要多加斜杠

path函数详解

path函数的定义为:path(route, view, name=None, kwargs=None)。以下对几个参数进行讲解

1. route参数: url的匹配规则。这个参数可以指定url中需要传递的参数, 比如在访问详情页面的时候, 可以传递一个id。传递的参数是通过<>尖括号来进行指定的。并且在传递参数的时候, 可以指定这个参数的数据类型, 比如文章的id都是int类型的, 那么可以这样写<int:id>, 以后匹配的时候, 就只会匹配到id为int类似的url, 而不会匹配其他的url, 并且在视图函数中获取这个参数的时候, 就已经被转换成一个int类型了。其中还有几种常用的类型:

str: 非空的字符串类型。默认的转换器。但是不能包含斜杠
Int: 匹配任意的零或者正数的整形。到视图函数中就死一个int类型
slug: 由英文中的横杆-, 或者下划线_连接英文为字符或者数字而成的字符串
uuid: 匹配uuid字符串
Path: 匹配非空的英文字符串, 可以包含斜杠

2. view参数: 可以作为一个视图函数或者类视图.as_view()或者django.urls.include()函数的返回值

3. name参数: 这个参数是给这个url取个名字的, 这在项目比较大,url比较多的时候用处很大

4. kwargs参数: 有时候想给视图函数传递一些额外的参数, 就可以通过kwargs参数进行传递。这个参数接收一个字典。传到视图函数的时候, 会作为一个关键字参数传过去。比如以下的url规则

from django.urls import path
from . import views

urlpatterns = [
    path('blog/<int:year>/', view.year_archive, {'foo':'bar'})
]

re_path函数详解

有时候在写url匹配的时候, 想要写使用正则表达式来实现一些复杂的需求,那么这时候我们可以使用re_path来实现。re_path的参数和path参数一模一样, 只不过第一个参数可以为一个正则表达式, 示例代码如下:

from django.urls import re_path

from . import views

urlpatterns = [
    path('articles/2003', views.special_case_2003),
    re_path(r'articles/(?P<year>[0-9]{4}/(?P<month>[0-9]{2})/(?P<slug>[w-_]+)/', view.article_detail)
]

通过上述例子我们可以看到, 所有的route字符串前面都加了一个r, 表示这个字符串是一个原生字符串。在写正则表达式的时候推荐使用原生字符串, 这样可以避免在python这一层面进行转义。而且, 使用正则表达式捕获参数的时候, 是用一个圆括号进行包裹, 然后这个参数的名字是通过尖括号<year>进行包裹, 之后才是写正则表达式的语法

url命名空间

为什么需要url命名

因为url是经常变化的, 如果在代码中写死可能会经常改代码。给url取个名字, 以后使用url的时候就使用他的名字进行反转就可以了, 就不需要写死url了
如何给一个url指定名称

在path函数中, 传递一个name参数就可以指定。示例代码如下:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('signin/', views.login, name='login'),
]

应用命名空间

　　在多个app之间, 有可能会产生同名的url, 这时候为避免反转url的时候产生混淆, 可以使用应用命名空间来做区分。定义应用命名空间非常简单。只要在app的urls.py文件中定义一个叫做app_name的变量, 来指定这个应用的命名空间即可。示例代码如下:

from django.urls import path
from . import views

# 应用命名空间
app_name = 'front'

urlpatterns = [
    path('', views.index, name='index'),
    path('signin/', views.login, name='login'),
]

以后在做反转的时候就可以使用应用命名空间:url名称的方式进行反转。示例代码如下:

login_url = reverse('front:login')

应用(app)命名空间和实例命名空间

　　一个app可以创建多个使用。可以使用多个url映射同一个app。所以这就会产生一个问题, 以后在做反转的时候, 如果使用应用命名空间。实例命名空间也是非常简单, 只要在include函数中传递一个namespace变量即可。示例代码如下；

urlpatterns = [
    # 同一个app下有两个实例
    path('cms1/', include('cms.urls', namespace='cms1')),
    path('cms2/', include('cms.urls', namespace='cms2')),
]

以后在做反转的时候, 就可以根据实例命名空间来指定具体的url。示例代码如下:

def index(request):
    username = request.GET.get('username')

    if username:
        return HttpResponse('CMS首页')
    else:
        # 获取当前的实例命名空间
        current_namespace = request.resolver_match.namespace
        return redirect(reverse('%s:login' % current_namespace))

include函数详解

1. include(module, namespace=None)

model: 子url的模块字符串
namespace: 实例命名空间, 这个地方需要注意一点。如果指定实例命名空间, 那么前提必须要先指定应用命名空间。也就是子urls.py中添加app_name变量

2. include((pattern_list, app_namespace), namespace=None)

include函数的第一个参数既可以为一个字符串, 也可以为一个元组。如果是元组, 那么元组的第一个参数是urls.py模块的字符串, 元组的第二个参数是应用命名空间。也就是说, 应用命名空间既可以在子urls.py中通过app_name指定。也可以在include函数中指定

3. include(pattern_list)

pattern_list是一个列表, 这个列表中装的是path或者re_path函数, 示例代码如下:

urlpatterns = [
    path('movie/', include([
        path('', views.movie),
        path('list/', views.movie_list),
    ]))
]

url反转

之前我们都是通过url来访问视图函数, 有时候我们知道这个视图函数, 当时想反转回他的url。这时候就可以通过reverse来实现。示例代码如下:

reverse('list')
> /book/list

如果有应用命名空间或者有实例命名空间, 那么应用在反转的时候加上命名空间。示例代码如下:

reverse('book:list')
> /book/list

如果这个url中需要传递参数, 那么可以通过kwargs来传递参数。示例代码如下:

reverse('book:detail', kwargs={"book_id":1})
> /book/detail/1

因为django中的reverse反转的url的时候不区分GET请求和POST请求, 因此不能在反转的时候添加查询字符串的参数。如果想要添加查询字符串参数, 只能手动的添加。示例代码如下:

login_url = reverse('login') + "?next=/"

自定义URL(PATH)转换器

之前已经学过一些django内置的url转换器, 包括有int、uuid等。有时候这些内置的url转换器并不能满足我们的需求, 因此django个我们提供了一个接口可以让我们自己定义自己的url转换器

自定义url转换器安装一下五个步骤来走就可以了:

定义一个类
在类中定义一个熟悉regex, 这个属性是用来保存url转换器规则的正则表达式
实现to_python(self, value)方法, 这个方法是将url中的值转换一下, 然后传给视图函数的
实现to_url(self, value)方法, 这个方法是在做url反转的时候, 将传进来的参数转换后拼接成一个正确的url
将定义好的转换器, 使用django.urls.converter.register_converter注册到django中

比如写一个匹配四个数字年份的url转换器。示例代码如下:

# 1. 定义一个类
class FourDigitYearConverter(object):
    # 2. 定义一个正则表达式
    regex = [0-9]{4}
    
    # 3. 定义to_python方法
    def to_python(self, value):
        return '04%d' % value
   
    # 4. 定义to_url方法
    def to_url(self, value):
        return '%04d' % value
    

# 5. 注册到django中
from django.urls import register_converter

register_converter(converter.FourDigitYearConverter, 'yyyy')

# 6. 转换器的使用
urlpatterns = [
    # 使用注册的转换器
    path('articles/<yyyy:year>/', views.year_archive)
]

Django限制请求method

常用的请求method

GET请求: GET请求一般用来项服务器索取数据, 但不会向服务器提交数据, 不会对服务器的状态进行更改，比如向服务器获取某篇文章的详情
POST请求: POST请求一般都是用来向服务器提交数据的, 会对服务器的状态进行更改。比如提交一篇文章给服务器

限制请求装饰器

Django内置的视图装饰器可以给视图提供一些限制。比如这个视图只能通过GET的method访问等。以下将介绍一些常用的内置视图装饰器

1. django.http.decorators.http.require_http_methods: 这个装饰器需要传递一个允许访问的方法列表。比如只能通过GET方式访问。那么示例代码如下:

from django.http.decorators.http import require_http_methods

@require_http_method(['GET'])
def my_view(request):
    pass

2. django.views.decorators.http.require_GET: 这个装饰器相当于是require_http_methods(["GET"])的缩写, 只允许使用GET的method来访问视图。示例代码如下:

from django.http.decorators.http import require_http_methods

@require_http_method(['GET'])
def my_view(request):
    pass

3. django.views.decorators.http.require_POST：这个装饰器相当于是require_http_methods(['POST'])的简写形式，只允许使用POST的method来访问视图。示例代码如下：

 from django.views.decorators.http import require_POST

 @require_POST
 def my_view(request):
     pass

4. django.views.decorators.http.require_safe：这个装饰器相当于是require_http_methods(['GET','HEAD'])的简写形式，只允许使用相对安全的方式来访问视图。因为GET和HEAD不会对服务器产生增删改的行为。因此是一种相对安全的请求方式。示例代码如下：

from django.views.decorators.http import require_safe

@require_safe
def my_view(request):
    pass

重定向

重定向分为永久性重定向和暂时性重定向，在页面上体现的操作就是浏览器会从一个页面自动跳转到另外一个页面。比如用户访问了一个需要权限的页面，但是该用户当前并没有登录，因此我们应该给他重定向到登录页面。

永久性重定向：http的状态码是301，多用于旧网址被废弃了要转到一个新的网址确保用户的访问，最经典的就是京东网站，你输入www.jingdong.com的时候，会被重定向到www.jd.com，因为jingdong.com这个网址已经被废弃了，被改成jd.com，所以这种情况下应该用永久重定向。
暂时性重定向：http的状态码是302，表示页面的暂时性跳转。比如访问一个需要权限的网址，如果当前用户没有登录，应该重定向到登录页面，这种情况下，应该用暂时性重定向。

在Django中，重定向是使用redirect(to, *args, permanent=False, **kwargs)来实现的。to是一个url，permanent代表的是这个重定向是否是一个永久的重定向，默认是False。关于重定向的使用。请看以下例子：

from django.shortcuts import reverse,redirect
def profile(request):
    if request.GET.get("username"):
        return HttpResponse("%s，欢迎来到个人中心页面！")
    else:
        return redirect(reverse("user:login"))

HttpRequest对象

WSGIRequest对象

Django在接收到http请求之后，会根据http请求携带的参数以及报文信息创建一个WSGIRequest对象，并且作为视图函数第一个参数传给视图函数。也就是我们经常看到的request参数。在这个对象上我们可以找到客户端上传上来的所有信息。这个对象的完整路径是django.core.handlers.wsgi.WSGIRequest

WSGIRequest对象常用属性和方法

WSGIRequest对象常用属性

WSGIRequest对象上大部分的属性都是只读的。因为这些属性是从客户端上传上来的，没必要做任何的修改。以下将对一些常用的属性进行讲解：

path：请求服务器的完整“路径”，但不包含域名和参数。比如http://www.baidu.com/xxx/yyy/，那么path就是/xxx/yyy/。
method：代表当前请求的http方法。比如是GET还是POST。
GET：一个django.http.request.QueryDict对象。操作起来类似于字典。这个属性中包含了所有以?xxx=xxx的方式上传上来的参数。
POST：也是一个django.http.request.QueryDict对象。这个属性中包含了所有以POST方式上传上来的参数。
FILES：也是一个django.http.request.QueryDict对象。这个属性中包含了所有上传的文件。
COOKIES：一个标准的Python字典，包含所有的cookie，键值对都是字符串类型。
SESSION：一个类似于字典的对象。用来操作服务器的session。
META：存储的客户端发送上来的所有header信息。
CONTENT_LENGTH：请求的正文的长度（是一个字符串）。
CONTENT_TYPE：请求的正文的MIME类型。
HTTP_ACCEPT：响应可接收的Content-Type。
HTTP_ACCEPT_ENCODING：响应可接收的编码。
HTTP_ACCEPT_LANGUAGE：响应可接收的语言。
HTTP_HOST：客户端发送的HOST值。
HTTP_REFERER：在访问这个页面上一个页面的url。
QUERY_STRING：单个字符串形式的查询字符串（未解析过的形式）。
REMOTE_ADDR：客户端的IP地址。如果服务器使用了nginx做反向代理或者负载均衡，那么这个值返回的是127.0.0.1,这时候可以使用HTTP_X_FORWARDED_FOR来获取，所以获取ip地址的代码片段如下：

  if request.META.has_key('HTTP_X_FORWARDED_FOR'):  
      ip =  request.META['HTTP_X_FORWARDED_FOR']  
  else:  
      ip = request.META['REMOTE_ADDR']

REMOTE_HOST：客户端的主机名。
REQUEST_METHOD：请求方法。一个字符串类似于GET或者POST。
SERVER_NAME：服务器域名。
SERVER_PORT：服务器端口号，是一个字符串类型。

WSGIRequest对象常用方法

is_secure()：是否是采用https协议。
is_ajax()：是否采用ajax发送的请求。原理就是判断请求头中是否存在X-Requested-With:XMLHttpRequest。
get_host()：服务器的域名。如果在访问的时候还有端口号，那么会加上端口号。比如www.baidu.com:9000。
get_full_path()：返回完整的path。如果有查询字符串，还会加上查询字符串。比如/music/bands/?print=True。
get_raw_uri()：获取请求的完整url。

QueryDict对象

我们平时用的request.GET和request.POST都是QueryDict对象，这个对象继承自dict，因此用法跟dict相差无几。其中用得比较多的是get方法和getlist方法。

get方法：用来获取指定key的值，如果没有这个key，那么会返回None。
getlist方法：如果浏览器上传上来的key对应的值有多个，那么就需要通过这个方法获取。

HttpResponse对象

Django服务器接收到客户端发送过来的请求后，会将提交上来的这些数据封装成一个HttpRequest对象传给视图函数。那么视图函数在处理完相关的逻辑后，也需要返回一个响应给浏览器。而这个响应，我们必须返回HttpResponseBase或者他的子类的对象。而HttpResponse则是HttpResponseBase用得最多的子类。那么接下来就来介绍一下HttpResponse及其子类。

常用属性

content：返回的内容。
status_code：返回的HTTP响应状态码。
content_type：返回的数据的MIME类型，默认为text/html。浏览器会根据这个属性，来显示数据。如果是text/html, 那么就会解析这个字符串，如果text/plain, 那么就会显示一个纯文本。常用的Content-Type

- text/html（默认的，html文件）
- text/plain（纯文本）
- text/css（css文件）
- text/javascript（js文件）
- multipart/form-data（文件提交）
- application/json（json传输）
- application/xml（xml文件）

设置请求头：response['X-Access-Token'] = 'xxxx'

常用方法

set_cookie：用来设置cookie信息。后面讲到授权的时候会着重讲到。
delete_cookie：用来删除cookie信息。
write：HttpResponse是一个类似于文件的对象，可以用来写入数据到数据体（content）中。

JsonResponse类

用来对象dump成json字符串，然后返回将json字符串封装成Response对象返回给浏览器。并且他的Content-Type是application/json。示例代码如下：

from django.http import JsonResponse
def index(request):
    return JsonResponse({"username":"feather","age":18})

默认情况下JsonResponse只能对字典进行dump，如果想要对非字典的数据进行dump，那么需要给JsonResponse传递一个safe=False参数。示例代码如下：

from django.http import JsonResponse
def index(request):
    persons = ['张三','李四','王五']
    return JsonResponse(persons, safe=False)

生成CSV文件

有时候我们做的网站，需要将一些数据，生成有一个CSV文件给浏览器，并且是作为附件的形式下载下来。以下将讲解如何生成CSV文件。

生成小的CSV文件

这里将用一个生成小的CSV文件为例，来把生成CSV文件的技术要点讲到位。我们用Python内置的csv模块来处理csv文件，并且使用HttpResponse来将csv文件返回回去。示例代码如下：

import csv
from django.http import HttpResponse

def csv_view(request):
    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename="somefilename.csv"'

    writer = csv.writer(response)
    writer.writerow(['username', 'age', 'height', 'weight'])
    writer.writerow(['zhiliao', '18', '180', '110'])

    return response

这里再来对每个部分的代码进行解释：

1. 我们在初始化HttpResponse的时候，指定了Content-Type为text/csv，这将告诉浏览器，这是一个csv格式的文件而不是一个HTML格式的文件，如果用默认值，默认值就是html，那么浏览器将把csv格式的文件按照html格式输出，这肯定不是我们想要的。

2. 第二个我们还在response中添加一个Content-Disposition头，这个东西是用来告诉浏览器该如何处理这个文件，我们给这个头的值设置为attachment;，那么浏览器将不会对这个文件进行显示，而是作为附件的形式下载，第二个filename="somefilename.csv"是用来指定这个csv文件的名字。

3. 我们使用csv模块的writer方法，将相应的数据写入到response中。

将`CSV`定义成模板

我们还可以将csv格式的文件定义成模板，然后使用Django内置的模板系统，并给这个模板传入一个Context对象，这样模板系统就会根据传入的Context对象，生成具体的csv文件。示例代码如下：

模板文件

{% for row in data %}"{{ row.0|addslashes }}", "{{ row.1|addslashes }}", "{{ row.2|addslashes }}", "{{ row.3|addslashes }}", "{{ row.4|addslashes }}"
{% endfor %}

视图函数:

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

def some_view(request):
    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename="somefilename.csv"'


    csv_data = (
        ('First row', 'Foo', 'Bar', 'Baz'),
        ('Second row', 'A', 'B', 'C', '"Testing"', "Here's a quote"),
    )

    t = loader.get_template('my_template_name.txt')
    response.write(t.render({"data": csv_data}))
    return response

生成大的CSV文件

以上的例子是生成的一个小的csv文件，如果想要生成大型的csv文件，那么以上方式将有可能会发生超时的情况（服务器要生成一个大型csv文件，需要的时间可能会超过浏览器默认的超时时间）。这时候我们可以借助另外一个类，叫做StreamingHttpResponse对象，这个对象是将响应的数据作为一个流返回给客户端，而不是作为一个整体返回。示例代码如下：

class Echo:
    """
    定义一个可以执行写操作的类，以后调用csv.writer的时候，就会执行这个方法
    """
    def write(self, value):
        return value

def large_csv(request):
    rows = (["Row {}".format(idx), str(idx)] for idx in range(655360))
    pseudo_buffer = Echo()
    writer = csv.writer(pseudo_buffer)
    response = StreamingHttpResponse((writer.writerow(row) for row in rows),content_type="text/csv")
    response['Content-Disposition'] = 'attachment; filename="somefilename.csv"'
    return response

这里我们构建了一个非常大的数据集rows，并且将其变成一个迭代器。然后因为StreamingHttpResponse的第一个参数只能是一个生成器，因此我们使用圆括号(writer.writerow(row) for row in rows)，并且因为我们要写的文件是csv格式的文件，因此需要调用writer.writerow将row变成一个csv格式的字符串。而调用writer.writerow又需要一个中间的容器，因此这里我们定义了一个非常简单的类Echo，这个类只实现一个write方法，以后在执行csv.writer(pseudo_buffer)的时候，就会调用Echo.writer方法。注意：StreamingHttpResponse会启动一个进程来和客户端保持长连接，所以会很消耗资源。所以如果不是特殊要求，尽量少用这种方法。

关于StreamingHttpResponse

这个类是专门用来处理流数据的。使得在处理一些大型文件的时候，不会因为服务器处理时间过长而到时连接超时。这个类不是继承自HttpResponse，并且跟HttpResponse对比有以下几点区别：

1. 这个类没有属性content，相反是streaming_content。

2. 这个类的streaming_content必须是一个可以迭代的对象。

3. 这个类没有write方法，如果给这个类的对象写入数据将会报错。

注意：StreamingHttpResponse会启动一个进程来和客户端保持长连接，所以会很消耗资源。所以如果不是特殊要求，尽量少用这种方法

类视图

在写视图的时候，Django除了使用函数作为视图，也可以使用类作为视图。使用类视图可以使用类的一些特性，比如继承等。

View

django.views.generic.base.View是主要的类视图，所有的类视图都是继承自他。如果我们写自己的类视图，也可以继承自他。然后再根据当前请求的method，来实现不同的方法。比如这个视图只能使用get的方式来请求，那么就可以在这个类中定义get(self,request,*args,**kwargs)方法。以此类推，如果只需要实现post方法，那么就只需要在类中实现post(self,request,*args,**kwargs)。示例代码如下：

from django.views import View
class BookDetailView(View):
    def get(self,request,*args,**kwargs):
        return render(request,'detail.html')

类视图写完后，还应该在urls.py中进行映射，映射的时候就需要调用View的类方法as_view()来进行转换。示例代码如下：

urlpatterns = [        
    path("detail/<book_id>/",views.BookDetailView.as_view(),name='detail')
]

除了get方法，View还支持以下方法['get','post','put','patch','delete','head','options','trace']。

如果用户访问了View中没有定义的方法。比如你的类视图只支持get方法，而出现了post方法，那么就会把这个请求转发给http_method_not_allowed(request,*args,**kwargs)。示例代码如下：

class AddBookView(View):
    def post(self,request,*args,**kwargs):
        return HttpResponse("书籍添加成功！")

    def http_method_not_allowed(self, request, *args, **kwargs):
        return HttpResponse("您当前采用的method是：%s，本视图只支持使用post请求！" % request.method)

urls.py中的映射如下：

path("addbook/",views.AddBookView.as_view(),name='add_book')

如果你在浏览器中访问addbook/，因为浏览器访问采用的是get方法，而addbook只支持post方法，因此以上视图会返回您当前采用的method是：GET，本视图只支持使用post请求！。

TemplateView

django.views.generic.base.TemplateView，这个类视图是专门用来返回模版的。在这个类中，有两个属性是经常需要用到的，一个是template_name，这个属性是用来存储模版的路径，TemplateView会自动的渲染这个变量指向的模版。另外一个是get_context_data，这个方法是用来返回上下文数据的，也就是在给模版传的参数的。示例代码如下：

from django.views.generic.base import TemplateView

class HomePageView(TemplateView):

    template_name = "home.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['username'] = "featherwit"
        return context

在urls.py中的映射代码如下：

from django.urls import path

from myapp.views import HomePageView

urlpatterns = [
    path('', HomePageView.as_view(), name='home'),
]

如果在模版中不需要传递任何参数，那么可以直接只在urls.py中使用TemplateView来渲染模版。示例代码如下：

from django.urls import path
from django.views.generic import TemplateView

urlpatterns = [
    path('about/', TemplateView.as_view(template_name="about.html")),
]

ListView

在网站开发中，经常会出现需要列出某个表中的一些数据作为列表展示出来。比如文章列表，图书列表等等。在Django中可以使用ListView来帮我们快速实现这种需求。示例代码如下：

class ArticleListView(ListView):
    model = Article
    template_name = 'article_list.html'
    paginate_by = 10
    context_object_name = 'articles'
    ordering = 'create_time'
    page_kwarg = 'page'

    def get_context_data(self, **kwargs):
        context = super(ArticleListView, self).get_context_data(**kwargs)
        print(context)
        return context

    def get_queryset(self):
        return Article.objects.filter(id__lte=89)

对以上代码进行解释：

1. 首先ArticleListView是继承自ListView。

2. model：重写model类属性，指定这个列表是给哪个模型的。

3. template_name：指定这个列表的模板。

4. paginate_by：指定这个列表一页中展示多少条数据。

5. context_object_name：指定这个列表模型在模板中的参数名称。

6. ordering：指定这个列表的排序方式。

7. page_kwarg：获取第几页的数据的参数名称。默认是page。

8. get_context_data：获取上下文的数据。

9. get_queryset：如果你提取数据的时候，并不是要把所有数据都返回，那么你可以重写这个方法。将一些不需要展示的数据给过滤掉

给类视图添加装饰器

在开发中，有时候需要给一些视图添加装饰器。如果用函数视图那么非常简单，只要在函数的上面写上装饰器就可以了。但是如果想要给类添加装饰器，那么可以通过以下两种方式来实现：

装饰dispatch方法

from django.utils.decorators import method_decorator

def login_required(func):
    def wrapper(request,*args,**kwargs):
        if request.GET.get("username"):
            return func(request,*args,**kwargs)
        else:
            return redirect(reverse('index'))
    return wrapper


class IndexView(View):
    def get(self,request,*args,**kwargs):
        return HttpResponse("index")

    @method_decorator(login_required)
    def dispatch(self, request, *args, **kwargs):
        super(IndexView, self).dispatch(request,*args,**kwargs)

直接装饰在整个类上

from django.utils.decorators import method_decorator
def login_required(func):
    def wrapper(request,*args,**kwargs):
        if request.GET.get("username"):
            return func(request,*args,**kwargs)
        else:
            return redirect(reverse('login'))
    return wrapper


@method_decorator(login_required,name='dispatch')
class IndexView(View):
    def get(self,request,*args,**kwargs):
        return HttpResponse("index")

    def dispatch(self, request, *args, **kwargs):
        super(IndexView, self).dispatch(request,*args,**kwargs)

分页

Paginator

Paginator 类的作用是将我们需要分页的数据分割成若干份。当我们实现化一个 Paginator 类的实例时，需要给 Paginator 传入两个参数。第一个参数是数据源，可以是一个列表、元组、以及查询结果集 QuerySet。第二个参数需要传入一个整数，表示每页显示数据条数。示例代码如下:

book_list = []
for x in range(1, 26):  # 一共 25 本书
    book_list.append('Book ' + str(x))
# 将数据按照规定每页显示 10 条, 进行分割
paginator = Paginator(book_list, 10)

上面代码中，我们传入一个名为 book_list 的列表，该列表中含有 25 本书，然后我们给 Paginator 设定每页显示 10 条数据，最后得到一个 Paginator 实例。

另外 Paginator 类中有三个常用的属性，它们分别是：

count：表示所有页面的对象总数。
num_pages：表示页面总数。
page_range：下标从 1 开始的页数范围迭代器。

Page对象

Paginator 类提供一个page(number)函数，该函数返回就是一个 Page 对象。参数 number 表示第几个分页。如果 number = 1，那么 page() 返回的对象是第一分页的 Page 对象。在前端页面中显示数据，我们主要的操作都是基于 Page 对象。实现代码如下:

# 使用  paginator 对象返回第 1 页的 page 对象
books = paginator.page(1)

Page 对象有三个常用的属性：

object_list: 表示当前页面上所有对象的列表。
numberv: 表示当前页的序号，从 1 开始计数。
paginator：当前 Page 对象所属的 Paginator 对象。

除此之外，Page 对象还拥有几个常用的函数：

has_next()：判断是否还有下一页，有的话返回True。
has_previous()：判断是否还有上一页，有的话返回 True。
has_other_pages()：判断是否上一页或下一页，有的话返回True。
next_page_number()：返回下一页的页码。如果下一页不存在，抛出InvalidPage 异常。
previous_page_number()：返回上一页的页码。如果上一页不存在，抛出InvalidPage 异常

from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage, InvalidPage
from django.http import HttpResponse
from django.shortcuts import render

def paginator_view(request):
    book_list = []
    '''
    数据通常是从 models 中获取。这里为了方便，直接使用生成器来获取数据。
    '''
    for x in range(1, 26):  # 一共 25 本书
        book_list.append('Book ' + str(x))

    # 将数据按照规定每页显示 10 条, 进行分割
    paginator = Paginator(book_list, 10)

    if request.method == "GET":
        # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
        page = request.GET.get('page')
        try:
            books = paginator.page(page)
        # todo: 注意捕获异常
        except PageNotAnInteger:
            # 如果请求的页数不是整数, 返回第一页。
            books = paginator.page(1)
        except InvalidPage:
            # 如果请求的页数不存在, 重定向页面
            return HttpResponse('找不到页面的内容')
        except EmptyPage:
            # 如果请求的页数不在合法的页数范围内，返回结果的最后一页。
            books = paginator.page(paginator.num_pages)

    template_view = 'page.html'
    return render(request, template_view, {'books': books})

错误处理

在一些网站开发中。经常会需要捕获一些错误，然后将这些错误返回比较优美的界面，或者是将这个错误的请求做一些日志保存。那么我们本节就来讲讲如何实现。

常用的错误码

404：服务器没有指定的url。
403：没有权限访问相关的数据。
405：请求的method错误。
400：bad request，请求的参数错误。
500：服务器内部错误，一般是代码出bug了。
502：一般部署的时候见得比较多，一般是nginx启动了，然后uwsgi有问题。

自定义错误模板

在碰到比如404，500错误的时候，想要返回自己定义的模板。那么可以直接在templates文件夹下创建相应错误代码的html模板文件。那么以后在发生相应错误后，会将指定的模板返回回去。

错误请求的解决方案

对于404和500这种自动抛出的错误。我们可以直接在templates文件夹下新建相应错误代码的模板文件。而对于其他的错误，我们可以专门定义一个app，用来处理这些错误。