django框架(1)

時間 2019-11-20

標籤 django 框架欄目 Python 简体版

原文原文鏈接

一什麼是web框架?

框架，即framework，特指爲解決一個開放性問題而設計的具備必定約束性的支撐結構，使用框架能夠幫你快速開發特定的系統，簡單地說，就是你用別人搭建好的舞臺來作表演。php

對於全部的Web應用，本質上其實就是一個socket服務端，用戶的瀏覽器其實就是一個socket客戶端css

import socket
 
def handle_request(client):
 
    buf = client.recv(1024)
    client.send("HTTP/1.1 200 OK\r\n\r\n".encode("utf8"))
    client.send("<h1 style='color:red'>Hello, yuan</h1>".encode("utf8"))
 
def main():
 
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('localhost',8001))
    sock.listen(5)
 
    while True:
        connection, address = sock.accept()
        handle_request(connection)
        connection.close()
 
if __name__ == '__main__':
 
    main()

最簡單的Web應用就是先把HTML用文件保存好，用一個現成的HTTP服務器軟件，接收用戶請求，從文件中讀取HTML，返回。html

若是要動態生成HTML，就須要把上述步驟本身來實現。不過，接受HTTP請求、解析HTTP請求、發送HTTP響應都是苦力活，若是咱們本身來寫這些底層代碼，還沒開始寫動態HTML呢，就得花個把月去讀HTTP規範。前端

正確的作法是底層代碼由專門的服務器軟件實現，咱們用Python專一於生成HTML文檔。由於咱們不但願接觸到TCP鏈接、HTTP原始請求和響應格式，因此，須要一個統一的接口，讓咱們專心用Python編寫Web業務。python

這個接口就是WSGI：Web Server Gateway Interface。mysql

第一步jquery

 1 from wsgiref.simple_server import make_server
 2  
 3  
 4 def application(environ, start_response):
 5     start_response('200 OK', [('Content-Type', 'text/html')])
 6     return [b'<h1>Hello, web!</h1>']
 7  
 8  
 9 httpd = make_server('', 8080, application)
10  
11 print('Serving HTTP on port 8000...')
12 # 開始監聽HTTP請求:
13 httpd.serve_forever()

View Code

 1 整個application()函數自己沒有涉及到任何解析HTTP的部分，也就是說，底層代碼不須要咱們本身編寫，
 2 咱們只負責在更高層次上考慮如何響應請求就能夠了。
 3  
 4 application()函數必須由WSGI服務器來調用。有不少符合WSGI規範的服務器，咱們能夠挑選一個來用。
 5  
 6 Python內置了一個WSGI服務器，這個模塊叫wsgiref   
 7      
 8      
 9 application()函數就是符合WSGI標準的一個HTTP處理函數，它接收兩個參數：
10  
11         //environ：一個包含全部HTTP請求信息的dict對象；
12          
13         //start_response：一個發送HTTP響應的函數。
14  
15 在application()函數中，調用：
16  
17 start_response('200 OK', [('Content-Type', 'text/html')])
18  
19 就發送了HTTP響應的Header，注意Header只能發送一次，也就是隻能調用一次start_response()函數。
20 start_response()函數接收兩個參數，一個是HTTP響應碼，一個是一組list表示的HTTP Header，每
21 個Header用一個包含兩個str的tuple表示。
22  
23 一般狀況下，都應該把Content-Type頭髮送給瀏覽器。其餘不少經常使用的HTTP Header也應該發送。
24  
25 而後，函數的返回值b'<h1>Hello, web!</h1>'將做爲HTTP響應的Body發送給瀏覽器。
26  
27 有了WSGI，咱們關心的就是如何從environ這個dict對象拿到HTTP請求信息，而後構造HTML，
28 經過start_response()發送Header，最後返回Body。

View Code

第二步nginx

 1 print(environ['PATH_INFO'])
 2     path=environ['PATH_INFO']
 3     start_response('200 OK', [('Content-Type', 'text/html')])
 4     f1=open("index1.html","rb")
 5     data1=f1.read()
 6     f2=open("index2.html","rb")
 7     data2=f2.read()
 8  
 9     if path=="/yuan":
10         return [data1]
11     elif path=="/alex":
12         return [data2]
13     else:
14         return ["<h1>404</h1>".encode('utf8')]

View Code

第三步git

 1 from wsgiref.simple_server import make_server
 2  
 3 def f1():
 4     f1=open("index1.html","rb")
 5     data1=f1.read()
 6     return [data1]
 7  
 8 def f2():
 9     f2=open("index2.html","rb")
10     data2=f2.read()
11     return [data2]
12  
13 def application(environ, start_response):
14  
15     print(environ['PATH_INFO'])
16     path=environ['PATH_INFO']
17     start_response('200 OK', [('Content-Type', 'text/html')])
18  
19  
20     if path=="/tomp":
21         return f1()
22  
23     elif path=="/tom":
24         return f2()
25  
26     else:
27         return ["<h1>404</h1>".encode("utf8")]
28  
29  
30 httpd = make_server('', 8502, application)
31  
32 print('Serving HTTP on port 8084...')
33  
34 # 開始監聽HTTP請求:
35 httpd.serve_forever()

View Code

第四步程序員

 1 from wsgiref.simple_server import make_server
 2  
 3  
 4 def f1(req):
 5     print(req)
 6     print(req["QUERY_STRING"])
 7  
 8     f1=open("index1.html","rb")
 9     data1=f1.read()
10     return [data1]
11  
12 def f2(req):
13  
14     f2=open("index2.html","rb")
15     data2=f2.read()
16     return [data2]
17  
18 import time
19  
20 def f3(req):        #模版以及數據庫
21  
22     f3=open("index3.html","rb")
23     data3=f3.read()
24     times=time.strftime("%Y-%m-%d %X", time.localtime())
25     data3=str(data3,"utf8").replace("!time!",str(times))
26  
27  
28     return [data3.encode("utf8")]
29  
30  
31 def routers():
32  
33     urlpatterns = (
34         ('/yuan',f1),
35         ('/alex',f2),
36         ("/cur_time",f3)
37     )
38     return urlpatterns
39  
40  
41 def application(environ, start_response):
42  
43     print(environ['PATH_INFO'])
44     path=environ['PATH_INFO']
45     start_response('200 OK', [('Content-Type', 'text/html')])
46  
47  
48     urlpatterns = routers()
49     func = None
50     for item in urlpatterns:
51         if item[0] == path:
52             func = item[1]
53             break
54     if func:
55         return func(environ)
56     else:
57         return ["<h1>404</h1>".encode("utf8")]
58  
59 httpd = make_server('', 8518, application)
60  
61 print('Serving HTTP on port 8084...')
62  
63 # 開始監聽HTTP請求:
64  
65 httpd.serve_forever()

View Code

二MVC和MTV模式

MVC模式:把web應用分爲模型(M),控制器(C),視圖(V)三層; 他們之間以一種插件似的,鬆耦合的方式來鏈接在一塊兒

模型負責業務對象與數據庫的對象(ORM),視圖負責與用戶的交互(頁面),控制器(C)接受用戶的輸入調用模型和視圖而完成用戶的請求.

django的MTV模式本質上與MVC模式沒有什麼差異,也是各組件之間爲了保持鬆耦合關係,只是定義上有些許不一樣,django的MTV分別表明:

　　Model(模型):負責業務對象與數據庫的對象(ORM)

　　Template(模板):負責如何把頁面展現給用戶

　　View(視圖):負責業務邏輯,並在適合的時候調用Model和Template

　　此外,django還有一個url分發器,它的做用是將一個個URL的頁面請求分發給不一樣的view處理,view再調用相應的Model和Template

三 django的流程和命令行工具

django實現流程

 1 django
 2         安裝:  pip3 install django
 3 
 4             添加環境變量
 5 
 6 1     建立project
 7     django-admin startproject mysite
 8 
 9 ---mysite
10 
11     ---settings.py
12     ---url.py
13     ---wsgi.py
14 
15 ---manage.py(啓動文件)
16 
17 2     建立APP
18     python  mannage.py startapp app01
19 
20 3      settings配置
21 TEMPLATES
22  
23        STATICFILES_DIRS=(
24             os.path.join(BASE_DIR,"statics"),   #注意：靜態文件括號裏是元組，就算一個元素也要加上逗號
25         )
26  
27        STATIC_URL = '/static/'
28        #  咱們只能用 STATIC_URL，但STATIC_URL會按着你的STATICFILES_DIRS去找#4  根據需求設計代碼
29            url.py
30            view.py
31 
32     #5  使用模版
33        render(req,"index.html")  
34  
35     #6  啓動項目
36        python manage.py runserver  127.0.0.1:8090
37  
38     #7  鏈接數據庫，操做數據
39        model.py

django的命令行工具

django-admin.py是django的一個用於管理任務的命令行工具,manage.py是對django-admin.py的簡單包裝,每個django project裏都會有一個manage.py

<1>建立一個django工程:django-admin.py startproject mysite

　　當前目錄下會生成mysite的工程,目錄結構以下:

　　manage.py-------django項目裏面的工具,經過它能夠調用django shell和數據庫等

　　settings.py-------包含了項目的默認設置,包括數據庫信息,調試標誌以及其餘一些工做的變量

　　urls.py-------負責把Url模式映射到應用程序

<2>在mysite目錄下建立blog應用:python manage.py startapp blog

<3>啓動django項目:python manage.py runserver 8080

　這樣咱們的django就啓動起來了!當咱們訪問: http://127.0.0.1:8080/時就能夠看到:

<4>生成同步數據庫的腳本: python manage.py makemigrations(此時並無連接到數據庫,在migrations文件夾中生成腳本文件)

　　　　同步數據庫: python manage.py migrate

　　注意: 在開發過程當中, 數據庫同步誤操做之後,不免會遇到後面不能同步成功的狀況,解決這個問題的一個簡單粗暴方法就是把migrations目錄下的腳本(除__init__.py以外)所有刪除,再把數據庫刪除以後建立一個新的數庫,數據庫同步操做再從新作一遍

<5>當咱們訪問http://127.0.0.1:8080/admin/時,會出現:

　　因此咱們須要爲進入這個項目的後臺建立超級管理員:

　　python manage.py createsuperuser, 設置好用戶名和密碼後即可登錄了

　　<6>清空數據庫:python manage.py flush

　　<7>查詢某個命令的詳細信息:django-admin.py help startapp

　　　　admin是django自帶的一個後臺數據庫管理系統

　　<8>啓動交互界面: python manage.py shell

　　　　這個命令和直接運行python進入shell的區別是:你能夠在這個shell裏面調用當前項目的models.py中的API,對於操做數據,還有一些小測試很是方便

<9>終端上輸入python manage.py 能夠看到詳細的列表,在忘記子名稱的時候特別有用

四 django的配置文件(settings)

靜態文件設置

  1 1、概述：
  2  
  3      #靜態文件交由Web服務器處理，Django自己不處理靜態文件。簡單的處理邏輯以下(以nginx爲例)：
  4  
  5      #          URI請求-----> 按照Web服務器裏面的配置規則先處理，以nginx爲例，主要求配置在nginx.
  6                              #conf裏的location
  7  
  8                          |---------->若是是靜態文件，則由nginx直接處理
  9  
 10                          |---------->若是不是則交由Django處理，Django根據urls.py裏面的規則進行匹配
 11  
 12     # 以上是部署到Web服務器後的處理方式，爲了便於開發，Django提供了在開發環境的對靜態文件的處理機制，方法是這樣：
 13  
 14     #一、在INSTALLED_APPS裏面加入'django.contrib.staticfiles',
 15  
 16     #二、在urls.py裏面加入
 17        if settings.DEBUG: 
 18            urlpatterns += patterns('', url(r'^media/(?P<path>.*)$',
 19            'django.views.static.serve', {'document_root': settings.MEDIA_ROOT }),  
 20             url(r'^static/(?P<path>.*)$',
 21           'django.views.static.serve',{'document_root':settings.STATIC_ROOT}), ) 
 22  
 23     # 三、這樣就能夠在開發階段直接使用靜態文件了。
 24  
 25 2、MEDIA_ROOT和MEDIA_URL
 26  
 27         #而靜態文件的處理又包括STATIC和MEDIA兩類，這每每容易混淆，在Django裏面是這樣定義的：
 28  
 29         #MEDIA:指用戶上傳的文件，好比在Model裏面的FileFIeld，ImageField上傳的文件。若是你定義
 30  
 31         #MEDIA_ROOT=c:\temp\media，那麼File=models.FileField(upload_to="abc/")＃，上傳的文件就會被保存到c:\temp\media\abc 
 32         #eg：
 33             class blog(models.Model): 
 34                    Title=models.charField(max_length=64) 
 35                    Photo=models.ImageField(upload_to="photo")
 36         #     上傳的圖片就上傳到c:\temp\media\photo，而在模板中要顯示該文件，則在這樣寫
 37         #在settings裏面設置的MEDIA_ROOT必須是本地路徑的絕對路徑，通常是這樣寫:
 38                  BASE_DIR= os.path.abspath(os.path.dirname(__file__)) 
 39                  MEDIA_ROOT=os.path.join(BASE_DIR,'media/').replace('\\','/')
 40  
 41         #MEDIA_URL是指從瀏覽器訪問時的地址前綴，舉個例子：
 42             MEDIA_ROOT=c:\temp\media\photo 
 43             MEDIA_URL="/data/"
 44         #在開發階段,media的處理由django處理：
 45  
 46         #    訪問http://localhost/data/abc/a.png就是訪問c:\temp\media\photo\abc\a.png
 47  
 48         #    在模板裏面這樣寫<img src="{{MEDIA_URL}}abc/a.png">
 49  
 50         #    在部署階段最大的不一樣在於你必須讓web服務器來處理media文件，所以你必須在web服務器中配置，
 51         #  以便能讓web服務器能訪問media文件
 52         #    以nginx爲例，能夠在nginx.conf裏面這樣：
 53  
 54                  location ~/media/{
 55                        root/temp/
 56                        break;
 57                     }
 58  
 59         #    具體能夠參考如何在nginx部署django的資料。
 60  
 61 3、STATIC_ROOT和STATIC_URL、
 62     STATIC主要指的是如css,js,images這樣文件，在settings裏面能夠配置STATIC_ROOT和STATIC_URL,
 63     配置方式與MEDIA_ROOT是同樣的，可是要注意
 64  
 65     #STATIC文件通常保存在如下位置：
 66  
 67     #一、STATIC_ROOT：在settings裏面設置，通常用來放一些公共的js,css,images等。
 68  
 69     #二、app的static文件夾，在每一個app所在文夾都可以創建一個static文件夾，而後當運行collectstatic時，
 70     #    Django會遍歷INSTALL_APPS裏面全部app的static文件夾，將裏面全部的文件複製到STATIC_ROOT。所以，
 71     #   若是你要創建可複用的app，那麼你要將該app所須要的靜態文件放在static文件夾中。
 72  
 73     # 也就是說一個項目引用了不少app，那麼這個項目所須要的css,images等靜態文件是分散在各個app的static文件的，比
 74     #  較典型的是admin應用。當你要發佈時，須要將這些分散的static文件收集到一個地方就是STATIC_ROOT。
 75  
 76     #三、STATIC文件還能夠配置STATICFILES_DIRS，指定額外的靜態文件存儲位置。
 77     #  STATIC_URL的含義與MEDIA_URL相似。
 78  
 79     # ----------------------------------------------------------------------------
 80     #注意1:
 81         #爲了後端的更改不會影響前端的引入，避免形成前端大量修改
 82  
 83         STATIC_URL = '/static/'               #引用名
 84         STATICFILES_DIRS = (
 85             os.path.join(BASE_DIR,"statics")  #實際名 ,即實際文件夾的名字
 86         )
 87  
 88         #django對引用名和實際名進行映射,引用時,只能按照引用名來,不能按實際名去找
 89         #<script src="/statics/jquery-3.1.1.js"></script>
 90         #------error－－－－－不能直接用，必須用STATIC_URL = '/static/':
 91         #<script src="/static/jquery-3.1.1.js"></script>
 92  
 93     #注意2(statics文件夾寫在不一樣的app下,靜態文件的調用):
 94  
 95         STATIC_URL = '/static/'
 96  
 97         STATICFILES_DIRS=(
 98             ('hello',os.path.join(BASE_DIR,"app01","statics")) ,
 99         )
100  
101         #<script src="/static/hello/jquery-1.8.2.min.js"></script>
102  
103     #注意3:
104         STATIC_URL = '/static/'
105         {% load staticfiles %}
106        # <script src={% static "jquery-1.8.2.min.js" %}></script>

其餘重要參數設置:

1 APPEND_SLASH
2        Default: True
3        When set to True, if the request URL does not match any of the patterns in the URLconf and it
4        doesn’t end in a slash, an HTTP redirect is issued to the same URL with a slash appended. Note
5        that the redirect may cause any data submitted in a POST request to be lost.

五 django url(路由系統)

URL配置(URLconf)就像Django 所支撐網站的目錄。它的本質是URL模式以及要爲該URL模式調用的視圖函數之間的映射表；你就是以這種方式告訴Django，對於這個URL調用這段代碼，對於那個URL調用那段代碼。

1 urlpatterns = [
2     url(正則表達式, views視圖函數，參數，別名),
3 ]

參數說明:

　　一個正則表達式字符串

　　一個可調用對象,一般爲一個視圖函數或一個指定視圖函數路徑的字符串

　　可選的要傳遞給視圖函數的默認參數(字典形式)

　　一個可選的name參數

 1 from django.conf.urls import url
 2 from django.contrib import admin
 3  
 4 from app01 import views
 5  
 6 urlpatterns = [
 7  
 8     url(r'^articles/2003/$', views.special_case_2003),   #從頭至尾徹底匹配
 9  
10     #url(r'^articles/[0-9]{4}/$', views.year_archive),
11  
12     url(r'^articles/([0-9]{4})/$', views.year_archive),  #無名分組，括號裏的參數會傳遞給視圖函數，一樣的，視圖函數也須要對應參數來接收，一個括號表明一個參數
13  
14     url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
15  
16     url(r'^articles/(？P[0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),#有名分組，括號裏的參數會傳遞給視圖函數，且視圖函數須要接收的參數名字需與有名分組名字一致
17  
18 ]

include用法:當項目中建立多個app時,在路由映射時經過include方法能夠將用戶訪問的目標路徑映射到對應的app中的視圖函數中

　　注意:

　　　　1.在主路由系統中須要導入include

　　　　2.映射格式:app.urls

 1 #At any point, your urlpatterns can 「include」 other URLconf modules. This
 2 #essentially 「roots」 a set of URLs below other ones.
 3  
 4 #For example, here’s an excerpt of the URLconf for the Django website itself.
 5 #It includes a number of other URLconfs:
 6  
 7  
 8 from django.conf.urls import include, url
 9  
10 urlpatterns = [
11    url(r'^admin/', admin.site.urls),
12    url(r'^blog/', include('blog.urls')),
13 ]

六 django views(視圖函數)

http請求中產生兩個核心對象:

　　http請求: HttpRequest對象

　　http響應:HttpResponse對象

所在位置: django.http

以前咱們用到的參數request就是HttpRequest 檢測方法: isinstance(request,HttpRequest)

1 HttpRequest對象的屬性和方法:

 1 path:                請求頁面的全路徑,不包括域名
 2 
 3 method:            請求使用的Http方法的字符串表示.全大寫表示.例如
 4             
 5         if  req.method=="GET":
 6 
 7                   do_something()
 8 
 9          elseif req.method=="POST":
10 
11                    do_something_else()
12 
13 GET:     包含全部HTTP GET參數的類字典對象
14 
15 POST:    包含全部HTTP POST參數的類字典對象
16 
17             服務器收到空的POST請求的狀況也是可能發生的,也就是說,表單 
18             form經過HTTP POST方法提交請求,可是表單中可能沒有數據,因 
19             此不能使用 if  req.POST來判斷是否使用了HTTP POST方法;應 
20             該使用 if req.method == "POST"    
21 
22 COOKIES:  包含全部cookies的標準python字典對象;keys和values都是 
23              字符串
24 
25 FILES:    包含全部上傳文件的類字典對象;FILES中的每個key都是<input  type="file" name></input>
26     
27           filename:    上傳文件名,用字符串表示
28           content_type:  上傳文件的 Content Type
29           content:      上傳文件的原始內容
30 
31 user:      是一個django.contrib.auth.models.User對象,表明當前登錄的用戶.若是訪問用戶沒有登錄,user將被初始化爲django.contrib.auth.models.AnonymousUser的實例.能夠經過user的is_authenticated()方法來辨別用戶是否登錄
32 if req.user.is_authenticated();只有激活django中的AuthentionMiddlewar時該屬性才能夠用
33 
34 session:  惟一可讀寫的屬性,表明當前會話的字典對象;本身有激活django 
35               中的session支持時該方法
36 
37 方法:
38 get_full_path(),   好比：http://127.0.0.1:8000/index33/?name=123 ,req.get_full_path()獲得的結果就是/index33/?name=123 
39 
40 req.path:/index33

注意一個經常使用方法:request.POST.getlist(" "),用於接受的value不爲單個元素時使用

2 HttpResponse對象

對於HttpRequest對象來講,是由django自動建立的,可是,HttpResponse對象就必須咱們本身建立.每一個view請求處理方法必須返回一個HttpResponse對象.

HttpResponse類在django.http.HttpResponse

在HttpResponse對象上擴展的經常使用方法:

1 頁面渲染:       render()            render_to_response(),
2 
3 頁面跳轉:        redirect("路徑")
4 locals():      能夠直接將函數中全部的變量傳給模板

七 Template基礎

模板系統的介紹

對頁面設計進行的任何改變都必須對 Python 代碼進行相應的修改。站點設計的修改每每比底層 Python 代碼的修改要頻繁得多，所以若是能夠在不進行 Python 代碼修改的狀況下變動設計，那將會方便得多。

Python 代碼編寫和 HTML 設計是兩項不一樣的工做，大多數專業的網站開發環境都將他們分配給不一樣的人員（甚至不一樣部門）來完成。設計者和HTML/CSS的編碼人員不該該被要求去編輯Python的代碼來完成他們的工做。

程序員編寫 Python代碼和設計人員製做模板兩項工做同時進行的效率是最高的，遠勝於讓一我的等待另外一我的完成對某個既包含 Python又包含 HTML 的文件的編輯工做。

基於這些緣由，將頁面的設計和Python的代碼分離開會更乾淨簡潔更容易維護。咱們可使用 Django的 模板系統 (Template System)來實現這種模式，這就是本章要具體討論的問題。

**************************************************************模板語法****************************************

一模板的組成

組成:HTML代碼 + 邏輯控制代碼

二邏輯控制代碼的組成

1 變量(使用雙大括號來引用變量)

語法格式： {{var_name}}

－－－－－－Template和Context對象

 1 >>> python manange.py shell  (進入該django項目的環境)
 2 >>> from django.template import Context, Template
 3 >>> t = Template('My name is {{ name }}.')
 4 >>> c = Context({'name': 'Stephane'})
 5 >>> t.render(c)
 6 'My name is Stephane.'
 7  
 8  
 9 # 同一模板，多個上下文，一旦有了模板對象，你就能夠經過它渲染多個context，不管什麼時候咱們均可以
10 # 像這樣使用同一模板源渲染多個context，只進行 一次模板建立而後屢次調用render()方法渲染會
11 # 更爲高效：
12 # Low
13 for name in ('John', 'Julie', 'Pat'):
14     t = Template('Hello, {{ name }}')
15     print t.render(Context({'name': name}))
16  
17 # Good
18 t = Template('Hello, {{ name }}')
19 for name in ('John', 'Julie', 'Pat'):
20     print t.render(Context({'name': name}))

View Code

Django 模板解析很是快捷。大部分的解析工做都是在後臺經過對簡短正則表達式一次性調用來完成。這和基於 XML 的模板引擎造成鮮明對比，那些引擎承擔了 XML 解析器的開銷，且每每比 Django 模板渲染引擎要慢上幾個數量級。

 1 from django.shortcuts import render,HttpResponse
 2 from django.template.loader import get_template #記得導入
 3 # Create your views here.
 4  
 5  
 6 import datetime
 7 from django.template import Template,Context
 8  
 9 # def current_time(req):
10     #原始的視圖函數
11     # now=datetime.datetime.now()
12     # html="<html><body>如今時刻：<h1>%s.</h1></body></html>" %now
13     # return HttpResponse(html)
14  
15  
16  
17 # def current_time(req):
18  
19       #django模板修改的視圖函數
20 #     now=datetime.datetime.now()
21 #     t=Template('<html><body>如今時刻是:<h1 style="color:red">{{current_date}}</h1></body></html>')
22       #t=get_template('current_datetime.html')
23 #     c=Context({'current_date':now})
24 #     html=t.render(c)
25 #     return HttpResponse(html)
26  
27 #另外一種寫法(推薦)
28  
29 def current_time(req):
30  
31     now=datetime.datetime.now()
32  
33     return render(req, 'current_datetime.html', {'current_date':now})
34  
35 推薦方式

View Code

-------------------深度變量查詢(萬能的點)

在到目前爲止的例子中，咱們經過 context 傳遞的簡單參數值主要是字符串，然而，模板系統可以很是簡潔地處理更加複雜的數據結構，例如list、dictionary和自定義的對象。

在 Django 模板中遍歷複雜數據結構的關鍵是句點字符 (.)

 1 #最好是用幾個例子來講明一下。
 2 # 首先，句點可用於訪問列表索引，例如：
 3  
 4 >>> from django.template import Template, Context
 5 >>> t = Template('Item 2 is {{ items.2 }}.')
 6 >>> c = Context({'items': ['apples', 'bananas', 'carrots']})
 7 >>> t.render(c)
 8 'Item 2 is carrots.'
 9  
10 #假設你要向模板傳遞一個 Python 字典。 要經過字典鍵訪問該字典的值，可以使用一個句點：
11 >>> from django.template import Template, Context
12 >>> person = {'name': 'Sally', 'age': '43'}
13 >>> t = Template('{{ person.name }} is {{ person.age }} years old.')
14 >>> c = Context({'person': person})
15 >>> t.render(c)
16 'Sally is 43 years old.'
17  
18 #一樣，也能夠經過句點來訪問對象的屬性。 比方說， Python 的 datetime.date 對象有
19 #year 、 month 和 day 幾個屬性，你一樣能夠在模板中使用句點來訪問這些屬性：
20  
21 >>> from django.template import Template, Context
22 >>> import datetime
23 >>> d = datetime.date(1993, 5, 2)
24 >>> d.year
25 >>> d.month
26 >>> d.day
27 >>> t = Template('The month is {{ date.month }} and the year is {{ date.year }}.')
28 >>> c = Context({'date': d})
29 >>> t.render(c)
30 'The month is 5 and the year is 1993.'
31  
32 # 這個例子使用了一個自定義的類，演示了經過實例變量加一點(dots)來訪問它的屬性，這個方法適
33 # 用於任意的對象。
34 >>> from django.template import Template, Context
35 >>> class Person(object):
36 ...     def __init__(self, first_name, last_name):
37 ...         self.first_name, self.last_name = first_name, last_name
38 >>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.')
39 >>> c = Context({'person': Person('John', 'Smith')})
40 >>> t.render(c)
41 'Hello, John Smith.'
42  
43 # 點語法也能夠用來引用對象的方法。 例如，每一個 Python 字符串都有 upper() 和 isdigit()
44 # 方法，你在模板中可使用一樣的句點語法來調用它們：
45 >>> from django.template import Template, Context
46 >>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}')
47 >>> t.render(Context({'var': 'hello'}))
48 'hello -- HELLO -- False'
49 >>> t.render(Context({'var': '123'}))
50 '123 -- 123 -- True'
51  
52 # 注意這裏調用方法時並* 沒有* 使用圓括號 並且也沒法給該方法傳遞參數；你只能調用不需參數的
53 # 方法。

View Code

-------------------變量的過濾器(filter)的使用

 1 語法格式:       {{obj | filter:param}}
 2 
 3 add   :  給變量加上相應的值
 4 
 5 addslashes:      給變量中的引號前加上斜線
 6 
 7 capfirst:        首字母大寫
 8 
 9 cut:        從字符串中移除指定的字符
10 
11 date:       格式化日期字符串
12 
13 default:    若是值是False,就替換成設置的默認值,不然就是用原本的值
14 
15 default_if_none:  若是值是none,就替換成設置的默認值,不然就使用原本的值
16 
17 
18 #實例:
19  
20 #value1="aBcDe"
21 {{ value1|upper }}<br>
22  
23 #value2=5
24 {{ value2|add:3 }}<br>
25  
26 #value3='he  llo wo r ld'
27 {{ value3|cut:' ' }}<br>
28  
29 #import datetime
30 #value4=datetime.datetime.now()
31 {{ value4|date:'Y-m-d' }}<br>
32  
33 #value5=[]
34 {{ value5|default:'空的' }}<br>
35  
36 #value6='<a href="#">跳轉</a>'
37  
38 {{ value6 }}
39  
40 {% autoescape off %}
41   {{ value6 }}
42 {% endautoescape %}
43  
44 {{ value6|safe }}<br>
45  
46 {{ value6|striptags }}
47  
48 #value7='1234'
49 {{ value7|filesizeformat }}<br>
50 {{ value7|first }}<br>
51 {{ value7|length }}<br>
52 {{ value7|slice:":-1" }}<br>
53  
54 #value8='http://www.baidu.com/?a=1&b=3'
55 {{ value8|urlencode }}<br>
56     value9='hello I am tom'

2 標籤(tag)的使用(使用大括號和百分比的組合來表示使用tag)

－－－－－－{% if %} 的使用

{% if %}標籤計算一個變量值，若是是「true」，即它存在、不爲空而且不是false的boolean值,系統則會顯示{% if %}和{% endif %}間的全部內容

 1 {% if num >= 100 and 8 %}
 2  
 3     {% if num > 200 %}
 4         <p>num大於200</p>
 5     {% else %}
 6         <p>num大於100小於200</p>
 7     {% endif %}
 8  
 9 {% elif num < 100%}
10     <p>num小於100</p>
11  
12 {% else %}
13     <p>num等於100</p>
14  
15 {% endif %}  #與if成對出現
16  
17  
18  
19 {% if %} 標籤接受and，or或者not來測試多個變量值或者否認一個給定的變量
20 {% if %} 標籤不容許同一標籤裏同時出現and和or，不然邏輯容易產生歧義，例以下面的標籤是不合法的：
21  
22 {% if obj1 and obj2 or obj3 %}

View Code

－－－－－－{% for %}的使用

{% for %}標籤容許你按順序遍歷一個序列中的各個元素,每次循環模板系統都會渲染{% for %}和{% endfor %}之間的全部內容

 1 <ul>
 2 {% for obj in list %}
 3     <li>{{ obj.name }}</li>
 4 {% endfor %}
 5 </ul>
 6  
 7  
 8 #在標籤裏添加reversed來反序循環列表：
 9  
10     {% for obj in list reversed %}
11     ...
12     {% endfor %}
13  
14 #{% for %}標籤能夠嵌套：
15  
16     {% for country in countries %}
17         <h1>{{ country.name }}</h1>
18         <ul>
19          {% for city in country.city_list %}
20             <li>{{ city }}</li>
21          {% endfor %}
22         </ul>
23     {% endfor %}
24  
25  
26 #系統不支持中斷循環，系統也不支持continue語句，{% for %}標籤內置了一個forloop模板變量，
27 #這個變量含有一些屬性能夠提供給你一些關於循環的信息
28  
29 1，forloop.counter表示循環的次數，它從1開始計數，第一次循環設爲1:
30  
31     {% for item in todo_list %}
32         <p>{{ forloop.counter }}: {{ item }}</p>
33     {% endfor %}
34 2，forloop.counter0 相似於forloop.counter，但它是從0開始計數，第一次循環設爲0
35 3，forloop.revcounter
36 4，forloop.revcounter0
37 5，forloop.first當第一次循環時值爲True，在特別狀況下頗有用：
38  
39      
40     {% for object in objects %}  
41          {% if forloop.first %}<li class="first">{% else %}<li>{% endif %}  
42          {{ object }}  
43         </li> 
44     {% endfor %} 
45      
46 # 富有魔力的forloop變量只能在循環中獲得，當模板解析器到達{% endfor %}時forloop就消失了
47 # 若是你的模板context已經包含一個叫forloop的變量，Django會用{% for %}標籤替代它
48 # Django會在for標籤的塊中覆蓋你定義的forloop變量的值
49 # 在其餘非循環的地方，你的forloop變量仍然可用
50  
51  
52 #{% empty %}
53  
54 {{li }}
55       {%  for i in li %}
56           <li>{{ forloop.counter0 }}----{{ i }}</li>
57       {% empty %}
58           <li>this is empty!</li>
59       {% endfor %}
60  
61 #         [11, 22, 33, 44, 55]
62 #            0----11
63 #            1----22
64 #            2----33
65 #            3----44
66 #            4----55

View Code

－－－－－－{%csrf_token%}：csrf_token標籤

用於生成csrf_token的標籤，用於防治跨站攻擊驗證。注意若是你在view的index裏用的是render_to_response方法，不會生效

其實，這裏是會生成一個input標籤，和其餘表單標籤一塊兒提交給後臺的。

－－－－－－{% url %}: 引用路由配置的地址

1 <form action="{% url "bieming"%}" >
2           <input type="text">
3           <input type="submit"value="提交">
4           {%csrf_token%}
5 </form>

－－－－－－{% with %}:用更簡單的變量名替代複雜的變量名

{% with total=fhjsaldfhjsdfhlasdfhljsdal %} {{ total }} {% endwith %}

－－－－－－{% verbatim %}: 禁止render

1 {% verbatim %}
2          {{ hello }}
3 {% endverbatim %}

－－－－－－{% load %}: 加載標籤庫

3自定義filter和simple_tag

－－－－－－a、在app中建立templatetags模塊(必須的)

－－－－－－b、建立任意 .py 文件，如：my_tags.py

 1 from django import template
 2 from django.utils.safestring import mark_safe
 3  
 4 register = template.Library()   #register的名字是固定的,不可改變
 5  
 6  
 7 @register.filter
 8 def filter_multi(v1,v2):
 9     return  v1 * v2
10  
11  
12 @register.simple_tag
13 def simple_tag_multi(v1,v2):
14     return  v1 * v2
15  
16  
17 @register.simple_tag
18 def my_input(id,arg):
19     result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
20     return mark_safe(result)

View Code

－－－－－－c、在使用自定義simple_tag和filter的html文件中導入以前建立的 my_tags.py ：{% load my_tags %}

－－－－－－d、使用simple_tag和filter（如何調用）

 1 -------------------------------.html
 2 {% load xxx %}   #首行
 3      
 4      
 5      
 6      
 7  # num=12
 8 {{ num|filter_multi:2 }} #24
 9  
10 {{ num|filter_multi:"[22,333,4444]" }}
11  
12  
13 {% simple_tag_multi 2 5 %}  參數不限,但不能放在if for語句中
14 {% simple_tag_multi num 5 %}

View Code

－－－－－－e、在settings中的INSTALLED_APPS配置當前app，否則django沒法找到自定義的simple_tag.

注意：

filter能夠用在if等語句後，simple_tag不能夠

1 {% if num|filter_multi:30 > 100 %}
2     {{ num|filter_multi:30 }}
3 {% endif %}

4 extend模板繼承

--------------------include模板標籤

在講解了模板加載機制以後，咱們再介紹一個利用該機制的內建模板標籤： {% include %} 。該標籤容許在（模板中）包含其它的模板的內容。標籤的參數是所要包含的模板名稱，能夠是一個變量，也能夠是用單/雙引號硬編碼的字符串。每當在多個模板中出現相同的代碼時，就應該考慮是否要使用 {% include %} 來減小重複。

－－－－－－extend(繼承)模板標籤

到目前爲止，咱們的模板範例都只是些零星的 HTML 片斷，但在實際應用中，你將用 Django 模板系統來建立整個 HTML 頁面。這就帶來一個常見的 Web 開發問題：在整個網站中，如何減小共用頁面區域（好比站點導航）所引發的重複和冗餘代碼？

解決該問題的傳統作法是使用 服務器端的 includes ，你能夠在 HTML 頁面中使用該指令將一個網頁嵌入到另外一箇中。事實上， Django 經過剛纔講述的 {% include %} 支持了這種方法。可是用 Django 解決此類問題的首選方法是使用更加優雅的策略—— 模板繼承 。

本質上來講，模板繼承就是先構造一個基礎框架模板，然後在其子模板中對它所包含站點公用部分和定義塊進行重載。

讓咱們經過修改 current_datetime.html 文件，爲 current_datetime 建立一個更加完整的模板來體會一下這種作法：

 1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
 2 <html lang="en">
 3 <head>
 4     <title>The current time</title>
 5 </head>
 6 <body>
 7     <h1>My helpful timestamp site</h1>
 8     <p>It is now {{ current_date }}.</p>
 9   
10     <hr>
11     <p>Thanks for visiting my site.</p>
12 </body>
13 </html>

View Code

這看起來很棒，但若是咱們要爲 hours_ahead 視圖建立另外一個模板會發生什麼事情呢？

 1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
 2 <html lang="en">
 3 <head>
 4     <title>Future time</title>
 5 </head>
 6 <body>
 7     <h1>My helpful timestamp site</h1>
 8     <p>In {{ hour_offset }} hour(s), it will be {{ next_time }}.</p>
 9   
10     <hr>
11     <p>Thanks for visiting my site.</p>
12 </body>
13 </html>

View Code

很明顯，咱們剛纔重複了大量的 HTML 代碼。想象一下，若是有一個更典型的網站，它有導航

條、樣式表，可能還有一些 JavaScript 代碼，事情必將以向每一個模板填充各類冗餘的 HTML 而了結。

解決這個問題的服務器端 include 方案是找出兩個模板中的共同部分，將其保存爲不一樣的模板片斷，而後在每一個模板中進行 include。也許你會把模板頭部的一些代碼保存爲 header.html 文件：

1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
2 <html lang="en">
3 <head>

View Code

你可能會把底部保存到文件 footer.html :

1 <hr>
2     <p>Thanks for visiting my site.</p>
3 </body>
4 </html>

View Code

對基於 include 的策略，頭部和底部的包含很簡單。麻煩的是中間部分。在此範例中，每一個頁面都有一個<h1>My helpful timestamp site</h1> 標題，可是這個標題不能放在 header.html 中，由於每一個頁面的 <title> 是不一樣的。若是咱們將 <h1> 包含在頭部，咱們就不得不包含 <title> ，但這樣又不容許在每一個頁面對它進行定製。何去何從呢？

Django 的模板繼承系統解決了這些問題。你能夠將其視爲服務器端 include 的逆向思惟版本。你能夠對那些不一樣 的代碼段進行定義，而不是共同代碼段。

第一步是定義基礎模板,該框架以後將由子模板所繼承。如下是咱們目前所講述範例的基礎模板：

 1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
 2 <html lang="en">
 3 <head>
 4     <title>{% block title %}{% endblock %}</title>
 5 </head>
 6 <body>
 7     <h1>My helpful timestamp site</h1>
 8     {% block content %}{% endblock %}
 9     {% block footer %}
10     <hr>
11     <p>Thanks for visiting my site.</p>
12     {% endblock %}
13 </body>
14 </html>

View Code

這個叫作 base.html 的模板定義了一個簡單的 HTML 框架文檔，咱們將在本站點的全部頁面中使用。子模板的做用就是重載、添加或保留那些塊的內容。（若是你一直按順序學習到這裏，保存這個文件到你的template目錄下，命名爲 base.html .）

咱們使用模板標籤： {% block %} 。全部的 {% block %} 標籤告訴模板引擎，子模板能夠重載這些部分。每一個{% block %}標籤所要作的是告訴模板引擎，該模板下的這一塊內容將有可能被子模板覆蓋。

如今咱們已經有了一個基本模板，咱們能夠修改 current_datetime.html 模板來使用它：

1 {% extends "base.html" %}
2   
3 {% block title %}The current time{% endblock %}
4   
5 {% block content %}
6 <p>It is now {{ current_date }}.</p>
7 {% endblock %}

View Code

再爲 hours_ahead 視圖建立一個模板，看起來是這樣的：

1 {% extends "base.html" %}
2   
3 {% block title %}Future time{% endblock %}
4   
5 {% block content %}
6 <p>In {{ hour_offset }} hour(s), it will be {{ next_time }}.</p>
7 {% endblock %}

View Code

如下是其工做方式：

在加載 current_datetime.html 模板時，模板引擎發現了 {% extends %} 標籤，注意到該模板是一個子模板。模板引擎當即裝載其父模板，即本例中的 base.html 。此時，模板引擎注意到 base.html 中的三個 {% block %} 標籤，並用子模板的內容替換這些 block 。所以，引擎將會使用咱們在 { block title %} 中定義的標題，對 {% block content %} 也是如此。因此，網頁標題一塊將由{% block title %}替換，一樣地，網頁的內容一塊將由 {% block content %}替換。

注意因爲子模板並無定義 footer 塊，模板系統將使用在父模板中定義的值。父模板 {% block %} 標籤中的內容老是被看成一條退路。繼承並不會影響到模板的上下文。換句話說，任何處在繼承樹上的模板均可以訪問到你傳到模板中的每個模板變量。你能夠根據須要使用任意多的繼承次數。使用繼承的一種常見方式是下面的三層法：

<1> 建立 base.html 模板，在其中定義站點的主要外觀感覺。 這些都是不常修改甚至從不修改的部分。
   <2> 爲網站的每一個區域建立 base_SECTION.html 模板(例如, base_photos.html 和 base_forum.html )。這些模板對base.html 進行拓展，
       幷包含區域特定的風格與設計。
   <3> 爲每種類型的頁面建立獨立的模板，例如論壇頁面或者圖片庫。 這些模板拓展相應的區域模板。

這個方法可最大限度地重用代碼，並使得向公共區域（如區域級的導航）添加內容成爲一件輕鬆的工做。

如下是使用模板繼承的一些訣竅：

<1>若是在模板中使用 {% extends %} ，必須保證其爲模板中的第一個模板標記。 不然，模板繼承將不起做用。
 
 <2>通常來講，基礎模板中的 {% block %} 標籤越多越好。 記住，子模板沒必要定義父模板中全部的代碼塊，所以
    你能夠用合理的缺省值對一些代碼塊進行填充，而後只對子模板所需的代碼塊進行（重）定義。 俗話說，鉤子越
    多越好。
 
 <3>若是發覺本身在多個模板之間拷貝代碼，你應該考慮將該代碼段放置到父模板的某個 {% block %} 中。
    若是你須要訪問父模板中的塊的內容，使用 {{ block.super }}這個標籤吧，這一個魔法變量將會表現出父模
    板中的內容。 若是隻想在上級代碼塊基礎上添加內容，而不是所有重載，該變量就顯得很是有用了。
 
 <4>不容許在同一個模板中定義多個同名的 {% block %} 。 存在這樣的限制是由於block 標籤的工做方式是雙向的。
    也就是說，block 標籤不只挖了一個要填的坑，也定義了在父模板中這個坑所填充的內容。若是模板中出現了兩個
    相同名稱的 {% block %} 標籤，父模板將無從得知要使用哪一個塊的內容。

八 Models

數據庫的配置

1 django默認支持sqlite,mysql,oracle,postgresql數據庫.

　　<1>sqlite

　　　　django默認使用sqlite的數據庫, 默認自帶sqlite的數據庫驅動,引擎名稱： django.db.backends.sqlite3

　　<2>mysql

　　　　引擎名稱：django.db.backends.mysql

2 mysql驅動程序

　　MySQLdb(mysql python)

　　mysqlclient

　　MySQL

　　PyMySQL(純Python的mysql驅動程序)

3 在django的項目中會默認使用sqlite數據庫,在settings裏有以下設置:

若是咱們想要更改數據庫，須要修改以下：

 1 DATABASES = {
 2  
 3     'default': {
 4  
 5         'ENGINE': 'django.db.backends.mysql',
 6  
 7         'NAME': 'books',    #你的數據庫名稱
 8  
 9         'USER': 'root',   #你的數據庫用戶名
10  
11         'PASSWORD': '', #你的數據庫密碼
12  
13         'HOST': '', #你的數據庫主機，留空默認爲localhost
14  
15         'PORT': '3306', #你的數據庫端口
16  
17     }
18  
19 }

mysql配置

 1 NAME即數據庫的名字，在mysql鏈接前該數據庫必須已經建立，而上面的sqlite數據庫下的db.sqlite3則是項目自動建立
 2  
 3 USER和PASSWORD分別是數據庫的用戶名和密碼。
 4  
 5 設置完後，再啓動咱們的Django項目前，咱們須要激活咱們的mysql。
 6  
 7 而後，啓動項目，會報錯：no module named MySQLdb
 8  
 9 這是由於django默認你導入的驅動是MySQLdb，但是MySQLdb對於py3有很大問題，因此咱們須要的驅動是PyMySQL
10  
11 因此，咱們只須要找到項目名文件下的__init__,在裏面寫入：
12  
13 import pymysql
14 pymysql.install_as_MySQLdb()
15

mysql的配置完後的操做

ORM(對象關係映射)

用於實現面向對象編程語言裏不一樣類型系統的數據之間的轉換，換言之，就是用面向對象的方式去操做數據庫的建立表以及增刪改查等操做。

優勢： 1 ORM使得咱們的通用數據庫交互變得簡單易行，並且徹底不用考慮該死的SQL語句。快速開發，由此而來。

2 能夠避免一些新手程序猿寫sql語句帶來的性能問題。

好比咱們查詢User表中的全部字段:

新手可能會用select ＊ from auth_user,這樣會由於多了一個匹配動做而影響效率的。

缺點：1 性能有所犧牲，不過如今的各類ORM框架都在嘗試各類方法，好比緩存，延遲加載登來減輕這個問題。效果很顯著。

2 對於個別複雜查詢，ORM仍然力不從心，爲了解決這個問題，ORM通常也支持寫raw sql。

3 經過QuerySet的query屬性查詢對應操做的sql語句

author_obj=models.Author.objects.filter(id=2)
print(author_obj.query)

表(模型)的建立

實例：咱們來假定下面這些概念，字段和關係

做者模型：一個做者有姓名。

做者詳細模型：把做者的詳情放到詳情表，包含性別，email地址和出生日期，做者詳情模型和做者模型之間是一對一的關係（one－to－one）（相似於每一個人和他的身份證之間的關係），在大多數狀況下咱們沒有必要將他們拆分紅兩張表，這裏只是引出一對一的概念。

出版商模型：出版商有名稱，地址，所在城市，省，國家和網站。

書籍模型：書籍有書名和出版日期，一本書可能會有多個做者，一個做者也能夠寫多本書，因此做者和書籍的關係就是多對多的關聯關係（many－to－many），一本書只應該由一個出版商出版，因此出版商和書籍是一對多關聯關係（one－to－many），也被稱做外鍵

 1 from django.db import models<br>
 2 class Publisher(models.Model):
 3     name = models.CharField(max_length=30, verbose_name="名稱")
 4     address = models.CharField("地址", max_length=50)
 5     city = models.CharField('城市',max_length=60)
 6     state_province = models.CharField(max_length=30)
 7     country = models.CharField(max_length=50)
 8     website = models.URLField()
 9   
10     class Meta:
11         verbose_name = '出版商'
12         verbose_name_plural = verbose_name
13   
14     def __str__(self):
15         return self.name
16   
17 class Author(models.Model):
18     name = models.CharField(max_length=30)
19     def __str__(self):
20         return self.name
21   
22 class AuthorDetail(models.Model):
23     sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))
24     email = models.EmailField()
25     address = models.CharField(max_length=50)
26     birthday = models.DateField()
27     author = models.OneToOneField(Author)    #建立多對多關係的第三張表，數據庫自動建立
28   
29 class Book(models.Model):
30     title = models.CharField(max_length=100)
31     authors = models.ManyToManyField(Author)
32     publisher = models.ForeignKey(Publisher)
33     publication_date = models.DateField()
34     price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
35     def __str__(self):
36         return self.title

View Code

注意1：記得在settings裏的INSTALLED_APPS中加入'app01',而後再同步數據庫。

注意2: models.ForeignKey("Publish") & models.ForeignKey(Publish)，因爲python解釋器加載順序的緣由，若是外鍵裏調用的類名已經在上面被加載了能夠直接寫類名，不用加引號，不然要加上，否則解釋器找不到

分析代碼：

<1> 每一個數據模型都是django.db.models.Model的子類，它的父類Model包含了全部必要的和數據庫交互的方法。並提供了一個簡介漂亮的定義數據庫字段的語法。

<2> 每一個模型至關於單個數據庫表（多對多關係例外，會多生成一張關係表），每一個屬性也是這個表中的字段。屬性名就是字段名，它的類型（例如CharField）至關於數據庫的字段類型（例如varchar）。你們能夠留意下其它的類型都和數據庫裏的什麼字段對應。

<3> 模型之間的三種關係：一對一，一對多，多對多。

一對一：實質就是在主外鍵（author_id就是foreign key）的關係基礎上，給外鍵加了一個UNIQUE＝True的屬性；

一對多：就是主外鍵關係；（foreign key）

多對多：(ManyToManyField) 自動建立第三張表(固然咱們也能夠本身建立第三張表：兩個foreign key)

　　<4>模型經常使用的字段類型參數

  1 <1> CharField
  2         #字符串字段, 用於較短的字符串.
  3         #CharField 要求必須有一個參數 maxlength, 用於從數據庫層和Django校驗層限制該字段所容許的最大字符數.
  4  
  5 <2> IntegerField
  6        #用於保存一個整數.
  7  
  8 <3> FloatField
  9         # 一個浮點數. 必須 提供兩個參數:
 10         #
 11         # 參數    描述
 12         # max_digits    總位數(不包括小數點和符號)
 13         # decimal_places    小數位數
 14                 # 舉例來講, 要保存最大值爲 999 (小數點後保存2位),你要這樣定義字段:
 15                 #
 16                 # models.FloatField(..., max_digits=5, decimal_places=2)
 17                 # 要保存最大值一百萬(小數點後保存10位)的話,你要這樣定義:
 18                 #
 19                 # models.FloatField(..., max_digits=19, decimal_places=10)
 20                 # admin 用一個文本框(<input type="text">)表示該字段保存的數據.
 21  
 22 <4> AutoField
 23         # 一個 IntegerField, 添加記錄時它會自動增加. 你一般不須要直接使用這個字段;
 24         # 自定義一個主鍵：my_id=models.AutoField(primary_key=True)
 25         # 若是你不指定主鍵的話,系統會自動添加一個主鍵字段到你的 model.
 26  
 27 <5> BooleanField
 28         # A true/false field. admin 用 checkbox 來表示此類字段.
 29  
 30 <6> TextField
 31         # 一個容量很大的文本字段.
 32         # admin 用一個 <textarea> (文本區域)表示該字段數據.(一個多行編輯框).
 33  
 34 <7> EmailField
 35         # 一個帶有檢查Email合法性的 CharField,不接受 maxlength 參數.
 36  
 37 <8> DateField
 38         # 一個日期字段. 共有下列額外的可選參數:
 39         # Argument    描述
 40         # auto_now    當對象被保存時,自動將該字段的值設置爲當前時間.一般用於表示 "last-modified" 時間戳.
 41         # auto_now_add    當對象首次被建立時,自動將該字段的值設置爲當前時間.一般用於表示對象建立時間.
 42         #（僅僅在admin中有意義...)
 43  
 44 <9> DateTimeField
 45         #  一個日期時間字段. 相似 DateField 支持一樣的附加選項.
 46  
 47 <10> ImageField
 48         # 相似 FileField, 不過要校驗上傳對象是不是一個合法圖片.#它有兩個可選參數:height_field和width_field,
 49         # 若是提供這兩個參數,則圖片將按提供的高度和寬度規格保存.    
 50 <11> FileField
 51      # 一個文件上傳字段.
 52      #要求一個必須有的參數: upload_to, 一個用於保存上載文件的本地文件系統路徑. 這個路徑必須包含 strftime #formatting,
 53      #該格式將被上載文件的 date/time
 54      #替換(so that uploaded files don't fill up the given directory).
 55      # admin 用一個<input type="file">部件表示該字段保存的數據(一個文件上傳部件) .
 56  
 57      #注意：在一個 model 中使用 FileField 或 ImageField 須要如下步驟:
 58             #（1）在你的 settings 文件中, 定義一個完整路徑給 MEDIA_ROOT 以便讓 Django在此處保存上傳文件.
 59             # (出於性能考慮,這些文件並不保存到數據庫.) 定義MEDIA_URL 做爲該目錄的公共 URL. 要確保該目錄對
 60             #  WEB服務器用戶賬號是可寫的.
 61             #（2） 在你的 model 中添加 FileField 或 ImageField, 並確保定義了 upload_to 選項,以告訴 Django
 62             # 使用 MEDIA_ROOT 的哪一個子目錄保存上傳文件.你的數據庫中要保存的只是文件的路徑(相對於 MEDIA_ROOT).
 63             # 出於習慣你必定很想使用 Django 提供的 get_<#fieldname>_url 函數.舉例來講,若是你的 ImageField
 64             # 叫做 mug_shot, 你就能夠在模板中以 {{ object.#get_mug_shot_url }} 這樣的方式獲得圖像的絕對路徑.
 65 <12> URLField
 66       # 用於保存 URL. 若 verify_exists 參數爲 True (默認), 給定的 URL 會預先檢查是否存在( 即URL是否被有效裝入且
 67       # 沒有返回404響應).
 68       # admin 用一個 <input type="text"> 文本框表示該字段保存的數據(一個單行編輯框)
 69  
 70 <13> NullBooleanField
 71        # 相似 BooleanField, 不過容許 NULL 做爲其中一個選項. 推薦使用這個字段而不要用 BooleanField 加 null=True 選項
 72        # admin 用一個選擇框 <select> (三個可選擇的值: "Unknown", "Yes" 和 "No" ) 來表示這種字段數據.
 73  
 74 <14> SlugField
 75        # "Slug" 是一個報紙術語. slug 是某個東西的小小標記(短籤), 只包含字母,數字,下劃線和連字符.#它們一般用於URLs
 76        # 若你使用 Django 開發版本,你能夠指定 maxlength. 若 maxlength 未指定, Django 會使用默認長度: 50.  #在
 77        # 之前的 Django 版本,沒有任何辦法改變50 這個長度.
 78        # 這暗示了 db_index=True.
 79        # 它接受一個額外的參數: prepopulate_from, which is a list of fields from which to auto-#populate
 80        # the slug, via JavaScript,in the object's admin form: models.SlugField
 81        # (prepopulate_from=("pre_name", "name"))prepopulate_from 不接受 DateTimeFields.
 82  
 83 <13> XMLField
 84         #一個校驗值是否爲合法XML的 TextField,必須提供參數: schema_path, 它是一個用來校驗文本的 RelaxNG schema #的文件系統路徑.
 85  
 86 <14> FilePathField
 87         # 可選項目爲某個特定目錄下的文件名. 支持三個特殊的參數, 其中第一個是必須提供的.
 88         # 參數    描述
 89         # path    必需參數. 一個目錄的絕對文件系統路徑. FilePathField 據此獲得可選項目.
 90         # Example: "/home/images".
 91         # match    可選參數. 一個正則表達式, 做爲一個字符串, FilePathField 將使用它過濾文件名. 
 92         # 注意這個正則表達式只會應用到 base filename 而不是
 93         # 路徑全名. Example: "foo.*\.txt^", 將匹配文件 foo23.txt 卻不匹配 bar.txt 或 foo23.gif.
 94         # recursive可選參數.要麼 True 要麼 False. 默認值是 False. 是否包括 path 下面的所有子目錄.
 95         # 這三個參數能夠同時使用.
 96         # match 僅應用於 base filename, 而不是路徑全名. 那麼,這個例子:
 97         # FilePathField(path="/home/images", match="foo.*", recursive=True)
 98         # ...會匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif
 99  
100 <15> IPAddressField
101         # 一個字符串形式的 IP 地址, (i.e. "24.124.1.30").
102 <16># CommaSeparatedIntegerField
103         # 用於存放逗號分隔的整數值. 相似 CharField, 必需要有maxlength參數.
104

View Code

　　<5>Field重要參數

 1 <1> null ： 數據庫中字段是否能夠爲空
 2  
 3     <2> blank： django的 Admin 中添加數據時是否可容許空值
 4  
 5     <3> default：設定缺省值
 6  
 7     <4> editable：若是爲假，admin模式下將不能改寫。缺省爲真
 8  
 9     <5> primary_key：設置主鍵，若是沒有設置django建立表時會自動加上：
10         id = meta.AutoField('ID', primary_key=True)
11         primary_key=True implies blank=False, null=False and unique=True. Only one
12         primary key is allowed on an object.
13  
14     <6> unique：數據惟一
15  
16     <7> verbose_name　　Admin中字段的顯示名稱
17  
18     <8> validator_list：有效性檢查。非有效產生 django.core.validators.ValidationError 錯誤
19  
20  
21     <9> db_column，db_index 若是爲真將爲此字段建立索引
22  
23     <10>choices：一個用來選擇值的2維元組。第一個值是實際存儲的值，第二個用來方便進行選擇。
24                 如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),)
25                 gender = models.CharField(max_length=2,choices = SEX_CHOICES)

View Code

表的操做(增刪改查)

--------------------------------------------------------------增(create , save)--------------------------------------------

 1 from app01.models import *
 2  
 3     #create方式一:   Author.objects.create(name='Alvin')
 4  
 5     #create方式二:   Author.objects.create(**{"name":"alex"})
 6  
 7     #save方式一:     author=Author(name="alvin")
 8                     author.save()
 9  
10     #save方式二:     author=Author()
11                     author.name="alvin"
12                     author.save()

create,save

重點來了－－－－－－－>那麼如何建立存在一對多或多對多關係的一本書的信息呢？(如何處理外鍵關係的字段如一對多的publisher和多對多的authors)

 1 #一對多(ForeignKey):
 2  
 3     #方式一: 因爲綁定一對多的字段,好比publish,存到數據庫中的字段名叫publish_id,因此咱們能夠直接給這個
 4     #       字段設定對應值:
 5            Book.objects.create(title='php',
 6                                publisher_id=2,   #這裏的2是指爲該book對象綁定了Publisher表中id=2的行對象
 7                                publication_date='2017-7-7',
 8                                price=99)
 9  
10  
11     #方式二:
12     #       <1> 先獲取要綁定的Publisher對象:
13         pub_obj=Publisher(name='河大出版社',address='保定',city='保定',
14                 state_province='河北',country='China',website='http://www.hbu.com')
15     OR  pub_obj=Publisher.objects.get(id=1)
16  
17     #       <2>將 publisher_id=2 改成  publisher=pub_obj
18  
19 #多對多(ManyToManyField()):
20  
21     author1=Author.objects.get(id=1)
22     author2=Author.objects.filter(name='alvin')[0]
23     book=Book.objects.get(id=1)
24     book.authors.add(author1,author2)
25     #等同於:
26     book.authors.add(*[author1,author2])
27     book.authors.remove(*[author1,author2])
28     #-------------------
29     book=models.Book.objects.filter(id__gt=1)
30     authors=models.Author.objects.filter(id=1)[0]
31     authors.book_set.add(*book)
32     authors.book_set.remove(*book)
33     #-------------------
34     book.authors.add(1)
35     book.authors.remove(1)
36     authors.book_set.add(1)
37     authors.book_set.remove(1)
38  
39 #注意: 若是第三張表是經過models.ManyToManyField()自動建立的,那麼綁定關係只有上面一種方式
40 #     若是第三張表是本身建立的:
41      class Book2Author(models.Model):
42             author=models.ForeignKey("Author")
43             Book=  models.ForeignKey("Book")
44 #     那麼就還有一種方式:
45             author_obj=models.Author.objects.filter(id=2)[0]
46             book_obj  =models.Book.objects.filter(id=3)[0]
47  
48             s=models.Book2Author.objects.create(author_id=1,Book_id=2)
49             s.save()
50             s=models.Book2Author(author=author_obj,Book_id=1)
51             s.save()

View Code

--------------------------------------------------------------刪(delete)-----------------------------------------------------

1 >>> Book.objects.filter(id=1).delete()
2 (3, {'app01.Book_authors': 2, 'app01.Book': 1})

咱們表面上刪除了一條信息，實際卻刪除了三條，由於咱們刪除的這本書在Book_authors表中有兩條相關信息，這種刪除方式就是django默認的級聯刪除。

若是是多對多的關係: remove()和clear()方法:

 1 #正向
 2 book = models.Book.objects.filter(id=1)
 3  
 4 #刪除第三張表中和女孩1關聯的全部關聯信息
 5 book.author.clear()        #清空與book中id=1 關聯的全部數據
 6 book.author.remove(2)  #能夠爲id
 7 book.author.remove(*[1,2,3,4])     #能夠爲列表,前面加*
 8  
 9 #反向
10 author = models.Author.objects.filter(id=1)
11 author.book_set.clear() #清空與boy中id=1 關聯的全部數據

----------------------------------------------------------改(update和save)-----------------------------------------------

實例：

注意：

<1> 第二種方式修改不能用get的緣由是：update是QuerySet對象的方法，get返回的是一個model對象，它沒有update方法，而filter返回的是一個QuerySet對象(filter裏面的條件可能有多個條件符合，好比name＝'alvin',可能有兩個name＝'alvin'的行數據)。

<2>在「插入和更新數據」小節中，咱們有提到模型的save()方法，這個方法會更新一行裏的全部列。而某些狀況下，咱們只須要更新行裏的某幾列。

 1 #---------------- update方法直接設定對應屬性----------------
 2     models.Book.objects.filter(id=3).update(title="PHP")
 3     ##sql:
 4     ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3)
 5  
 6  
 7 #--------------- save方法會將全部屬性從新設定一遍,效率低-----------
 8     obj=models.Book.objects.filter(id=3)[0]
 9     obj.title="Python"
10     obj.save()
11 # SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price",
12 # "app01_book"."color", "app01_book"."page_num",
13 # "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1;
14 #
15 # UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556,
16 # "publisher_id" = 1 WHERE "app01_book"."id" = 3;

在這個例子裏咱們能夠看到Django的save()方法更新了不只僅是title列的值，還有更新了全部的列。若title之外的列有可能會被其餘的進程所改動的狀況下，只更改title列顯然是更加明智的。更改某一指定的列，咱們能夠調用結果集（QuerySet）對象的update()方法,與之等同的SQL語句變得更高效，而且不會引發競態條件。

此外，update()方法對於任何結果集（QuerySet）均有效，這意味着你能夠同時更新多條記錄update()方法會返回一個整型數值，表示受影響的記錄條數。

注意，這裏由於update返回的是一個整形，因此無法用query屬性；對於每次建立一個對象，想顯示對應的raw sql，須要在settings加上日誌記錄部分：

 1 LOGGING = {
 2     'version': 1,
 3     'disable_existing_loggers': False,
 4     'handlers': {
 5         'console':{
 6             'level':'DEBUG',
 7             'class':'logging.StreamHandler',
 8         },
 9     },
10     'loggers': {
11         'django.db.backends': {
12             'handlers': ['console'],
13             'propagate': True,
14             'level':'DEBUG',
15         },
16     }
17 }

　　注意：若是是多對多的改：

1 obj=Book.objects.filter(id=1)[0]
2 author=Author.objects.filter(id__gt=2)
3  
4 obj.author.clear()
5 obj.author.add(*author)

-------------------------------------------------------查(filter,value等)---------------------------------------------------

----------------->查詢API:

 1 # 查詢相關API：
 2  
 3 #  <1>filter(**kwargs):      它包含了與所給篩選條件相匹配的對象
 4  
 5 #  <2>all():                 查詢全部結果
 6  
 7 #  <3>get(**kwargs):         返回與所給篩選條件相匹配的對象，返回結果有且只有一個，若是符合篩選條件的對象超過一個或者沒有都會拋出錯誤。
 8  
 9 #-----------下面的方法都是對查詢的結果再進行處理:好比 objects.filter.values()--------
10  
11 #  <4>values(*field):        返回一個ValueQuerySet——一個特殊的QuerySet，運行後獲得的並非一系列 model的實例化對象，而是一個可迭代的字典序列
12                                       
13 #  <5>exclude(**kwargs):     它包含了與所給篩選條件不匹配的對象
14  
15 #  <6>order_by(*field):      對查詢結果排序
16  
17 #  <7>reverse():             對查詢結果反向排序
18  
19 #  <8>distinct():            從返回結果中剔除重複紀錄
20  
21 #  <9>values_list(*field):   它與values()很是類似，它返回的是一個元組序列，values返回的是一個字典序列
22  
23 #  <10>count():              返回數據庫中匹配查詢(QuerySet)的對象數量。
24  
25 # <11>first():               返回第一條記錄
26  
27 # <12>last():                返回最後一條記錄
28  
29 #  <13>exists():             若是QuerySet包含數據，就返回True，不然返回False。

View Code

　　補充：

1 (1)  Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
2 (2)  Blog.objects.extra(
3         select=SortedDict([('a', '%s'), ('b', '%s')]),
4         select_params=('one', 'two'))
5  
6 (3)  q = Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
7      q = q.extra(order_by = ['-is_recent'])
8  
9 (4)  Entry.objects.extra(where=['headline=%s'], params=['Lennon'])

View Code

-------------------------->惰性機制:

所謂惰性機制：Publisher.objects.all()或者.filter()等都只是返回了一個QuerySet（查詢結果集對象），它並不會立刻執行sql，而是當調用QuerySet的時候才執行。

QuerySet特色:

　　<1> 可迭代的

　　<2> 可切片

 1 #objs=models.Book.objects.all()#[obj1,obj2,ob3...]
 2  
 3     #QuerySet:   可迭代
 4  
 5     # for obj in objs:#每一obj就是一個行對象
 6     #     print("obj:",obj)
 7     # QuerySet:  可切片
 8  
 9     # print(objs[1])
10     # print(objs[1:4])
11     # print(objs[::-1])

View Code

QuerySet的高效使用

 1 <1>Django的queryset是惰性的
 2  
 3      Django的queryset對應於數據庫的若干記錄（row），經過可選的查詢來過濾。例如，下面的代碼會得
 4      到數據庫中名字爲‘Dave’的全部的人:person_set = Person.objects.filter(first_name="Dave")
 5      上面的代碼並無運行任何的數據庫查詢。你可使用person_set，給它加上一些過濾條件，或者將它傳給某個函數，
 6      這些操做都不會發送給數據庫。這是對的，由於數據庫查詢是顯著影響web應用性能的因素之一。
 7  
 8 <2>要真正從數據庫得到數據，你能夠遍歷queryset或者使用if queryset,總之你用到數據時就會執行sql.
 9    爲了驗證這些,須要在settings里加入 LOGGING(驗證方式)
10         obj=models.Book.objects.filter(id=3)
11         # for i in obj:
12         #     print(i)
13  
14         # if obj:
15         #     print("ok")
16  
17 <3>queryset是具備cache的
18      當你遍歷queryset時，全部匹配的記錄會從數據庫獲取，而後轉換成Django的model。這被稱爲執行
19     （evaluation）.這些model會保存在queryset內置的cache中，這樣若是你再次遍歷這個queryset，
20      你不須要重複運行通用的查詢。
21         obj=models.Book.objects.filter(id=3)
22  
23         # for i in obj:
24         #     print(i)
25                           ## models.Book.objects.filter(id=3).update(title="GO")
26                           ## obj_new=models.Book.objects.filter(id=3)
27         # for i in obj:
28         #     print(i)   #LOGGING只會打印一次
29  
30 <4>
31      簡單的使用if語句進行判斷也會徹底執行整個queryset而且把數據放入cache，雖然你並不須要這些
32      數據！爲了不這個，能夠用exists()方法來檢查是否有數據：
33  
34             obj = Book.objects.filter(id=4)
35             #  exists()的檢查能夠避免數據放入queryset的cache。
36             if obj.exists():
37                 print("hello world!")
38  
39 <5>當queryset很是巨大時，cache會成爲問題
40  
41      處理成千上萬的記錄時，將它們一次裝入內存是很浪費的。更糟糕的是，巨大的queryset可能會鎖住系統
42      進程，讓你的程序瀕臨崩潰。要避免在遍歷數據的同時產生queryset cache，可使用iterator()方法
43      來獲取數據，處理完數據就將其丟棄。
44         objs = Book.objects.all().iterator()
45         # iterator()能夠一次只從數據庫獲取少許數據，這樣能夠節省內存
46         for obj in objs:
47             print(obj.name)
48         #BUT,再次遍歷沒有打印,由於迭代器已經在上一次遍歷(next)到最後一次了,沒得遍歷了
49         for obj in objs:
50             print(obj.name)
51  
52      #固然，使用iterator()方法來防止生成cache，意味着遍歷同一個queryset時會重複執行查詢。因此使
53      #用iterator()的時候要小心，確保你的代碼在操做一個大的queryset時沒有重複執行查詢
54  
55 總結:
56     queryset的cache是用於減小程序對數據庫的查詢，在一般的使用下會保證只有在須要的時候纔會查詢數據庫。
57 使用exists()和iterator()方法能夠優化程序對內存的使用。不過，因爲它們並不會生成queryset cache，可能
58 會形成額外的數據庫查詢。

View Code

------------------->對象查詢,單表條件查詢,多表條件關聯查詢

 1 #--------------------對象形式的查找--------------------------
 2     # 正向查找
 3     ret1=models.Book.objects.first()
 4     print(ret1.title)
 5     print(ret1.price)
 6     print(ret1.publisher)
 7     print(ret1.publisher.name)  #由於一對多的關係因此ret1.publisher是一個對象,而不是一個queryset集合
 8  
 9     # 反向查找
10     ret2=models.Publish.objects.last()
11     print(ret2.name)
12     print(ret2.city)
13     #如何拿到與它綁定的Book對象呢?
14     print(ret2.book_set.all()) #ret2.book_set是一個queryset集合
15  
16 #---------------了不得的雙下劃線(__)之單表條件查詢----------------
17  
18 #    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 獲取id大於1 且 小於10的值
19 #
20 #    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 獲取id等於十一、2二、33的數據
21 #    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
22 #
23 #    models.Tb1.objects.filter(name__contains="ven")
24 #    models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
25 #
26 #    models.Tb1.objects.filter(id__range=[1, 2])   # 範圍bettwen and
27 #
28 #    startswith，istartswith, endswith, iendswith,
29  
30 #----------------了不得的雙下劃線(__)之多表條件關聯查詢---------------
31  
32 # 正向查找(條件)
33  
34 #     ret3=models.Book.objects.filter(title='Python').values('id')
35 #     print(ret3)#[{'id': 1}]
36  
37       #正向查找(條件)之一對多
38  
39       ret4=models.Book.objects.filter(title='Python').values('publisher__city')
40       print(ret4)  #[{'publisher__city': '北京'}]
41  
42       #正向查找(條件)之多對多
43       ret5=models.Book.objects.filter(title='Python').values('author__name')
44       print(ret5)
45       ret6=models.Book.objects.filter(author__name="alex").values('title')
46       print(ret6)
47  
48       #注意
49       #正向查找的publisher__city或者author__name中的publisher,author是book表中綁定的字段
50       #一對多和多對多在這裏用法沒區別
51  
52 # 反向查找(條件)
53  
54     #反向查找之一對多:
55     ret8=models.Publisher.objects.filter(book__title='Python').values('name')
56     print(ret8)#[{'name': '人大出版社'}]  注意,book__title中的book就是Publisher的關聯表名
57  
58     ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors')
59     print(ret9)#[{'book__authors': 1}, {'book__authors': 2}]
60  
61     #反向查找之多對多:
62     ret10=models.Author.objects.filter(book__title='Python').values('name')
63     print(ret10)#[{'name': 'tom'}, {'name': 'alvin'}]
64  
65     #注意
66     #正向查找的book__title中的book是表名Book
67     #一對多和多對多在這裏用法沒區別

View Code

注意：條件查詢即與對象查詢對應，是指在filter，values等方法中的經過__來明確查詢條件。

-------------------->聚合查詢和分組查詢

<1> aggregate(*args,**kwargs):

經過對QuerySet進行計算，返回一個聚合值的字典。aggregate()中每個參數都指定一個包含在字典中的返回值。即在查詢集上生成聚合。

 1 from django.db.models import Avg,Min,Sum,Max
 2  
 3 從整個查詢集生成統計值。好比，你想要計算全部在售書的平均價錢。Django的查詢語法提供了一種方式描述全部
 4 圖書的集合。
 5  
 6 >>> Book.objects.all().aggregate(Avg('price'))
 7 {'price__avg': 34.35}
 8  
 9 aggregate()子句的參數描述了咱們想要計算的聚合值，在這個例子中，是Book模型中price字段的平均值
10  
11 aggregate()是QuerySet 的一個終止子句，意思是說，它返回一個包含一些鍵值對的字典。鍵的名稱是聚合值的
12 標識符，值是計算出來的聚合值。鍵的名稱是按照字段和聚合函數的名稱自動生成出來的。若是你想要爲聚合值指定
13 一個名稱，能夠向聚合子句提供它:
14 >>> Book.objects.aggregate(average_price=Avg('price'))
15 {'average_price': 34.35}
16  
17  
18 若是你也想知道全部圖書價格的最大值和最小值，能夠這樣查詢：
19 >>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
20 {'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

View Code

<2> annotate(*args,**kwargs):

　　能夠經過計算查詢結果中每個對象所關聯的對象集合，從而得出總計值(也能夠是平均值或總和)，即爲查詢集的每一項生成聚合

　　查詢xxx出的書總價格

　　查詢各個做者出的書的總價格,這裏就涉及到分組了，分組條件是authors__name

　　查詢各個出版社最便宜的書價是多少

-------------------->F查詢和Q查詢

僅僅靠單一的關鍵字參數查詢已經很難知足查詢要求。此時Django爲咱們提供了F和Q查詢：

 1 # F 使用查詢條件的值,專門取對象中某列值的操做
 2  
 3     # from django.db.models import F
 4     # models.Tb1.objects.update(num=F('num')+1)
 5  
 6  
 7 # Q 構建搜索條件
 8     from django.db.models import Q
 9  
10     #1 Q對象(django.db.models.Q)能夠對關鍵字參數進行封裝，從而更好地應用多個查詢
11     q1=models.Book.objects.filter(Q(title__startswith='P')).all()
12     print(q1)#[<Book: Python>, <Book: Perl>]
13  
14     # 二、能夠組合使用&,|操做符，當一個操做符是用於兩個Q的對象,它產生一個新的Q對象。
15     Q(title__startswith='P') | Q(title__startswith='J')
16  
17     # 三、Q對象能夠用~操做符放在前面表示否認，也可容許否認與不否認形式的組合
18     Q(title__startswith='P') | ~Q(pub_date__year=2005)
19  
20     # 四、應用範圍：
21  
22     # Each lookup function that takes keyword-arguments (e.g. filter(),
23     #  exclude(), get()) can also be passed one or more Q objects as
24     # positional (not-named) arguments. If you provide multiple Q object
25     # arguments to a lookup function, the arguments will be 「AND」ed
26     # together. For example:
27  
28     Book.objects.get(
29         Q(title__startswith='P'),
30         Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
31     )
32  
33     #sql:
34     # SELECT * from polls WHERE question LIKE 'P%'
35     #     AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')
36  
37     # import datetime
38     # e=datetime.date(2005,5,6)  #2005-05-06
39  
40     # 五、Q對象能夠與關鍵字參數查詢一塊兒使用，不過必定要把Q對象放在關鍵字參數查詢的前面。
41     # 正確：
42     Book.objects.get(
43         Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
44         title__startswith='P')
45     # 錯誤：
46     Book.objects.get(
47         question__startswith='P',
48         Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))

View Code

raw sql

django中models的操做,也是調用了ORM框架來實現的,pymysql 或者mysqldb,因此咱們也可使用原生的SQL語句來操做數據庫!

九 admin的配合

admin是django強大功能之一，它能共從數據庫中讀取數據，呈如今頁面中，進行管理。默認狀況下，它的功能已經很是強大，若是你不須要複雜的功能，它已經夠用，可是有時候，一些特殊的功能還須要定製，好比搜索功能，下面這一系列文章就逐步深刻介紹如何定製適合本身的admin應用。

若是你以爲英文界面很差用，能夠在setting.py 文件中修改如下選項

LANGUAGE_CODE = 'en-us'  #LANGUAGE_CODE = 'zh-hans'

一認識ModelAdmin

管理界面的定製類,如需擴展特定的model界面需從該類繼承

二註冊model類到admin的兩種方式:

　　<1> 使用register的方法

admin.site.register(Book,MyAdmin)

　　<2> 使用register的裝飾器

@admin.register(Book)

三掌握一些經常使用的設置技巧

　　list_display: 指定要顯示的字段

　　search_fields: 指定搜索的字段

　　list_filter: 指定列表過濾器

　　ordering:指定排序字段

 1 from django.contrib import admin
 2 from app01.models import *
 3 # Register your models here.
 4  
 5 # @admin.register(Book)#----->單給某個表加一個定製
 6 class MyAdmin(admin.ModelAdmin):
 7     list_display = ("title","price","publisher")
 8     search_fields = ("title","publisher")
 9     list_filter = ("publisher",)
10     ordering = ("price",)
11     fieldsets =[
12         (None,               {'fields': ['title']}),
13         ('price information', {'fields': ['price',"publisher"], 'classes': ['collapse']}),
14     ]
15  
16 admin.site.register(Book,MyAdmin)
17 admin.site.register(Publish)
18 admin.site.register(Author)