Django组件介绍

我不是女神ヾ 2022-05-12 08:28 336阅读 0赞

### 文章目录 ###

*  Django组件介绍
 *   *  1. 分页器的使用
     *   *  1.1 数据库内插入大量数据
         *  1.2 导入模块
         *  1.3 实例化一个分页器
         *  1.4 分页器对象相关的方法
         *  1.5 一个简单的分页示例
     *  2. forms组件
     *   *  2.1 检验字段功能
         *   *  2.11 导入forms组件
             *  2.12 使用forms组件创建一个类
             *  2.13 实例化一个forms对象
             *  2.14 查看校验字段结果
         *  2.15 渲染标签功能
         *   *  2.16 首先实例化一个forms类
             *  2.17 在模板中使用forms
         *  2.2 使用forms显示重置界面
         *  2.3 如何显示错误信息
         *   *  2.31 首先将实例化的forms对象传入HTML
             *  2.32 在HTML模板中调用相应的对象
         *  2.4 forms的参数配置
         *   *  2.41 导入模块
             *  2.42 设置forms组件在模板中生成的元素类型
             *  2.43 设置forms组件在模板中生成元素的属性
         *  2.5 校验的局部钩子
         *   *  2.51 原理
             *  2.52 先导入错误类型
             *  2.53 然后在forms类中创建一个\`clean\_字段\`的函数
             *  2.54 使用\`cleaned\_data\`获取校验成功的值
             *  2.55 示例
         *  2.6 全局钩子
         *   *  2.61 原理
             *  2.62 在forms类中创建一个\`clean\`函数
             *  2.63 示例
     *  3. 中间件
     *   *  3.1 什么是中间件？
         *  3.2 自定义中间件
         *   *  3.21 创建一个存放中间件的文件夹，如my\_middlewares.py
             *  3.22 导入相应的类
             *  3.23 创建相应的类（必须继承MiddlewareMixin）
             *  3.24 在MIDDLEWARE数组中注册该中间件
             *  3.25 中间件有什么作用？
             *  3.26 主要方法
         *  3.3 使用示例
         *   *  3.31 服务器页面加一个用户验证
             *  3.32 IP访问评率限制

# Django组件介绍 #

## 1. 分页器的使用 ##

分页器在页面中非常常见，当数据库条数数据过多时，页面一次性显示不好看时，我们可以使用分页器，将数据分几次显示。

### 1.1 数据库内插入大量数据 ###

Booklist=[]
    for i in range(100):
        Booklist.append(Book(title="book"+str(i),price=30+i*i))
    Book.objects.bulk_create(Booklist)

使用对象下面的`bulk_create()`，可以实现批量插入

### 1.2 导入模块 ###

`from django.core.paginator import Paginator`

### 1.3 实例化一个分页器 ###

`paginator = Paginator(book_list,8)` 第一个为数据列表，第二个为每一页数据

### 1.4 分页器对象相关的方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>paginator.count()</code></td> 
   <td>数据总数</td> 
  </tr> 
  <tr> 
   <td><code>paginator.num_pages()</code></td> 
   <td>总页数</td> 
  </tr> 
  <tr> 
   <td><code>paginator.page_range()</code></td> 
   <td>页码的迭代器</td> 
  </tr> 
 </tbody> 
</table>

**获取第n页数据**  
`current_page = paginator.page(1)`获取第一页的列表

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>current_page.object_list</code></td> 
   <td>获取第n页对象列表</td> 
  </tr> 
  <tr> 
   <td><code>current_page.has_next()</code></td> 
   <td>是否有下一页</td> 
  </tr> 
  <tr> 
   <td><code>current_page.next_page_number()</code></td> 
   <td>下一页的页码</td> 
  </tr> 
  <tr> 
   <td><code>current_page.has_previous()</code></td> 
   <td>是否有上一页</td> 
  </tr> 
  <tr> 
   <td><code>current_page.previous_page_number()</code></td> 
   <td>上一页的页码</td> 
  </tr> 
 </tbody> 
</table>

注意：如果在`paginator.page(1)`输入的页码数小于1或者大于最大页数，会报`EmptyPage`错误。  
捕捉`EmptyPage`错误方法

from django.core.paginator import EmptyPage
    引入错误，使用try捕捉错误
    try:
       内容
    except EmptyPage as e:
        current_page=paginator.page(1)

### 1.5 一个简单的分页示例 ###

`views.py`中

def books(request):
        book_list = Book.objects.all()
        from django.core.paginator import  Paginator,EmptyPage
        paginator = Paginator(book_list,3)
        num_pages = paginator.num_pages
        current_page_num = int(request.GET.get("page",1))
        if num_pages > 11:
            if current_page_num < 5:
                page_range = range(1,11)
            elif current_page_num+5 > num_pages:
                page_range = range(num_pages-10,num_pages+1)
            else:
                page_range = range(current_page_num-5,current_page_num+5)
        else:
            page_range = paginator.page_range
        try:
            current_page = paginator.page(current_page_num)
        except EmptyPage as e:
            current_page = paginator.page(1)
        return render(request,"book.html",locals())

`book.html`中

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>分页练习</title>
        <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
        <script
                src="https://code.jquery.com/jquery-3.3.1.js"
                integrity="sha256-2Kok7MbOyxpgUVvAk/HJ2jigOSYS2auK4Pfzbm7uH60="
                crossorigin="anonymous"></script>
    </head>
    <body>
    <p>OK</p>
    <table class="table table-striped">
        <tbody>
    {#显示当前页面#}
        {% for book in current_page %}
            <tr>
                <td>{
       { book.nid }}</td>
                <td>{
       { book.title  }}</td>
                <td>{
       { book.price}}</td>
            </tr>
        {% endfor %}
        </tbody>
    </table>
    {#显示页码#}
    <ul class="pagination">
        {% if current_page.has_previous %}
            <li>
                <a href="?page={
       { current_page.previous_page_number }}" aria-label="Previous">
                    <span aria-hidden="true">«</span>
                </a>
            </li>
        {% else %}
            <li class="disabled">
                <a href="" aria-label="Previous">
                    <span aria-hidden="true">«</span>
                </a>
            </li>
        {% endif %}
    
        {% for item in page_range %}
            {% if item == current_page_num %}
                <li class="active"><a href="?page={
       { item }}">{
       { item }}</a></li>
            {% else %}
                <li><a href="?page={
       { item }}">{
       { item }}</a></li>
            {% endif %}
        {% endfor %}
    
        {% if current_page.has_next %}
        <li>
            <a href="?page={
       { current_page.next_page_number }}" aria-label="Next">
                <span aria-hidden="true">»</span>
            </a>
        </li>
        {% else %}
        <li class="disabled">
            <a href="" aria-label="Next">
                <span aria-hidden="true">»</span>
            </a>
        </li>
        {% endif %}
    </ul>
    
    </body>
    {#<script>#}
    {#    $(".pagination li a").click(function () {#}
    {#        $(this).parent().addClass("active").siblings("li").removeClass("active")#}
    {#    })#}
    {#</script>#}
    </html>

## 2. forms组件 ##

forms组件主要功能是检验字段的功能，校验表单中的键值对的功能

### 2.1 检验字段功能 ###

#### 2.11 导入forms组件 ####

`from django import forms`

#### 2.12 使用forms组件创建一个类 ####

class UserForm(forms.Form):
        name = forms.CharField(min_length=4)
        email=forms.EmailField()

`name`字段最小不得小于4个字节，email字段必须邮箱格式  
注意：该类必须继承`forms.Form`  
只校验UserForm中的字段，传入的其他字段会被忽视，不会校验。forms存在该字段，校验时该字段就不能为空

一些常用的校验函数及其参数

<table> 
 <thead> 
  <tr> 
   <th>校验函数</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>CharField</code></td> 
   <td>校验字符串，可以设置<code>max_length</code>最大长度或最小长度<code>min_length</code></td> 
  </tr> 
  <tr> 
   <td><code>DecimalField</code></td> 
   <td>校验验证数字，前后空格会被忽略，<code>max_value</code>和<code>min_value</code>控制总长度，并应作为decimal.Decimal值给出。<code>max_digits</code>允许的小数+整数总位数;<code>decimal_places</code>允许的最大小数位数。</td> 
  </tr> 
  <tr> 
   <td><code>EmailField</code></td> 
   <td>是否为有效的电子邮件地址,可选参数<code>max_length</code>和<code>min_length</code></td> 
  </tr> 
  <tr> 
   <td><code>FileField</code></td> 
   <td>非空文件数据是否已绑定到表单,<code>max_length</code>文件最大大小和<code>allow_empty_file</code>文件是否可以为空</td> 
  </tr> 
  <tr> 
   <td><code>FloatField</code></td> 
   <td>验证给定值是否为float,可选<code>max_value</code>并且<code>min_value</code></td> 
  </tr> 
  <tr> 
   <td><code>IntegerField</code></td> 
   <td>验证给定值是否为整数。可选<code>max_value</code>和<code>min_value</code></td> 
  </tr> 
 </tbody> 
</table>

#### 2.13 实例化一个forms对象 ####

将需要验证的表单值传入，检验是否合法  
`form=UserForm({"name":"yuan","email":"123"})`  
也可以直接传入POST字典（但是前段键值必须与form一一对应）  
`form = UserForm(request.POST)`

#### 2.14 查看校验字段结果 ####

<table> 
 <thead> 
  <tr> 
   <th>相关API</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>form.is_valid()</code></td> 
   <td>校验全部通过返回True,否则返回False</td> 
  </tr> 
  <tr> 
   <td><code>form.cleaned_data</code></td> 
   <td>返回字典，可以查看校验成功的字段（键值都放入）</td> 
  </tr> 
  <tr> 
   <td><code>form.errors</code></td> 
   <td>可以查看校验失败的字段（键为校验错误的键，值为错误信息的列表）</td> 
  </tr> 
 </tbody> 
</table>

### 2.15 渲染标签功能 ###

forms组件还可以自动为我们在form表单中渲染校验字段的表单

具体方法如下

#### 2.16 首先实例化一个forms类 ####

`form=UserForm()` 不用传值

#### 2.17 在模板中使用forms ####

方式一： 使用标签`{ { form.字段 }}`可以渲染出相应的input标签  
在HTML中

<form action="" method="post">
        {% csrf_token %}
        <p>用户名：{
       { form.name }}</p>
        <p>密码：{
       { form.pwd }}</p>
        <p>再次确认密码：{
       { form.re_pwd }}</p>
        <p>邮箱：{
       { form.email }}</p>
        <p>电话：{
       { form.tel }}</p>
        <input type="submit" value="注册">
    </form>

视图函数中  
`form=UserForm()`  
forms组件将自动将生成标签`name`属性变成相应的字段名  
比如说`<p>用户名：{ { form.name }}</p>`  
等同于`<p>用户名：<input type="text" name="name"></p>`

方式二： 使用for循环标签

<form action="" method="post">
        {% csrf_token %}
        {% for field in form %}
            <p>
                <label>{
       { field.label }}</label>
                {
       { field }} <span>{
       { field.errors.0 }}</span>
            </p>
        {% endfor %}
        <input type="submit" value="注册">
    </form>

使用`{ { form.字段.label }}`可以渲染出相应的label标签  
注意：label标签默认显示的是字段名，如果想修改label标签显示的内容，可以在创建forms类时指定

class UserForm(forms.Form):
        name = forms.CharField(min_length=4,label="用户名")
        email=forms.EmailField(label="邮箱")

使用`label`参数进行指定，用这个`UserForm`渲染出的效果相当于

<p>用户名：{
       { form.name }}</p>  
    <p>邮箱：{
       { form.email }}</p>

方式三:

<p>方式三</p>
    <form action="" method="post">
        {% csrf_token %}
        {
       { form.as_ul }}
        <input type="submit" value="注册">
    </form>

使用`{ { form.as_ul }}`可以自动渲染所有字段，每个字段使用label和input渲染，并且用`ul`包裹  
还可以选择用`as_p()`,`as_table()`分别是用`p`，`table`标签包裹

### 2.2 使用forms显示重置界面 ###

当用户表单输入错误时，我们可能自己传入参数，设置各个input的value值，来渲染出一个重置页面，使用forms组件，可以快速渲染出一个重置界面  
只需简单设置几步即可

def register(request):
        if request.method =="POST":
            form = UserForm(request.POST)
            if form.is_valid():
                return HttpResponse("ok")
            else:
                return render(request,"register.html",locals())
        else:
            form = UserForm()
            return render(request,"register.html",locals())

简单说，如果用户使用浏览器访问页面时，发送的是get请求，我们使用`form = UserForm()`传入一个没有参数的forms对象，在浏览器中，将自动渲染出各个字段的空白标签  
如果用户提交表单时，我们实例化一个`form = UserForm(request.POST)`带有参数的forms对象，同样的，浏览器中会渲染出提交表单传入的参数内容。  
也就是说，输入错误时，返回的表单中用户输入的内容不会为空，会是用户上次输入错误的内容

### 2.3 如何显示错误信息 ###

如果我们想在校验数据之后，将错误信息输入到HTML页面上，我们可以这样做

#### 2.31 首先将实例化的forms对象传入HTML ####

form = UserForm()
    return render(request,"register.html",locals())

这样直接将局部变量全部当映射到HTML模板中（包括form）

#### 2.32 在HTML模板中调用相应的对象 ####

<form action="" method="post">
        {% csrf_token %}
        <p>用户名：{
       { form.name }}<span>{
       { form.name.errors.0 }}</span></p>
        <p>密码：{
       { form.pwd }}<span>{
       { form.pwd.errors.0 }}</span></p>
        <p>再次确认密码：{
       { form.re_pwd }}<span>{
       { form.re_pwd.errors.0 }}</span></p>
        <p>邮箱：{
       { form.email }}<span>{
       { form.email.errors.0 }}</span></p>
        <p>电话：{
       { form.tel }}<span>{
       { form.tel.errors.0 }}</span></p>
        <input type="submit" value="注册">
    </form>

使用`{ { form.字段.errors.0 }}`标签 如果相应字段错误，可以渲染出相应的错误信息（`{ {form.字段.errors}}`是一个错误列表，我们使用`{ { form.字段.errors.0 }}`只取出第一个错误信息）

### 2.4 forms的参数配置 ###

使用`widgets`模块，我们可以给forms类中的字段设置相应的参数

#### 2.41 导入模块 ####

`form django.forms import widgets`

#### 2.42 设置forms组件在模板中生成的元素类型 ####

如果我们设置一个校验字段为`CharField`类型，那么在HTML模板中生成的标签即为`<input type='text'>`类型  
如果我们想修改生成的标签类型，怎么办？  
示例：  
`pwd =forms.CharField(min_length=4,widget=widgets.PasswordInput())`  
使用`widget`参数可以设置标签类型，`PasswordInput()`代表将自动生成\`\`\`类型标签

#### 2.43 设置forms组件在模板中生成元素的属性 ####

如果我们想给每一个生成的元素中默认添加某些属性，我们可以在元素类型函数中使用`attrs`参数  
示例：`name = forms.CharField(min_length=4,widget=widgets.TextInput(attrs={"class":"form-control"}))`  
在每个默认生成的元素中添加`class`属性，值为`form-control`  
通过attrs中存放需要设置键值对

### 2.5 校验的局部钩子 ###

如果上述对字段的校验条件太少，不能满足我们的需要，我们可以对每个字段自定义校验的内容，就要使用局部钩子  
使用方法

#### 2.51 原理 ####

当我们调用forms对象下的`s_valid()`函数时，将会进行字段校验；校验成功放入clean\_data字典中，校验失败抛出异常，然后异常处理函数将校验失败的字段和错误信息存入errors字典中。而在django校验成功时，特意留下一个钩子，用来给用户自定义函数  
django部分代码：

if hasattr(self, 'clean_%s' % name):
        value = getattr(self, 'clean_%s' % name)()
        self.cleaned_data[name] = value

#### 2.52 先导入错误类型 ####

`from django.core.exceptions import ValidationError`  
`ValidationError`是用来抛出异常时的错误类型

#### 2.53 然后在forms类中创建一个`clean_字段`的函数 ####

`def clean_name(self):`

#### 2.54 使用`cleaned_data`获取校验成功的值 ####

`val = self.cleaned_data.get("name")`  
使用`cleaned_data`可以获取的校验成功的字典

#### 2.55 示例 ####

验证手机号码字段是否是十一位

def clean_tel(self):
        val = self.cleaned_data.get("tel")
        if len(val)==11:
            return val
        else:
            raise ValidationError("手机号位数错误")

取出由forms校验成功的电话号码，对其进行校验，如果满足条件，将原来取出的字段原样返回，否则抛出异常

### 2.6 全局钩子 ###

如果我们想对多个字段之间的关系进行校验，比如说确认密码和密码需要相同，但用局部钩子只能对单个字段的值进行校验。这是候我们需要全局钩子  
第一步，同样导入`ValidationError`类型的错误

#### 2.61 原理 ####

django同时也留一个`clean`函数，当用户想要对多个字段之间的关系进行校验时，直接覆盖掉这个函数，在函数中写出自己想校验的内容即可  
django中部分代码  
clean代码

def clean(self):
            """
            Hook for doing any extra form-wide cleaning after Field.clean() has been
            called on every field. Any ValidationError raised by this method will
            not be associated with a particular field; it will have a special-case
            association with the field named '__all__'.
            """
            return self.cleaned_data

#### 2.62 在forms类中创建一个`clean`函数 ####

`def clean(self):`

#### 2.63 示例 ####

校验确认密码和密码是否相同

def clean(self):
        pwd = self.cleaned_data.get("pwd")
        re_pwd = self.cleaned_data.get("re_pwd")
        if pwd and re_pwd:
            if pwd == re_pwd:
                return self.cleaned_data
            else:
                raise ValidationError("两次密码不一致")
        return self.cleaned_data

如果校验成功，返回原来的`clean_data`字段，校验失败抛出异常`ValidationError`

注意：

1.  在模板中，单个字段校验失败的错误信息我们可以使用`{ {form.字段.errors}}`  
    而全局钩子抛出的异常会被存入全局错误中，我们需要在python使用`clean_errors = form.errors.get("__all__")`获取全局错误信息，在模板中使用`{ { clean_errors.0 }}`获取错误信息
2.  我们在校验时，还要判断`if pwd and re_pwd:`,代表如果单个字段校验失败，就不执行全局钩子。这样如果密码或者是确认密码格式不对，密码和确认密码也不相同时，只报一个密码或者是确认密码格式错误。

## 3. 中间件 ##

### 3.1 什么是中间件？ ###

request和respone之间的处理程序  
settings.py中MIDDLEWARE数组中存储的就是中间件

MIDDLEWARE = [
        'django.middleware.security.SecurityMiddleware',
        'django.contrib.sessions.middleware.SessionMiddleware',
        'django.middleware.common.CommonMiddleware',
        'django.middleware.csrf.CsrfViewMiddleware',
        'django.contrib.auth.middleware.AuthenticationMiddleware',
        'django.contrib.messages.middleware.MessageMiddleware',
        'django.middleware.clickjacking.XFrameOptionsMiddleware',
        'app01.my_middlewares.AuthMiddleware',
        'app01.my_middlewares.IpLimitMiddleware',
    ]

中间件流程  
客户端-》wsgiref模块-》中间件-》urls路由控制-》数据库MODEL,HTML模板

### 3.2 自定义中间件 ###

#### 3.21 创建一个存放中间件的文件夹，如my\_middlewares.py ####

#### 3.22 导入相应的类 ####

`from django.utils.deprecation import MiddlewareMixin`

#### 3.23 创建相应的类（必须继承MiddlewareMixin） ####

class CustomerMiddleware(MiddlewareMixin)
        def process_request(self,request):
            print("Customer")

必须有request参数；不用返回值，让其默认返回none

#### 3.24 在MIDDLEWARE数组中注册该中间件 ####

MIDDLEWARE = [
    ...
    ...
    ...
    "app01.my_middlewares.CustomerMiddleware",
    ]

#### 3.25 中间件有什么作用？ ####

只要浏览器访问服务器，就会访问中间件  
作用：大部分视图函数要使用的代码就可以放到中间件中  
比如，将登陆函数放到中间件中，访问服务器就会调用中间件，验证是否登录  
使用中间件限制用户访问的频率

#### 3.26 主要方法 ####

在该类中，主要可以定义一下几个方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>定义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>process_request</code></td> 
   <td><code>def process_request(self,request):</code></td> 
  </tr> 
  <tr> 
   <td><code>process_response</code></td> 
   <td><code>def process_response(self,request,response):</code></td> 
  </tr> 
  <tr> 
   <td><code>process_view</code></td> 
   <td><code>process_view(self, request, callback, callback_args, callback_kwargs)|</code></td> 
  </tr> 
  <tr> 
   <td><code>process_exception</code></td> 
   <td><code>def process_exception(self,request,exception):</code></td> 
  </tr> 
 </tbody> 
</table>

注意：

1.  每个类都必须传入request参数
2.  `process_response`必须有返回值，类型为响应体（传入的`respone`参数为视图函数返回的响应体）
3.  如果中间件1的`process_request`直接返回`HttpRespone`，不会执行后面的中间件，会直接跳到中间件1的`process_respone`
4.  `process_exception`正常情况下不会执行，只有视图函数报错时才会执行;作用：在该函数下返回的响应体会替代原出错时的黄色报错界面,相当于捕获异常，处理异常的函数

**执行顺序**  
正常情况下：  
`process_request`\-》url控制器-》`process_view`\-》视图函数-》`process_response`  
视图函数出错时候  
`process_request`\-》url控制器-》`process_view`\-》视图函数出错-》`process_exception`\-》`process_response`

`setting.py`中`MIDDLEWARE`列表执行顺序  
当有多个中间件时，服务器发过来的数据依次从上向下执行函数，视图函数返回顺序时，从下向上执行  
每个`process_request`将传过来的客户端的请求依次传给下一个`process_request`  
每个`process_response`将传过来的响应体依次传给上一个`process_response`

例如：  
`process_request1`\-》`process_request2`\-》url控制器-》`process_view1`\-》》`process_view2`\-》视图函数出错-》`process_exception2`\-》`process_exception1`\-》`process_response2`\-》`process_response1`

### 3.3 使用示例 ###

#### 3.31 服务器页面加一个用户验证 ####

如果我们想让一些页面在用户登录后才显示，我们除了可以使用用户认证装饰器装饰器以外，还可以使用中间件

from django.utils.deprecation import MiddlewareMixin
    from django.shortcuts import redirect
    from authDemo import settings
    class AuthMiddleware(MiddlewareMixin):
        def process_request(self,request):
            if request.path in settings.WHITE_LIST:
                return None
            #  用户登录验证
            if  not request.user.is_authenticated:
                return redirect("/login/")

`settings.py`里面创建一个`WHITE_LIST`列表，用来存放不需要加用户认证的url，比如登录，注册，注销url  
如果用户没有登录，我们将其页面重定向到`/login/`

#### 3.32 IP访问评率限制 ####

如果我们想限制客户端ip的访问频率，我们可以使用中间件

from django.utils.deprecation import MiddlewareMixin
    from django.shortcuts import redirect,HttpResponse
    from authDemo import settings
    import datetime
    
    class IpLimitMiddleware(MiddlewareMixin):
        def process_request(self,request):
        if request.META.get("HTTP_X_FORWARDED_FOR"):
            ip = request.META["HTTP_X_FORWARDED_FOR"]
        else:
            ip = request.META["REMOTE_ADDR"]
        now_min = datetime.datetime.now().minute
        if ip in settings.BLACK_LIST:  #查询ip是否在黑名单内
            return HttpResponse("你已经被加入黑名单")
        elif ip in settings.IP_LIST:
            if settings.IP_LIST[ip]["min"] == now_min:
                settings.IP_LIST[ip]["times"] += 1
                if settings.IP_LIST[ip]["times"] >= settings.LIMIT_VISIT_TIMES:  #判断用户访问次数是否太快，返回提醒用户
                    if settings.IP_LIST[ip]["times"] >= settings.MAX_VISIT_TIMES: #如果用户访问次数非常多，加入黑名单
                        settings.BLACK_LIST.append(ip)
                    return HttpResponse("访问频率过快")
            else:
                settings.IP_LIST[ip]["times"] = 0
                settings.IP_LIST[ip]["min"] = now_min
        else:
            settings.IP_LIST[ip] = {"times":1,"min":now_min}

1.  `settings.py`里创建一个`IP_LIST`字典，用来存储客户端ip和其他信息（其实可以单独放入数据库一个表中，不过从数据库中读取没有内存中读取快，访问速度会受到影响）
2.  如果用户使用代理`request.META["REMOTE_ADDR"]`抓不到真实地址，所以我们首先使用`request.META["HTTP_X_FORWARDED_FOR"]`来获取用户真实地址
3.  我们将其用户ip和访问次数储存，在`settings.py`中设置一个常量`LIMIT_VISIT_TIMES`，超过这个次数不让用户访问网页;`MAX_VISIT_TIMES`超过这个次数，将这个ip加入黑名单