Django框架

時間 2019-11-17

標籤 django 框架欄目 Python 简体版

原文原文鏈接

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',

1. Django框架 - 19 Django框架總結
2. web框架---Django框架
3. pythonweb框架django框架1
4. python Django框架
5. Django框架
6. 框架Django
7. Django ORM框架
8. django框架
9. Django 框架 # 51
10. Django 框架
更多相關文章...
• Docker 架構 - Docker教程
• SSH框架（Struts2+Spring+Hibernate）搭建整合詳細步驟 - Spring教程
• 適用於PHP初學者的學習線路和建議
• 常用的分佈式事務解決方案

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。