django基礎（一）

時間 2019-12-13

標籤 django 基礎欄目 Python 简体版

原文原文鏈接

1、Django基礎命令

一、MVC和MTV模式php

　　Django的MTV模式本質是各組件之間爲了保持鬆耦合關係,Django的MTV分別表明：html

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

Template(模版)：負責如何把頁面展現給用戶python

View(視圖)：負責業務邏輯，並在適當的時候調用Model和Templatemysql

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

二、建立一個django projectgit

django-admin.py startproject mysite程序員

project的目錄結構爲：web

　　mysite正則表達式

　　|-- manage.py

　　|-- mysite

　　　　|-- settings.py

　　　　|-- urls.py

　　　　|-- wsgi.py

manage.py ----- Django項目裏面的工具，經過它能夠調用django shell和數據庫等。
settings.py ---- 包含了項目的默認設置，包括數據庫信息，調試標誌以及其餘一些工做的變量。
urls.py ----- 負責把URL模式映射到應用程序。

三、在mystie目錄下建立應用，如blog：

　　python manage.py startapp blog

四、啓動django項目

　　python manage.py runserver 8080

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

五、同步更改數據庫表或字段

　 Django1.7.1一下版本執行

 python manage.py syncdb

Django 1.7.1 及以上的版本須要用如下命令：

python manage.py makemigrations

python manage.py migrate

　這種方法能夠建立表，當你在models.py中新增了類時，運行它就能夠自動在數據庫中建立表了，不用手動建立。

六、清空數據庫

python manage.py flush

此命令會詢問是 yes 仍是 no, 選擇 yes 會把數據所有清空掉，只留下空表。

七、建立超級管理員

python manage.py createsuperuser

# 按照提示輸入用戶名和對應的密碼就行了郵箱能夠留空，用戶名和密碼必填
# 修改 用戶密碼能夠用：
python manage.py changepassword username

八、Django 項目環境終端

　python manage.py shell

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

九、Django 項目環境終端

python manage.py dbshell

　Django 會自動進入在settings.py中設置的數據庫，若是是 MySQL 或 postgreSQL,會要求輸入數據庫用戶密碼。

　在這個終端能夠執行數據庫的SQL語句。若是您對SQL比較熟悉，可能喜歡這種方式。

十、更多命令

　　python manage.py

十一、static配置

 1 STATIC文件還能夠配置STATICFILES_DIRS，指定額外的靜態文件存儲位置。
 2     #  STATIC_URL的含義與MEDIA_URL相似。
 3 
 4     # ----------------------------------------------------------------------------
 5     #注意1:
 6         #爲了後端的更改不會影響前端的引入，避免形成前端大量修改
 7 
 8         STATIC_URL = '/static/'               #引用名
 9         STATICFILES_DIRS = (
10             os.path.join(BASE_DIR,"statics")  #實際名 ,即實際文件夾的名字
11         )
12 
13         #django對引用名和實際名進行映射,引用時,只能按照引用名來,不能按實際名去找
14         #<script src="/statics/jquery-3.1.1.js"></script>
15         #------error－－－－－不能直接用，必須用STATIC_URL = '/static/':
16         #<script src="/static/jquery-3.1.1.js"></script>
17 
18     #注意2(statics文件夾寫在不一樣的app下,靜態文件的調用):
19 
20         STATIC_URL = '/static/'
21 
22         STATICFILES_DIRS=(
23             ('hello',os.path.join(BASE_DIR,"app01","statics")) ,
24         )
25 
26         #<script src="/static/hello/jquery-1.8.2.min.js"></script>
27 
28     #注意3:
29         STATIC_URL = '/static/'
30         {% load staticfiles %}
31        # <script src={% static "jquery-1.8.2.min.js" %}></script>

View Code

2、路由配置系統

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

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


參數說明：

    一個正則表達式字符串
    一個可調用對象，一般爲一個視圖函數或一個指定視圖函數路徑的字符串
    可選的要傳遞給視圖函數的默認參數（字典形式）
    一個可選的name參數

    '''

一、URLconf的正則字符串參數

　1）簡單配置

 1 from django.conf.urls import url
 2 
 3 from . import views
 4 
 5 urlpatterns = [
 6     url(r'^articles/2003/$', views.special_case_2003),
 7     url(r'^articles/([0-9]{4})/$', views.year_archive),
 8     url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
 9     url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
10 ]

View Code

 1 '''
 2     NOTE:
 3     1 一旦匹配成功則再也不繼續
 4     2 若要從URL 中捕獲一個值，只須要在它周圍放置一對圓括號。
 5     3 不須要添加一個前導的反斜槓，由於每一個URL 都有。例如，應該是^articles 而不是 ^/articles。
 6     4 每一個正則表達式前面的'r' 是可選的可是建議加上。
 7 
 8 一些請求的例子：
 9 
10     /articles/2005/3/ 不匹配任何URL 模式，由於列表中的第三個模式要求月份應該是兩個數字。
11     /articles/2003/ 將匹配列表中的第一個模式不是第二個，由於模式按順序匹配，第一個會首先測試是否匹配。
12     /articles/2005/03/ 請求將匹配列表中的第三個模式。Django 將調用函數
13                        views.month_archive(request, '2005', '03')。
14     '''

View Code

1 #設置項是否開啓URL訪問地址後面不爲/跳轉至帶有/的路徑
2 APPEND_SLASH=True

View Code

　2）有名分組（name group）

　　上面的示例使用簡單的、沒有命名的正則表達式組（經過圓括號）來捕獲URL 中的值並以位置參數傳遞給視圖。在更高級的用法中，可使用命名的正則表達式組來捕獲URL 　　中的值並以關鍵字參數傳遞給視圖。

　　在Python 正則表達式中，命名正則表達式組的語法是(?P<name>pattern)，其中name 是組的名稱，pattern 是要匹配的模式。

　　下面是以上URLconf 使用命名組的重寫：

 1 from django.conf.urls import url
 2 
 3 from . import views
 4 
 5 urlpatterns = [
 6     url(r'^articles/2003/$', views.special_case_2003),
 7     url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
 8     url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
 9     url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$', views.article_detail),
10 ]

View Code

　　這個實現與前面的示例徹底相同，只有一個細微的差異：捕獲的值做爲關鍵字參數而不是位置參數傳遞給視圖函數。例如：

1     /articles/2005/03/    
2     請求將調用views.month_archive(request, year='2005', month='03')函數
3     /articles/2003/03/03/ 
4     請求將調用函數views.article_detail(request, year='2003', month='03', day='03')。

View Code

　　在實際應用中，這意味你的URLconf 會更加明晰且不容易產生參數順序問題的錯誤 —— 你能夠在你的視圖函數定義中從新安排參數的順序。固然，這些好處是以簡潔爲代

　　價；有些開發人員認爲命名組語法醜陋而繁瑣。

　3） URLconf的查找

　　URLconf 在請求的URL 上查找，將它當作一個普通的Python 字符串。不包括GET和POST參數以及域名。

　　例如，http://www.example.com/myapp/ 請求中，URLconf 將查找myapp/。

　　在http://www.example.com/myapp/?page=3 請求中，URLconf 仍將查找myapp/。

　　URLconf 不檢查請求的方法。換句話講，全部的請求方法 —— 同一個URL的POST、GET、HEAD等等 —— 都將路由到相同的函數。

　4）捕獲參數永遠是字符串

　　每一個捕獲的參數都做爲一個普通的Python 字符串傳遞給視圖，不管正則表達式使用的是什麼匹配方式。例如，下面這行URLconf 中：

　　url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
　 的 參數將是一個字符串
5）指定視圖參數的默認值
　有一個方便的小技巧是指定視圖參數的默認值。 下面是一個URLconf 和視圖的示例：
views.year_archive()year

 1 # URLconf
 2 from django.conf.urls import url
 3 
 4 from . import views
 5 
 6 urlpatterns = [
 7     url(r'^blog/$', views.page),
 8     url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
 9 ]
10 
11 # View (in blog/views.py)
12 def page(request, num="1"):
13 
14     ...

View Code

　　在上面的例子中，兩個URL模式指向同一個視圖views.page —— 可是第一個模式不會從URL 中捕獲任何值。若是第一個模式匹配，page() 函數將使用num參數的默認值"1"。

　　若是第二個模式匹配，page() 將使用正則表達式捕獲的num 值。

　6）Including other URLconfs

 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 ]

View Code

二、傳遞額外的選項給視圖函數(瞭解)

　URLconfs 具備一個鉤子，讓你傳遞一個Python 字典做爲額外的參數傳遞給視圖函數。

　django.conf.urls.url() 函數能夠接收一個可選的第三個參數，它是一個字典，表示想要傳遞給視圖函數的額外關鍵字參數。

1 from django.conf.urls import url
2 from . import views
3 
4 urlpatterns = [
5     url(r'^blog/(?P<year>[0-9]{4})/$', views.year_archive, {'foo': 'bar'}),
6 ]

View Code

　在這個例子中，對於/blog/2005/請求，Django 將調用views.year_archive(request, year='2005', foo='bar')。

　這個技術在Syndication 框架中使用，來傳遞元數據和選項給視圖。

三、name參數

 1 '''
 2 
 3 urlpatterns = [
 4     url(r'^index',views.index,name='INDEX'),
 5 
 6 ]
 7 ###################
 8 
 9 def index(req):
10     if req.method=='POST':
11         username=req.POST.get('username')
12         password=req.POST.get('password')
13         if username=='alex' and password=='123':
14             return HttpResponse("登錄成功")
15 
16     return render(req,'index.html')
17 
18 #####################
19 
20 <!DOCTYPE html>
21 <html lang="en">
22 <head>
23     <meta charset="UTF-8">
24     <title>Title</title>
25 </head>
26 <body>
27 {#     <form action="/index/" method="post">#}
28      <form action="{% url 'INDEX' %}" method="post">
29          用戶名:<input type="text" name="username">
30          密碼:<input type="password" name="password">
31          <input type="submit" value="submit">
32      </form>
33 </body>
34 </html>
35 
36 
37 #######################
38 
39 '''

View Code

3、編寫試圖

一個視圖函數，或者簡短來講叫作視圖，是一個簡單的Python函數，它接受web請求，而且返回web響應。響應能夠是一張網頁的HTML內容，一個重定向，一個404錯誤，一個XML文檔，或者一張圖片. . . 是任何東西均可以。不管視圖自己包含什麼邏輯，都要返回響應。代碼寫在哪裏也無所謂，只要它在你的Python目錄下面。除此以外沒有更多的要求了——能夠說「沒有什麼神奇的地方」。爲了可以把代碼放在某個地方，慣例是把視圖放在叫作views.py的文件中，而後把它放到你的項目或者應用目錄裏。

一、簡單視圖：

　下面是一個返回當前日期和時間做爲HTML文檔的視圖：

1 from django.http import HttpResponse
2 import datetime
3 
4 def current_datetime(request):
5     now = datetime.datetime.now()
6     html = "<html><body>It is now %s.</body></html>" % now
7     return HttpResponse(html)

View Code

　讓咱們逐行閱讀上面的代碼：

首先，咱們從 django.http模塊導入了HttpResponse類，以及Python的datetime庫。
接着，咱們定義了current_datetime函數。它是一個視圖函數。每一個視圖函數都應接收HttpRequest對象做爲第一個參數，通常叫作request。
注意視圖函數的名稱並不重要；不須要用一個統一的命名方式來命名，以便讓Django識別它。咱們將其命名爲current_datetime，是由於這個名稱可以精確地反映出它的功能。
這個視圖會返回一個HttpResponse對象，其中包含生成的響應。每一個視圖函數都要返回HttpResponse對象


'''
http請求－響應過程當中有兩個核心對象：

        http請求對象：HttpRequest

        http響應響應：HttpResponse

所在位置：django.http

'''

二、快捷函數

　1） render函數

 1 －－－－－－－－－－－－－－－render(request, template_name[, context]）
 2 
 3 結合一個給定的模板和一個給定的上下文字典，並返回一個渲染後的 HttpResponse 對象。
 4 
 5 參數：
 6      request： 用於生成響應的請求對象。
 7 
 8      template_name：要使用的模板的完整名稱，可選的參數
 9 
10      context：添加到模板上下文的一個字典。默認是一個空字典。若是字典中的某個值是可調用的，視圖將在渲染模板以前調用它。
11 
12      content_type：生成的文檔要使用的MIME類型。默認爲DEFAULT_CONTENT_TYPE 設置的值。
13 
14      status：響應的狀態碼。默認爲200。

View Code

　2）redirct函數

 1 -----------------------------------url.py
 2 
 3  url(r"login",   views.login),
 4  url(r"yang_back",   views.yang_back),
 5 
 6 -----------------------------------views.py
 7 def login(req):
 8     if req.method=="POST":
 9         if 1:
10             # return redirect("/yuan_back/")
11             name="shuyang"
12 
13             return render(req,"my backend.html",locals())
14 
15     return render(req,"login.html",locals())
16 
17 
18 def yang_back(req):
19 
20     name="舒陽"
21 
22     return render(req,"my backend.html",locals())
23 
24 -----------------------------------login.html
25 
26 <form action="/login/" method="post">
27     <p>姓名<input type="text" name="username"></p>
28     <p>性別<input type="text" name="sex"></p>
29     <p>郵箱<input type="text" name="email"></p>
30     <p><input type="submit" value="submit"></p>
31 </form>
32 -----------------------------------my backend.html
33 <h1>用戶{{ name }}你好</h1>

View Code

　3）總結：

　　render和redirect的區別:

if render的頁面須要模板語言渲染,須要的將數據庫的數據加載到html,那麼全部的這一部分除了寫在yuan_back的視圖函數中,必須還要寫在login中,代碼重複,沒有解耦.
the most important: url沒有跳轉到/yuan_back/,而是還在/login/,因此當刷新後又得從新登陸.

4、Template

一、模版系統的介紹

　你可能已經注意到咱們在例子視圖中返回文本的方式有點特別。也就是說，HTML被直接硬編碼在 Python代碼之中。

1 def current_datetime(request):
2     now = datetime.datetime.now()
3     html = "<html><body>It is now %s.</body></html>" % now
4     return HttpResponse(html)

View Code

儘管這種技術便於解釋視圖是如何工做的，但直接將HTML硬編碼到你的視圖裏卻並非一個好主意。讓咱們來看一下爲何：

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

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

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

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

二、模版支持的語法

　1）變量（使用雙大括號來引用變量）

語法格式：       {{var_name}}

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

View Code

　2）深度變量的查找（萬能的句點號）

　　在到目前爲止的例子中，咱們經過 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 1993
26 >>> d.month
27 5
28 >>> d.day
29 2
30 >>> t = Template('The month is {{ date.month }} and the year is {{ date.year }}.')
31 >>> c = Context({'date': d})
32 >>> t.render(c)
33 'The month is 5 and the year is 1993.'
34 
35 # 這個例子使用了一個自定義的類，演示了經過實例變量加一點(dots)來訪問它的屬性，這個方法適
36 # 用於任意的對象。
37 >>> from django.template import Template, Context
38 >>> class Person(object):
39 ...     def __init__(self, first_name, last_name):
40 ...         self.first_name, self.last_name = first_name, last_name
41 >>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.')
42 >>> c = Context({'person': Person('John', 'Smith')})
43 >>> t.render(c)
44 'Hello, John Smith.'
45 
46 # 點語法也能夠用來引用對象的方法。 例如，每一個 Python 字符串都有 upper() 和 isdigit()
47 # 方法，你在模板中可使用一樣的句點語法來調用它們：
48 >>> from django.template import Template, Context
49 >>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}')
50 >>> t.render(Context({'var': 'hello'}))
51 'hello -- HELLO -- False'
52 >>> t.render(Context({'var': '123'}))
53 '123 -- 123 -- True'
54 
55 # 注意這裏調用方法時並* 沒有* 使用圓括號 並且也沒法給該方法傳遞參數；你只能調用不需參數的
56 # 方法。

View Code

　3）變量的過濾器(filter)的使用

　語法格式：      {{obj|filter:param}}

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

View Code

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

　語法格式:    {% tags %}

　（1）{% 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 %}
16 
17 
18 
19 {% if %} 標籤接受and，or或者not來測試多個變量值或者否認一個給定的變量
20 {% if %} 標籤不容許同一標籤裏同時出現and和or，不然邏輯容易產生歧義，例以下面的標籤是不合法的：
21 
22 {% if obj1 and obj2 or obj3 %}

View Code

　　（2）{% 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

　　（3）csrf_token標籤

　　用於生成csrf_token的標籤，用於防治跨站攻擊驗證。其實，這裏是會生成一個input標籤，和其餘表單標籤一塊兒提交給後臺的。

　　{% url %}

　　引用路由配置的地址

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

View Code

　　{% with %}

　　用更簡單的變量名替代複雜的變量名

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

View Code

　　{% verbatim %}

　　禁止render

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

View Code

　　{% load %}

　　略

　　（4）加載標籤庫:自定義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 %}

View Code

三、extend模版

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

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

看起來很漂亮是否是？每一個模板只包含對本身而言 獨一無二 的代碼。無需多餘的部分。若是想進行站點級的設計修改，僅需修改 base.html ，全部其它模板會當即反映出所做修改。

如下是其工做方式：

在加載 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 %} 標籤，父模板將無從得知要使用哪一個塊的內容。

5、數據庫與ORM

一、數據庫的配置

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 }

View Code

　　ps.

NAME即數據庫的名字，在mysql鏈接前該數據庫必須已經建立，而上面的sqlite數據庫下的db.sqlite3則是項目自動建立

USER和PASSWORD分別是數據庫的用戶名和密碼。

設置完後，再啓動咱們的Django項目前，咱們須要激活咱們的mysql。

而後，啓動項目，會報錯：no module named MySQLdb

這是由於django默認你導入的驅動是MySQLdb，但是MySQLdb對於py3有很大問題，因此咱們須要的驅動是PyMySQL

因此，咱們只須要找到項目名文件下的__init__,在裏面寫入：

import pymysql
pymysql.install_as_MySQLdb()

問題解決！

二、ORM表模型

表(模型)的建立：

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

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

做者詳細模型：把做者的詳情放到詳情表，包含性別，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> 每一個數據模型都是django.db.models.Model的子類，它的父類Model包含了全部必要的和數據庫交互的方法。並提供了一個簡介漂亮的定義數據庫字段的語法。

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

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

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

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

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

一、ORM之增長（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()

View Code

那麼如何建立存在一對多或多對多關係的一本書的信息呢？(如何處理外鍵關係的字段如一對多的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

二、ORM之刪（delete）

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

View Code

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

三、ORM之改（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;

View Code

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

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

四、ORM之查（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 ---------------了不得的雙下劃線(__)之單表條件查詢----------------
 2 
 3 #    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 獲取id大於1 且 小於10的值
 4 #
 5 #    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 獲取id等於十一、2二、33的數據
 6 #    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
 7 #
 8 #    models.Tb1.objects.filter(name__contains="ven")  #like方法
 9 #    models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
10 #
11 #    models.Tb1.objects.filter(id__range=[1, 2])   # 範圍bettwen and
12 #
13 #    startswith，istartswith, endswith, iendswith,

View Code

五、QuerySet與惰性機制

所謂惰性機制：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': 'alex'}, {'name': 'alvin'}]
64 
65     #注意
66     #正向查找的book__title中的book是表名Book
67     #一對多和多對多在這裏用法沒區別

View Code

七、聚合查詢和分組查詢

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

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

查詢alex出的書總價格

查詢各個做者出的書的總價格,這裏就涉及到分組了，分組條件是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

6、admin的配置

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

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

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

1）認識ModelAdmin

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

2）註冊medel類到admin的兩種方式：

<1> 使用register的方法
admin.site.register(Book,MyAdmin)
<2> 使用register的裝飾器
@admin.register(Book)

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

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)