Django框架

2019年11月17日阅读数：407

这篇文章主要向大家介绍Django框架,主要内容包括基础应用、实用技巧、原理机制等方面，希望对大家有所帮助。

Web框架之Django：

请给做者点赞 —> 原文连接

（1）简介：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
         
         
         
          
           
           
          Django是一个由Python写成开源的重量级Web应用框架，采用MTV的框架模式。它最初是被开发来用于管理劳伦斯出版集团旗下的一些以新闻内容为主的网站的，便是CMS（内容管理系统）软件。并于2005年7月在BSD许可证下发布。这套框架是以比利时的吉普赛爵士吉他手Django Reinhardt来命名的。Django的优点在于：大而全，框架自己集成了ORM、模型绑定、模板引擎、缓存、Session等诸多功能。

（2）Django的处理流程：

当用户发出HTTP请求，URLhandler接收用户请求，根据开发人员设置的路由规则匹配相应的处理类根据请求的类型判断调用的HTTP方法
若是须要链接数据库，Views中的函数将会调用Models的方法，不然直接去Template中取出HTML页面直接返回
调用Models的时候，Models会去数据库读取数据再返回给Views
通过渲染页面一块儿将最终的HTML页面返回给页面

☆MTV与MVC：

MTV和MVC的思想是同样的的，只是思想的体现有所不一样。javascript

MVC：M管理应用程序的状态，并约束改变状态的行为，通常叫作业务规则；V负责把数据格式化后呈现给用户查看；C接收用户操做，根据访问模型获取数据，并调用视图显示这些数据，控制器（处理器）用于将模型与视图隔离并成为两者之间的联系纽带。html

MTV：M表明数据存取层，也就是Model，改为处理与数据相关的全部事务如何存取，如何验证数据的有效性，包含哪些行为与数据相关；T指的是表现层，该层处理与现实相关的行为，如何在页面文档中显示数据，展示内容，也就是Template；V表明业务逻辑层，该层包含存取模型及调取恰当模板的相关逻辑。java

☆Django版的MTV：

Django也是一个MVC框架。可是在Django中，控制器接受用户输入的部分由框架自行处理，因此 Django 里更关注的是模型（Model）、模板(Template)和视图（Views），称为 MTV模式。node

☆Django设计MVC优美哲学：

1.对象关系映射 (ORM,object-relational mapping)：python

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          以Python类形式定义你的数据模型，ORM将模型与关系数据库链接起来，你将获得一个很是容易使用的数据库API，同时你也能够在Django中使用原始的SQL语句。

2.URL 分派：mysql

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          使用正则表达式匹配URL，你能够设计任意的URL，没有框架的特定限定。像你喜欢的同样灵活。

3.模版系统：jquery

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          使用Django强大而可扩展的模板语言，能够分隔设计、内容和Python代码。而且具备可继承性。

4.表单处理：git

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          你能够方便的生成各类表单模型，实现表单的有效性检验。能够方便的从你定义的模型实例生成相应的表单。

5.Cache系统：web

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          能够挂在内存缓冲或其它的框架实现超级缓冲一一实现你所须要的粒度。

6.会话(session)：ajax

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          用户登陆与权限检查，快速开发用户会话功能。

7.国际化:

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          内置国际化系统，方便开发出多种语言的网站。

8.自动化的管理界面(Model)：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          不须要你花大量的工做来建立人员管理和更新内容。Django自带一个ADMIN site,相似于内容管理系统

（3）Django的经常使用命令：

建立程序
- django-admin startproject sitename # 在当前目录下建立一个Django程序
启动服务器
- python manage.py runserver ip:port # 启动服务器，默认是127.0.0.1:8000
建立APP
- python manage.py startapp appname # 建立APP
同步数据库
- python manage.py syncdb# 同步数据库，Django 1.7及以上版本须要用如下的
建立数据配置文件
- python manage.py makemigrations # 建立数据配置文件，显示并记录全部数据的改动
建立表结构
- python manage.py migrate #建立表结构，将改动更新到数据库
建立超级管理员
- python manage.py createsuperuser # 建立超级管理员
启动命令行模式
- python manage.py dbshell # 数据库命令行
查看命令列表
- python manage.py # 查看命令列表

（4）Django数据库相关：

☆默认使用SQLite3数据库的配置：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          DATABASES = { 
          
          
             'default': { 
          
                 'ENGINE': 'django.db.backends.sqlite3', 
          
                 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), 
          
             } 
          
         }

☆MySQL的配置：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          DATABASES = { 
          
          
             'default': { 
          
             'ENGINE': 'django.db.backends.mysql', 
          
             'NAME':'',   # 数据库应该以utf-8编码以支持中文 
          
             'USER': '', 
          
             'PASSWORD': '', 
          
             'HOST': '', 
          
             'PORT': '', 
          
             } 
          
         }

导入 PyMySQL模块

因为Python开发经常使用Python3.x，Django链接数据库的时候使用的是MySQL的MySQLdb模块，然而在Python3中尚未此模块，所以须要使用pymysql进行代替，下面的配置代码写入到项目目录的init.py中便可：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          import pymysql 
          
          
         pymysql.install_as_MySQLdb()

☆PostgreSQL数据库的配置：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          DATABASES = { 
          
          
             'default': { 
          
                 'NAME': '', 
          
                 'ENGINE': 'django.db.backends.postgresql_psycopg2', 
          
                 'USER': '', 
          
                 'PASSWORD': '' 
          
             }

☆Oracle数据库的配置：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          DATABASES = { 
          
          
             'default': { 
          
                 'ENGINE': 'django.db.backends.oracle', 
          
                 'NAME': '', 
          
                 'USER': 'r', 
          
                 'PASSWORD': '', 
          
                 'HOST': '', 
          
                 'PORT': '', 
          
             } 
          
         }

Django框架对于开发者而言高度透明化，对于不一样数据库的具体使用方法是一致的，改变数据库类型只须要变更上述配置便可。

☆Django中的Model数据库操做：

Django提供了一个抽象层（“Model”）来构建和管理Web应用程序的数据。Django中遵循 Code Frist 的原则，即：根据代码中定义的类来自动生成数据库表。关系对象映射（Object Relational Mapping，简称ORM）。

建立Django项目后的目录结构：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          ├── app0  # app应用目录 
          
          
         │   ├── admin.py 
          
         │   ├── apps.py 
          
         │   ├── __init__.py 
          
         │   ├── migrations 
          
         │   │   └── __init__.py 
          
         │   ├── models.py 
          
         │   ├── tests.py 
          
         │   └── views.py 
          
         ├── DjangoAllNotes  # 与项目同名的项目目录 
          
         │   ├── __init__.py 
          
         │   ├── __pycache__ 
          
         │   │   ├── __init__.cpython-36.pyc 
          
         │   │   └── settings.cpython-36.pyc 
          
         │   ├── settings.py  # 公用的Django配置文件 
          
         │   ├── urls.py 
          
         │   └── wsgi.py 
          
         ├── manage.py 
          
         └── template

★建立基本表结构：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          在 **Django** 中，每一张数据表就是一个类，这些类存在于每一个 app 目录的 **models.py** 文件中，执行 **python manage.py makemigrations**  会根据 **models.py** 生成配置文件，再执行 **python manage.py migrate** 将会链接数据库并建立表结构。

# file:models.py

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          from django.db import models 
          
          
         \# Create your models here. 
          
         class UserInfo(models.Model): 
          
             username = models.CharField(max_length=32) 
          
             password = models.CharField(max_length=64) 
          
             age = models.IntegerField() 
          
             email = models.EmailField() 
          
             other = models.TextField()

执行命令： python manage.py makemigrations

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          D:\Codes\Python\DjangoAllNotes>python manage.py makemigrations 
          
          
         Migrations for 'app0': 
          
           app0\migrations\0001_initial.py 
          
             \- Create model UserInfo

执行命令:python manage.py migrate

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          D:\Codes\Python\DjangoAllNotes>python manage.py migrate 
          
          
         Operations to perform: 
          
           Apply all migrations: admin, app0, auth, contenttypes, sessions 
          
         Running migrations: 
          
           Applying contenttypes.0001_initial... OK 
          
           Applying auth.0001_initial... OK 
          
           Applying admin.0001_initial... OK 
          
           Applying admin.0002_logentry_remove_auto_add... OK 
          
           Applying app0.0001_initial... OK 
          
           Applying contenttypes.0002_remove_content_type_name... OK 
          
           Applying auth.0002_alter_permission_name_max_length... OK 
          
           Applying auth.0003_alter_user_email_max_length... OK 
          
           Applying auth.0004_alter_user_username_opts... OK 
          
           Applying auth.0005_alter_user_last_login_null... OK 
          
           Applying auth.0006_require_contenttypes_0002... OK 
          
           Applying auth.0007_alter_validators_add_error_messages... OK 
          
           Applying auth.0008_alter_user_username_max_length... OK 
          
           Applying sessions.0001_initial... OK 
              
           D:\Codes\Python\DjangoAllNotes>

可视化以下：

其余的字段参数：

null = True # 数据库字段是否能够为空
blank = True # django的 Admin 中添加数据时是否可容许空值
primary_key = False # 主键，对AutoField设置主键后，就会代替原来的自增 id 列
auto_now # 自动建立，不管添加或修改，都是当前操做的时间
auto_now_add # 自动建立永远是建立时的时间
选择：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          GENDER_CHOICE = ( 
          
          
         (u'男',u'Male'), 
          
         (u'女',u'Female'), 
          
         ) 
         gender = models.CharField(max_length=2,choices = GENDER_CHOICE)

max_length # 长度，是CharField必须属性
default # 默认值
verbose_name # Admin中字段的显示名称
name|db_column # 数据库中的字段名称
unique = True # 不容许重复
db_index = True # 数据库索引
editable = True # 在Admin中是否能够编辑
error_messages = None # 错误提示
auto_created = False # 自动建立

16.help_text # 在Admin中提示帮助信息

validators = []
*upload-to**

其余的字段：

1. models.AutoField

自增列，int类型，若是没有设置，默认会生成一个名称为id的列，若是要显示一个自定义的自增列，必须将其设置为主键

2. models.CharField

字符串字段，必须设置max_length属性

3. models.BooleanField

布尔类型，在数据库中的类型使用tinyint类型构造实现，不能为空

4. models.ComaSeparatedIntegerField

用逗号分割的数字，在数据库中是varchar类型，继承自CharField，因此必须 max_lenght 属性

5. models.DateField

日期类型，在数据库中对应date类型，auto_now = True 则每次更新都会更新这个时间；auto_now_add 则只是第一次建立添加，以后的更新再也不改变。

6. models.DateTimeField

日期类型，在数据库中对应datetime，auto_now = True 则每次更新都会更新这个时间；auto_now_add 则只是第一次建立添加，以后的更新再也不改变。

7. models.Decimal

十进制小数类型，在数据库中对应decimal类型，必须指定整数位max_digits和小数位decimal_places

8. models.EmailField

字符串类型（正则表达式邮箱），在数据库中对应varchar类型

9. models.FloatField

浮点类型，在数据库中对应double类型

10. models.IntegerField　

整型，在数据库中对应int类型

11. models.BigIntegerField　

长整形

    
    
     
     
      
      
     
     
     
     
      
      
       
       
        
        
         
          
           
            
           
           
           
           
            
             
             
            1. integer_field_ranges = { 
            
            
           　　'SmallIntegerField': (-32768, 32767), 
            
           　　'IntegerField': (-2147483648, 2147483647), 
            
           　　'BigIntegerField': (-9223372036854775808, 9223372036854775807), 
            
           　　'PositiveSmallIntegerField': (0, 32767), 
            
           　　'PositiveIntegerField': (0, 2147483647), 
            
           }

models.IPAddressField

字符串类型（ip4正则表达式）

models.GenericIPAddressField

字符串类型（ip4和ip6是可选的），参数protocol能够是：both、ipv四、ipv6，验证时，会根据设置报错

models.NullBooleanField

容许为空的布尔类型

models.PositiveIntegerFiel

正数范围的Integer

models.PositiveSmallIntegerField

正数范围的smallInteger

models.SlugField

减号、下划线、字母、数字

models.SmallIntegerField

数字，数据库中的字段有：tinyint、smallint、int、bigint

models.TextField

字符串，在数据库中对应longtext

models.TimeField

时间 HH:MM[:ss[.uuuuuu]]

models.URLField

字符串，地址正则表达式

models.BinaryField

二进制

24.models.ImageField

图片

models.FilePathField

文件

元数据：

db_table = ‘TableName’ # 数据库中生成的名称，使用app名称+下划线+类名
index_tohether = [(‘pub_date’,’deadline’)] # 联合索引
unique_together = ((‘drive’,’ restaurant’)) # 联合惟一索引
verbose_name admin中显示的名称

触发Model中的验证和错误提示有两种方式：

DjangoAdmin中的错误信息会优先根据Admin内部的ModelForm错误信息提示，若是都成功，才会再验证Model的字段并显示指定的错误信息。

更改Admin中的错误提示：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          from django.contrib import admin 
          
          
         \# Register your models here. 
          
         \# file:admin.py 
          
         from django.contrib import admin 
          
         from app0 import models 
          
         from django import forms 
          
         class UserInfoForm(forms.ModelForm): 
          
             username = forms.CharField(error_messages={'required': '用户名不能为空.'}) 
          
             email = forms.EmailField(error_messages={'invalid': '邮箱格式错误.'}) 
          
             age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'}) 
          
           
          
             class Meta: 
          
                 model = models.UserInfo 
          
                 fields = "__all__" 
          
         class UserInfoAdmin(admin.ModelAdmin): 
          
             form = UserInfoForm 
          
           
          
         admin.site.register(models.UserInfo, UserInfoAdmin)

调用Model对象的clean_fields方法：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          \# file:models.py 
          
          
         class UserInfo(models.Model): 
          
         nid = models.AutoField(primary_key=True) 
          
         username = models.CharField(max_length=32) 
          
         email = models.EmailField(error_messages={'invalid': '格式错.'}) 
          
         \# file:views.py 
          
         def index(request): 
          
            obj = models.UserInfo(username='11234', email='uu') 
          
            try: 
          
                print(obj.clean_fields()) 
          
            except Exception as e: 
          
                print(e) 
          
         return HttpResponse('ok') 
          
         \# Model的clean方法是一个钩子，可用于定制操做，如：上述的异常处理。

★连表操做：

一对多：models.ForeignKey(其余表)

多对多：models.ManyToManyField(其余表)

一对一：models.OneToOneField(其余表)

1. 一对多：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          ForeignKey(ForeignObject) # ForeignObject(RelatedField) 
          
          
         to,                            # 要进行关联的表名 
          
         to_field=None,               # 要关联的表中的字段名称 
          
         on_delete=None,              # 当删除关联表中的数据时，当前表与其关联的行的行为 
          
         \- models.CASCADE，删除关联数据，与之关联也删除 
          
         \- models.DO_NOTHING，删除关联数据，引起错误IntegrityError 
          
         \- models.PROTECT，删除关联数据，引起错误ProtectedError 
          
         \- models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段须要设置为可空） 
          
         \- models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段须要设置默认值） 
          
         \- models.SET，删除关联数据， 
          
         a. 与之关联的值设置为指定值，设置：models.SET(值) 
          
         b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

2. 一对一：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          OneToOneField(ForeignKey) 
          
          
         to,                         # 要进行关联的表名 
          
         to_field=None               # 要关联的表中的字段名称 
          
         on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为 
          
         一对一其实就是 一对多 + 惟一索引，当两个类之间有继承关系时，默认会建立一个一对一字段。

3. 多对多:

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          ManyToManyField(RelatedField) 
          
          
         to,                         # 要进行关联的表名 
          
         related_name=None,          # 反向操做时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all() 
          
         related_query_name=None,    # 反向操做时，使用的链接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')

★表的增删改查：

1.对数据进行增长数据：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          \# -*- coding:utf-8 -*- 
          
          
         \# file:views.py 
          
         from django.shortcuts import render, HttpResponse 
          
         \# Create your views here. 
          
         def home(request): 
          
             from app01 import models 
          
             models.UserInfo.objects.create(username='haha', password='123', age=20) 
          
             return HttpResponse('Home, 建立数据完成.')

1.1也能够直接传入字典建立：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          def home(request): 
          
          
             from app01 import models 
          
             dic = { 
          
                'username':'tom', 
          
                'password':'123', 
          
                'age':18, 
          
             } 
          
             models.UserInfo.objects.create(**dic) 
          
             return HttpResponse('Home, 建立数据成功.')

2. 删除数据：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          def home(request): 
          
          
             from app01 import models 
          
             models.UserInfo.objects.filter(username='tom').delete()

3.修改数据：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          def home(request): 
          
          
             from app01 import models 
          
             models.UserInfo.objects.filter(age=20).update(age=22) 
          
             models.UserInfo.objects.all().update(age=22)   # 修改所有数据

4.查询数据：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          def home(request): 
          
          
             from app01 import models 
          
             list = models.UserInfo.objects.all()  # 获取所有数据 
          
             models.UserInfo.objects.filter(username='tom').first()   # 获取第一条数据 
          
             获取的数据是个列表，querySet类型。 
          
             for item ini list:       # 遍历列表 
          
                print(item.username)

★使用双下划线链接操做：

1.获取个数：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          models.Tb1.objects.filter(name='seven').count()

2.比较大小：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值 
          
          
         models.Tb1.objects.filter(id__gte=1)             # 获取id大于等于1的值 
          
         models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值 
          
         models.Tb1.objects.filter(id__lte=10)            # 获取id小于10的值 
          
         models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值

3.是否包含：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          models.Tb1.objects.filter(id__in=[11, 22, 33]) 
          
          
         models.Tb1.objects.exclude(id__in=[11, 22, 33])  # 至关于not in

4.是否为空：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          Entry.objects.filter(pub_date__isnull=True)

5.contains：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          models.Tb1.objects.filter(name__contains="ven") 
          
          
         models.Tb1.objects.filter(name__icontains="ven")#icontains大小写不敏感 
          
         models.Tb1.objects.exclude(name__icontains="ven")

6. range范围：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          models.Tb1.objects.filter(id__range=[1, 2]) # 至关于SQL中的between and

7.其余的操做：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          startswith，istartswith, endswith, iendswith,

8. order by：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          models.Tb1.objects.filter(name='seven').order_by('id')    # asc 
          
          
         models.Tb1.objects.filter(name='seven').order_by('-id')   # desc

9. group by：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          from django.db.models import Count, Min, Max, Sum 
          
          
         models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num')) 
          
         \# 至关于：SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

10. limit 、offset：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          models.Tb1.objects.all()[10:20]

11. regex正则匹配，iregex 不区分大小写：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          Entry.objects.get(title__regex=r'^(An?|The) +') 
          
          
         Entry.objects.get(title__iregex=r'^(an?|the) +')

12.日期：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1)) 
          
          
         Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

13.年月日周时分秒：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          Entry.objects.filter(pub_date__year=2005) 
          
          
         Entry.objects.filter(pub_date__year__gte=2005) 
          
           
          
         Entry.objects.filter(pub_date__month=12) 
          
         Entry.objects.filter(pub_date__month__gte=6) 
          
           
          
         Entry.objects.filter(pub_date__day=3) 
          
         Entry.objects.filter(pub_date__day__gte=3) 
          
           
          
         Entry.objects.filter(pub_date__week_day=2) 
          
         Entry.objects.filter(pub_date__week_day__gte=2) 
          
           
          
         Entry.objects.filter(timestamp__hour=23) 
          
         Entry.objects.filter(time__hour=5) 
          
         Entry.objects.filter(timestamp__hour__gte=12) 
          
           
          
         Entry.objects.filter(timestamp__minute=29) 
          
         Entry.objects.filter(time__minute=46) 
          
         Entry.objects.filter(timestamp__minute__gte=29) 
          
           
          
         Entry.objects.filter(timestamp__second=31) 
          
         Entry.objects.filter(time__second=2) 
          
         Entry.objects.filter(timestamp__second__gte=31)

14.extra：

extra(select=None, where=None, params=None, tables=None, order_by=None, select_params=None)，有些状况下，Django的查询语法难以简单的表达复杂的 WHERE 子句，对于这种状况, Django 提供了 extra() QuerySet 修改机制，它能在 QuerySet生成的SQL从句中注入新子句。不管什么时候你都须要很是当心的使用extra(). 每次使用它时，您都应该转义用户可使用params控制的任何参数，以防止SQL注入攻击。因为产品差别的缘由，这些自定义的查询难以保障在不一样的数据库之间兼容(由于你手写 SQL 代码的缘由)，并且违背了 DRY 原则，因此如非必要，仍是尽可能避免写 extra。

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,)) 
          
          
         Entry.objects.extra(where=['headline=%s'], params=['Lennon']) 
          
         Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) 
          
         Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

★F和Q：

from django.db.models import F

models.Tb1.objects.update(num=F('num')+1) #F用于拿到原始数据

# ##方式一：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          from django.db.models import Q 
          
          
         con = Q() 
          
           
          
         q1 = Q() 
          
         q2 = Q() 
          
           
          
         q1.connecter = 'OR' 
          
           
          
         q1.children.append(('id', 1)) 
          
         q1.children.append(('id', 2)) 
          
         q1.children.append(('id', 3)) 
          
           
          
         q2.children.append(('c1', 10)) 
          
         q2.children.append(('c1', 23)) 
          
         q2.children.append(('c1', 12)) 
          
           
          
         con.add('q1', 'AND') 
          
         con.add('q1', 'AND') 
          
           
          
         models.Tb.objects.filter(con)

# ##方式二：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          Q(nid__gt=10) 
          
          
         Q(nid=8) | Q(nid__gt=10) 
          
         Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')

★执行原生SQL：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          from django.db import connection, connections 
          
          
         cursor = connection.cursor()  
          
         \# 实际上是cursor = connections['default'].cursor() 
          
         cursor.execute("""SELECT * from auth_user where id = %s""", [1]) 
          
         row = cursor.fetchone()

★利用双下划线和 _set 将表之间的操做链接起来：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          1.建立表结构： 
          
          
         from django.db import models 
          
           
          
         \# Create your models here. 
          
         class UserProfile(models.Model): 
          
             user_info = models.OneToOneField('UserInfo') 
          
             username = models.CharField(max_length=64) 
          
         password = models.CharField(max_length=64) 
          
           
          
             def __unicode__(self): 
          
                 return self.username 
          
           
          
         class UserInfo(models.Model): 
          
             user_type_choice = ( 
          
                 (0, u'普通用户'), 
          
                 (1, u'高级用户'), 
          
             ) 
          
             user_type = models.IntegerField(choices=user_type_choice) 
          
             name = models.CharField(max_length=32) 
          
             email = models.CharField(max_length=32) 
          
             address = models.CharField(max_length=128) 
          
           
          
             def __unicode__(self): 
          
                 return self.name 
          
           
          
         class UserGroup(models.Model): 
          
             caption = models.CharField(max_length=64) 
          
             user_info = models.ManyToManyField('UserInfo') 
          
             def __unicode__(self): 
          
                 return self.caption 
          
           
          
         class Host(models.Model): 
          
             hostname = models.CharField(max_length=64) 
          
             ip = models.GenericIPAddressField() 
          
             user_group = models.ForeignKey('UserGroup') 
          
           
          
             def __unicode__(self): 
          
                 return self.hostname

2.一对一操做：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          user_info_obj = models.UserInfo.objects.filter(id=1).first() 
          
          
         print user_info_obj.user_type 
          
         print user_info_obj.get_user_type_display() 
          
         print user_info_obj.userprofile.password 
          
           
          
         user_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first() 
          
         print user_info_obj.keys() 
          
         print user_info_obj.values()

3.一对多操做：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          dic = { 
          
          
             "hostname": "名字1", 
          
             "ip": "192.168.1.1", 
          
             "user_group_id": 1,   # 加对象则为"user_group" 
          
         } 
          
         models.Host.objects.create(**dic)

# 正向查找一对多

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          host_obj = models.Host.objects.all() 
          
          
         print(type(host_obj),host_obj)           
          
         \# <class 'django.db.models.query.QuerySet'> 
          
         \# <QuerySet [<Host: 名字1>]> 
          
         for item in host_obj: 
          
             print(item.hostname) 
          
             print(item.user_group.caption) 
          
             print(item.user_group.user_info.values()) 
          
         \# <QuerySet [{'name': 'nick', 'user_type': 1, 'id': 1, 'email': '630571017@qq.com', 'address': '128号'}]> 
          
         usergroup_obj = models.Host.objects.filter(user_group__caption='标题1') 
          
         print(usergroup_obj)

# 反向查找一对多

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          usergroup_obj = models.UserGroup.objects.get(id=1) 
          
          
         print(usergroup_obj.caption) 
          
         ret = usergroup_obj.host_set.all()  # 全部关于id=1的host 
          
         print(ret) 
          
         obj = models.UserGroup.objects.filter(host__ip='192.168.1.1').values('host__id', 'host__hostname') 
          
         print(obj)      
          
         \# <QuerySet [{'host__id': 1, 'host__hostname': '名字1'}]>

4.多对多操做：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          user_info_obj = models.UserInfo.objects.get(name='nick') 
          
          
         user_info_objs = models.UserInfo.objects.all() 
          
           
          
         group_obj = models.UserGroup.objects.get(caption='CTO') 
          
         group_objs = models.UserGroup.objects.all()

# 添加数据

#group_obj.user_info.add(user_info_obj)

\#group_obj.user_info.add(*user_info_objs)

# 删除数据

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          #group_obj.user_info.remove(user_info_obj) 
          
          
         \#group_obj.user_info.remove(*user_info_objs)

# 添加数据

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          #user_info_obj.usergroup_set.add(group_obj) 
          
          
         \#user_info_obj.usergroup_set.add(*group_objs)

# 删除数据

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          #user_info_obj.usergroup_set.remove(group_obj) 
          
          
         \#user_info_obj.usergroup_set.remove(*group_objs)

# 获取数据

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          [#print group_obj.user_info.all()]() 
          
          
         \#print group_obj.user_info.all().filter(id=1)

# 获取数据

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          #print user_info_obj.usergroup_set.all() 
          
          
         \#print user_info_obj.usergroup_set.all().filter(caption='CTO') 
          
         \#print user_info_obj.usergroup_set.all().filter(caption='DBA')

# 添加多对多

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          # userinfo_id_1 = models.UserInfo.objects.filter(id=1) 
          
          
         \# usergroup_id_1 = models.UserGroup.objects.filter(id=1).first() 
          
         \# usergroup_id_1.user_info.add(*userinfo_id_1)

（5）Django路由系统：

Django的路由系统本质就是URL正则与调用的视图函数之间的映射表，URL的加载是从配置中开始的。

这样Django也就很好的支持了静态路由，基于正则的动态路由，以及二级路由，一样开发人员也能够自行使用基于请求方法的路由。

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          urlpatterns = [ 
          
          
             url(正则表达式, view函数, 参数, 别名), 
          
             Some... 
          
         ]

参数是可选的要传递给视图函数的默认参数（字典形式）

别名也是可选的

例如：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          urlpatterns = [ 
          
          
             url(r'^admin/', admin.site.urls), 
          
             url(r'^one',views.one2one), 
          
             url(r'^two',views.one2many), 
          
             url(r'^three',views.many2many), 
          
         ]

其余使用正则的例子：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          urlpatterns = [ 
          
          
             url(r'^articles/2003/$', views.special_case_2003), 
          
             url(r'^articles/([0-9]{4})/$', views.year_archive), 
          
             url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive), 
          
             url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail), 
          
         ]

说明：

要捕获从URL中的值，用括号括起来，会当参数传入 views 视图。
没有必要添加一个斜线，由于每一个URL都有。例如，它^{articles不是}/articles。
在'r'前面的每一个正则表达式字符串中是可选的，但建议。它告诉Python字符串是“原始” -没有什么字符串中应该进行转义。

使用正则分组：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          # URL 规则 
          
         urlpatterns = [ 
          
             url(r’^index\d{2}/$’,views.index), 
          
         url(r’^index2/(?P<id>\d{3})/$’,views.index2), 
          
         url(r’^index3/(?P<id>\d{3})/(?P<name>\w+)’,views.index3), 
          
         ] 
          
         # 视图函数 
          
         def index(request): 
          
             return HttpResponse(‘OK’) 
          
         def index2(request, id): 
          
             print(“id=”+str(id)) 
          
             return HttpResponse(‘OK’) 
          
         def index3(request, id, name): 
          
             print(“id=”+str(id)) 
          
             print(“name=”+str(name)) 
          
             return HttpResponse(‘OK’)

Django的二级路由示例：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          extra_patterns = [ 
          
          
             url(r'^reports/$', credit_views.report), 
          
             url(r'^reports/(?P<id>[0-9]+)/$', credit_views.report), 
          
             url(r'^charge/$', credit_views.charge), 
          
         ] 
          
         from django.conf.urls import include, url 
          
         urlpatterns = [ 
          
             url(r'^$', main_views.homepage), 
          
             url(r'^help/', include('apps.help.urls')), # 这里是个文件 
          
             url(r'^credit/', include(extra_patterns)), 
          
         ] 
          
         URLconfs 有一个钩子可让你加入一些额外的参数到view函数中： 
          
         from django.conf.urls import url 
          
         from . import views 
          
         urlpatterns = [ 
          
             url(r'^blog/(?P<year>[0-9]{4})/$', views.year_archive, {'foo': 'bar'}), 
          
         ]

须要注意的是，当你加上参数时，对应函数views.year_archive必须加上一个参数，参数名也必须命名为 foo，这样就实现了参数名的静态绑定，放置参数顺序出错。

（6）Django的View视图函数：

HTTP中产生的两大对象：

HTTP请求：HttpRequest
HTTP应答：HttpResponse

☆HttpRequest对象：

当请求一个HTML页面的时候，Django将会建立一个HttpRequest对象包含原数据的请求，而后Django加载适合的视图，经过HTTPRequest做为视图函数的一地个参数。每一个视图负责返回一个HttpResponse响应。

HttpRequest对象的属性：

path：请求页面的全路径，不包括域名
method：请求中使用的HTTP方法的字符串表示。全大写表示。例如

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          if  req.method=="GET": 
          
          
         Some... 
          
         elseif req.method=="POST": 
          
         Some...

GET: 包含全部HTTP GET参数的类字典对象

POST：包含全部HTTP POST参数的类字典对象

服务器收到空的POST请求的状况也是可能发生的，也就是说，表单form经过HTTP POST方法提交请求，可是表单中可能没有数据，所以不能使用if req.POST来判断是否使用了HTTP POST 方法；应该使用if req.method=="POST"。

COOKIES:
- *包含全部cookies的标准Python字典对象；keys和values都是字符串。**
FILES：
- 包含全部上传文件的类字典对象；FILES中的每个Key都是标签中 name属性的值，FILES中的每个value同时也是一个标准的python字典对象，包含下面三个Keys：
- filename：上传文件名，用字符串表示
- content_type:上传文件的Content Type
- content：上传文件的原始内容

5. user：

是一个django.contrib.auth.models.User对象，表明当前登录的用户。若是访问用户当前没有登录，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。能够经过user的is_authenticated()方法来辨别用户是否登录：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          if req.user.is_authenticated()； 
          
          
         只有激活Django中的AuthenticationMiddleware时该属性才可用。

6. session：

惟一可读写的属性，表明当前会话的字典对象；本身有激活Django中session支持时该属性才可用。

7. META：

一个标准的Python字典包含全部可用的HTTP头。可用标题取决于客户端和服务器，一些例子：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          CONTENT_LENGTH         – 请求体的长度（一个字符串）。 
          
          
         CONTENT_TYPE           – 请求体的类型。 
          
         HTTP_ACCEPT            - 为响应–能够接受的内容类型。 
          
         HTTP_ACCEPT_ENCODING – 接受编码的响应 
          
         HTTP_ACCEPT_LANGUAGE – 接受语言的反应 
          
         HTTP_HOST              – 客户端发送的HTTP主机头。 
          
         HTTP_REFERER           – 参考页面 
          
         HTTP_USER_AGENT       – 客户端的用户代理字符串。 
          
         QUERY_STRING          – 查询字符串，做为一个单一的（分析的）字符串。 
          
         REMOTE_ADDR           – 客户端的IP地址 
          
         REMOTE_HOST           – 客户端的主机名 
          
         REMOTE_USER           – 用户经过Web服务器的身份验证。 
          
         REQUEST_METHOD       – 字符串，如"GET"或"POST" 
          
         SERVER_NAME           – 服务器的主机名 
          
         SERVER_PORT           – 服务器的端口（一个字符串）。

☆HttpResponse对象属性：

对于HtppResponse对象来讲，是由Django自动建立的牡丹石HTTPResponse对象必须开发人员手动建立，每一个View请求处理方法必须返回一个HTTPResponse对象。

HTTPResponse对象经常使用的方法：

页面渲染，render,render_to_response，推荐使用render，由于render功能更为强大。
页面跳转，redirect
页面传参，locals，能够直接将对应视图中的全部变量所有传递给模板。

示例代码：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          def HandlerName(request): 
          
          
             Some... 
          
             var0, var1 = 1, 2 
          
             Some... 
          
             return render_to_response(‘Home.html’, locals())

对于render的：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          render(request, template_name, context=None, content_type=None, status=None, using=None)

结合给定的模板与一个给定的上下文，返回一个字典HttpResponse在渲染文本对象。

request和template_name是必须参数，request指的是传来的resquest，template_name指的是HTML模板或模板序列的名称，若是给定的是序列，那么序列中的第一个模板将被引用。
context 一组字典的值添加到模板中。默认状况下，这是一个空的字典。
content_type MIME类型用于生成文档。
status 为响应状态代码。默认值为200
using 这个名字一个模板引擎的使用将模板。

（7）Django模板和模板语言：

要使用模板，必然会牵扯到静态文件的配置，好比CSS，Js等，在Django的项目目录中的settings.py中追加：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          STATICFILES_DIRS =  
          
         (os.path.join(BASE_DIR,'static'), 
         )

其中static是存放静态文件的目录，这样就能在HTML页面中引用特效或者图片了。对于模板，其实就是读取模板，模板中嵌套着标签，而后渲染数据的时候，从Model中取出数据插入到模板中，最后用户接收到请求的响应。

模板语言：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          # 标签: 
          
          
         {{ item }} 
          
         # 控制语句 
          
         # 循环 
          
         {% for item in list %}  <a>{{ item }}</a>  {% endfor %} 
          
         # 判断 
          
         {% if ordered_warranty %}  {% else %} {% endif %}

继承:

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          父模板：{% block title %}{% endblock %} 
          
          
         子模板：{% extends "base.html" %}和{% block title %}{% endblock %}

其余经常使用方法：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          # 使用过滤器 
          
         {{ item.event_start|date:"Y-m-d H:i:s"}} 
          
         {{ bio|truncatewords:"30" }} 
          
         {{ my_list|first|upper }} 
          
         {{ name|lower }}

在字典中取出数据使用dict.some的形式

自定义标签：

由于在模板语言中不能进行逻辑运算，因此在Django中提供两种自定义的标签，

一种是simple_tag，
另外一种是filter。

simple_tag能够传递任意参数，可是不能用做布尔判断，filter最多只能传递2个参数，能够用作布尔判断，一样的，simple_tag和filter的实现是相似的。

示例代码：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          \# file:mycustomtags.py 
          
          
         from django import template 
          
         from django.utils.safestring import mark_safe 
          
         from django.template.base import resolve_variable, Node, TemplateSyntaxError 
          
           
          
         register = template.Library() 
          
         @register.simple_tag 
          
         def my_simple_time(v1,v2,v3): 
          
             return  v1 + v2 + v3 
          
          
         @register.simple_tag 
          
         def my_input(id,arg): 
          
             result = "<input type='text' id='%s' class='%s' />" %(id,arg,) 
          
             return mark_safe(result)

在HTML文件中导入以前建立的Python文件，使用load命令：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          {% load mycustomtags %}

使用simple_tag：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          {% my_simple_time 1 2 3%} 
          
          
         {% my_input 'id_username' 'hide'%}

须要在项目目录中的settings.py中配置当前的APP：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          INSTALLED_APPS = ( 
          
          
         'app0',  # app的名称 
          
         )

（8）Django的中间件：

中间件示意图：

每一次用户的请求都会一层一层穿过中间件，当不符合中间件的业务逻辑的时候就会直接返回，用户请求到达不了最里层的业务逻辑处理函数，这样能够自定义中间件，在不使用Nginx等第三方工具的时候统计每次用户的访问次数。

中间件其实就是一个Python文件，可是其中的类须要继承自

from django.utils.deprecation import MiddlewareMixin，

在这个文件中能够建立以下5中函数：

# 请求到来以前执行

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          def process_request(self, request): 
          
          
         Some...

# 数据返回以前执行

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          def process_reponse(self, request, response): 
          
          
         Some... 
          
         return response  # 必须返回请求的数据

# 执行view中的方法以前执行

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          def process_view(self, request, callback, callback_args, callback_kwargs)

# 程序出错时执行

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          def process_exception(self, request, exception)

# 渲染模板数据时执行

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          def process_template_response(self, request, response)

须要在项目目录中的settings.py文件中设置：

  
  
   
   
    
    
   
   
   
   
    
    
     
     
      
      
       
        
         
          
         
         
         
         
          
           
           
          MIDDLEWARE = [ 
          
          
         'middle.first.First', 
          
         'django.middleware.security.SecurityMiddleware', 
          
         'django.contrib.sessions.middleware.SessionMiddleware',