django学习笔记6-django视图高级（101-116）

101 限制请求method装饰器

两个方法

from django.views.decorators.http import require_http_methods,require_GET,require_POST,require_safe
from django.http import HttpResponse

# require_GET = @require_http_methods(['GET'])

# require_safe = @require_http_methods(['GET','HEAD'])

@require_GET
def index(request):
    # 首页返回所有的文章
    # 只能使用GET请求来访问这个视图函数
    articles = Article.objects.all()
    return render(request,'index.html',context={"articles":articles})

@require_http_methods(['POST','GET'])
def add_article(request):
    # 如果使用GET请求来访问这个视图函数，那么就返回一个添加文章的HTML页面
    # 如果使用POST请求来访问这个视图函数，那么就获取提交上来的数据，然后保存
    # 到数据库中
    if request.method == 'GET':
        return render(request,'add_article.html')
    else:
        title = request.POST.get("title")
        content = request.POST.get('content')
        Article.objects.create(title=title,content=content)
        return HttpResponse('success')

---

102 【Django视图高级】重定向详解

• 301 永久性重定向 比如 t.tt 跳转到 https://www.smartisan.com/ www.jingdong.com 跳转到 www.jd.com
• 302暂时性的重定向 https://www.zhihu.com 如果没有登陆 跳转到 https://www.zhihu.com/signup?next=%2F

from django.shortcuts import render,redirect,reverse
from django.http import HttpResponse

def index(request):
    # 如果没有登录，那么就重定向到注册页面
    # 如果在url中，传递了usename这个参数，那么就认为是登录了，否则就没有登录
    # /?username=xxx
    username = request.GET.get("username")
    if username:
        return HttpResponse("首页")
    else:
        return redirect(reverse('signup'))
        # return HttpResponse("注册页")

def signup(request):
    return HttpResponse("注册页")

---

103 HttpRequest对象讲解

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

http请求的url详解：

在了解WSGIRequest对象的属性和方法之前，我们先了解一下url的组成，通常来说url的完整组成如下，[]为可选：

protocol ://hostname[:port]/path/[;parameters][?query]#fragment

protocol： 网络协议，常用的协议有http/https/ftp等
hostname： 主机地址，可以是域名，也可以是IP地址
port： 端口 http协议默认端口是：80端口，在浏览器中默认会隐藏不显示
path：路径 网络资源在服务器中的指定路径
parameter： 参数 如果要向服务器传入参数，在这部分输入
query： 查询字符串 如果需要从服务器那里查询内容，在这里编辑
fragment：片段 网页中可能会分为不同的片段，如果想访问网页后直接到达指定位置，可以在这部分设置

WSGIRequest对象常用属性：

WSGIRequest对象上大部分的属性都是只读的。因为这些属性是从客户端上传上来的，没必要做任何的修改，在django视图中使用时，视图函数的第一个参数参数request就是WSGIRequest对象。以下将对一些常用的属性进行讲解：

path：资源在服务器的完整“路径”，但不包含域名和参数，在url中也是path的内容。比如http://www.baidu.com/xxx/yyy/，那么path就是/xxx/yyy/。
method：代表当前请求的http方法。比如是GET、POST、delete或者是put等方法
GET：一个django.http.request.QueryDict对象。操作起来类似于字典。这个属性中包含了所有以?xxx=xxx的方式上传上来的参数。
POST：也是一个django.http.request.QueryDict对象。这个属性中包含了所有以POST方式上传上来的参数。
FILES：也是一个django.http.request.QueryDict对象。这个属性中包含了所有上传的文件。
COOKIES：一个标准的Python字典，包含所有的cookie，键值对都是字符串类型。
session：一个类似于字典的对象。用来操作服务器的session。
user：user 只有当Django 启用 AuthenticationMiddleware 中间件时才可用。它的值是一个 setting.py 里面AUTH_USER_MODEL 字段所定义的类的对象，表示当前登录的用户。如果用户当前没有登录，user 将设为 django.contrib.auth.models.AnonymousUser 的一个实例。你可以通过 is_authenticated() 区分它们。

META：存储的客户端发送上来的所有header信息，下面是这些常用的header信息：

CONTENT_LENGTH：请求的正文的长度（是一个字符串）。

CONTENT_TYPE：请求的正文的MIME类型。
　　HTTP_ACCEPT：响应可接收的Content-Type。
　　HTTP_ACCEPT_ENCODING：响应可接收的编码，用于告知服务器客户端所能够处理的编码方式和相对优先级。
　　HTTP_ACCEPT_LANGUAGE： 响应可接收的语言。
　　HTTP_HOST：客户端发送的HOST值。
　　HTTP_REFERER：在访问这个页面上一个页面的url。
　　QUERY_STRING：单个字符串形式的查询字符串（未解析过的形式）。
　　TE：设置传输实体的编码格式，表示请求发起者愿意接收的Transfer-Encoding类型(传输过程中的编码格式，代理服务器之间)
　　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()：服务器的域名。如果在访问的时候还有端口号，那么会加上端口号，在url中就是hostname+port。比如www.baidu.com:9000。
get_full_path()：返回完整的path。如果有查询字符串，还会加上查询字符串，在url中就是path以及其后面的所有。比如/music/bands/?print=True。
get_raw_uri()：获取请求的完整url。

---

104

QueryDict对象：

用法：https://www.cnblogs.com/fat39/p/9646971.html

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

1. get方法：用来获取指定key的值，如果没有这个key，那么会返回None。
2. getlist方法：如果浏览器上传上来的key对应的值有多个，如果使用get取值，那么你只能取出最后面一个值，如果你想取到所有的值，那么就需要通过getlist这个方法获取。
   推荐使用request.GET.get('username',default=1)

---

105 Django之HttpResponse对象

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

常用属性：

1. content：返回的内容。
2. status_code：返回的HTTP响应状态码。
3. 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文件）
4. 设置请求头：response['X-Access-Token'] = 'xxxx'。

常用方法：

1. set_cookie：用来设置cookie信息。
2. delete_cookie：用来删除cookie信息。
3. write：HttpResponse是一个类似于文件的对象，可以用来写入数据到数据体（content）中。

---

106 JsonResponse

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

from django.http import JsonResponse

response = JsonResponse({"foo": "bar"})
print(response.content)
默认只能传递字典类型, 如果要传递非字典类型需要设置一下safe关键字参数.

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

107 生成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

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

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

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

我们使用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 %}

视图函数：

rom 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

108 大型CSV文件的处理方式.

生成大的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对比有以下几点区别：

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

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

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

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

109类视图

get post dispatch http_method_not_allowed

110TemplateView讲解 适合没有上下文的模型使用 不需要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//",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请求！。

其实不管是get请求还是post请求，都会走dispatch(request,args,*kwargs)方法，所以如果实现这个方法，将能够对所有请求都处理到。

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'] = "黄勇"
        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")),
]

---

111 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)

对以上代码进行解释：

首先ArticleListView是继承自ListView。
model：重写model类属性，指定这个列表是给哪个模型的。
template_name：指定这个列表的模板。
paginate_by：指定这个列表一页中展示多少条数据。
context_object_name：指定这个列表模型在模板中的参数名称。
ordering：指定这个列表的排序方式。
page_kwarg：获取第几页的数据的参数名称。默认是page。
get_context_data：获取上下文的数据。
get_queryset：如果你提取数据的时候，并不是要把所有数据都返回，那么你可以重写这个方法。将一些不需要展示的数据给过滤掉。

---

112Paginator和Page类常用属性和方法

Paginator和Page类：
Paginator和Page类都是用来做分页的。他们在Django中的路径为django.core.paginator.Paginator和django.core.paginator.Page。以下对这两个类的常用属性和方法做解释：

Paginator常用属性和方法：
count：总共有多少条数据。
num_pages：总共有多少页。
page_range：页面的区间。比如有三页，那么就range(1,4)。
Page常用属性和方法：
has_next：是否还有下一页。

has_previous：是否还有上一页。

next_page_number：下一页的页码。

previous_page_number：上一页的页码。

number：当前页。

start_index：当前这一页的第一条数据的索引值。

end_index：当前这一页的最后一条数据的索引值。

实例:
def get_context_data(self, *kwargs):
context = super(ArticleListView, self).get_context_data(kwargs)
context[‘username’] = ‘zhiliao’
paginator = context.get(‘paginator’)
page_obj = context.get(‘page_obj’)
pagination_data = self.get_pagination_data(paginator,page_obj,3)
context.update(pagination_data)
return context

---

113 手动实现普通分页效果

这节课是介绍了,如何在BOOTSTRAP上面寻找模板

   
    
        
        
        
    
    
        

            {% for article in articles %}
                
{{ article.title }}
            {% endfor %}
            

    {#             上一页#}
                {% if page_obj.has_previous %}
                    
上一页
                {% else %}
                    
上一页
                {% endif %}
    
    {#             中间的页码#}
                {% for page in paginator.page_range %}
                    {% if page == page_obj.number %}
                        
{{ page }}
                    {% else %}
                        
{{ page }}
                    {% endif %}
                {% endfor %}
    
    {#             下一页#}
                {% if page_obj.has_next %}
                    
下一页
                {% else %}
                    
下一页
                {% endif %}
    
            
        
    

---

114 手动实现通用分页算法

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

    def get_context_data(self, **kwargs):
        context = super(ArticleListView, self).get_context_data(*kwargs)
        context['username'] = 'zhiliao'
        paginator = context.get('paginator')
        page_obj = context.get('page_obj')
        pagination_data = self.get_pagination_data(paginator,page_obj,3)
        context.update(pagination_data)
        return context

    def get_pagination_data(self,paginator,page_obj,around_count=2):
        #page_obj是在get_context_data里面原有参数,表示现在处于总页数的第几页.
        current_page = page_obj.number
        num_pages = paginator.num_pages

        left_has_more = False
        right_has_more = False

        if current_page <= around_count + 2:
            left_pages = range(1,current_page)
        else:
            left_has_more = True
            left_pages = range(current_page-around_count,current_page)

        if current_page >= num_pages - around_count - 1:
            right_pages = range(current_page+1,num_pages+1)
        else:
            right_has_more = True
            right_pages = range(current_page+1,current_page+around_count+1)

        return {
            'left_pages': left_pages,
            'right_pages': right_pages,
            'current_page': current_page,
            'left_has_more': left_has_more,
            'right_has_more': right_has_more,
            'num_pages': num_pages
        }

html

    
    
    


    

        {% for article in articles %}
            
{{ article.title }}
        {% endfor %}
        

{#             上一页#}
            {% if page_obj.has_previous %}
                
上一页
            {% else %}
                
上一页
            {% endif %}

            {% if left_has_more %}
                
1
                
...
            {% endif %}

            {# 左边的页码 #}
            {% for left_page in left_pages %}
                
{{ left_page }}
            {% endfor %}

            {# 当前的页面 #}
            
{{ current_page }}

            {# 右边的页码 #}
            {% for right_page in right_pages %}
                
{{ right_page }}
            {% endfor %}

            {% if right_has_more %}
                
...
                
{{ num_pages }}
            {% endif %}

{#             下一页#}
            {% if page_obj.has_next %}
                
下一页
            {% else %}
                
下一页
            {% endif %}

        
    

---

115 给类视图添加装饰器

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

def login_required(func):
    def wrapper(request,*args,**kwargs):
# ?username=zhiliao
        username = request.GET.get(‘username’)
    if username:
        return func(request,*args,**kwargs)
    else:
        return redirect(reverse(‘front:login’))
return wrapper

2

@method_decorator([login_required],name='dispatch')
class ProfileView(View):
    def get(self,request):
        return HttpResponse("个人中心界面")

---

116错误处理

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

常用的错误码：

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

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