Django框架_URLconf、Views、template、ORM

時間 2019-11-12

標籤 django 框架 urlconf views template orm 欄目 Python 简体版

原文原文鏈接

MTV模型

Django的MTV分別表明：css

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

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

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

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

Django基本命令

一、下載Django：

pip3 install django

二、建立一個django project

django-admin.py startproject mysite

當前目錄下會生成mysite的工程，目錄結構以下：git

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

三、在mysite目錄下建立應用

python manage.py startapp blog

四、啓動django項目

python manage.py runserver 8080

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

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

'''
    python manage.py syncdb
     
    注意：Django 1.7.1 及以上的版本須要用如下命令
    python manage.py makemigrations
    python manage.py migrate
    
'''

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

六、清空數據庫

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，對於操做數據的測試很是方便。sql

九、Django 項目環境終端

ython manage.py dbshell

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

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

十、更多命令

python manage.py

查看全部的命令，忘記子名稱的時候特別有用。

11 靜態文件配置

概述：

     靜態文件交由Web服務器處理，Django自己不處理靜態文件。簡單的處理邏輯以下(以nginx爲例)：

              URI請求-----> 按照Web服務器裏面的配置規則先處理，以nginx爲例，主要求配置在nginx.
                             conf裏的location

                         |---------->若是是靜態文件，則由nginx直接處理

                         |---------->若是不是則交由Django處理，Django根據urls.py裏面的規則進行匹配

    以上是部署到Web服務器後的處理方式，爲了便於開發，Django提供了在開發環境的對靜態文件的處理機制，方法是這樣：

static配置：

STATIC主要指的是如css,js,images這樣文件：

STATIC_URL = '/static/'      # 別名
STATICFILES_DIRS = (
            os.path.join(BASE_DIR,"static"),  #實際名 ,即實際文件夾的名字
        )

'''

注意點1:
 django對引用名和實際名進行映射,引用時,只能按照引用名來,不能按實際名去找
        <script src="/statics/jquery-3.1.1.js"></script>
        ------error－－－－－不能直接用，必須用STATIC_URL = '/static/':
        <script src="/static/jquery-3.1.1.js"></script>

注意點2:
 STATICFILES_DIRS = (
    ("app01",os.path.join(BASE_DIR, "app01/statics")),
        )

 <script src="/static/app01/jquery.js"></script>

'''

have a try：

http://127.0.0.1:8000/static/jquery.js

media配置：

# in settings:

MEDIA_URL="/media/"
MEDIA_ROOT=os.path.join(BASE_DIR,"app01","media","upload")

# in urls:
from django.views.static import serve
url(r'^media/(?P<path>.*)$', serve, {'document_root': settings.MEDIA_ROOT}),

have a try:

http://127.0.0.1:8000/media/1.png

        '''
        靜態文件的處理又包括STATIC和MEDIA兩類，這每每容易混淆，在Django裏面是這樣定義的：
        
        MEDIA:指用戶上傳的文件，好比在Model裏面的FileFIeld，ImageField上傳的文件。若是你定義
        
        MEDIA_ROOT=c:\temp\media，那麼File=models.FileField(upload_to="abc/")＃，上傳的文件就會被保存到c:\temp\media\abc

        eg：
            class blog(models.Model):
                   Title=models.charField(max_length=64)
                   Photo=models.ImageField(upload_to="photo")
          上傳的圖片就上傳到c:\temp\media\photo，而在模板中要顯示該文件，則在這樣寫
          在settings裏面設置的MEDIA_ROOT必須是本地路徑的絕對路徑，通常是這樣寫:
                 BASE_DIR= os.path.abspath(os.path.dirname(__file__))
                 MEDIA_ROOT=os.path.join(BASE_DIR,'media/').replace('\\','/')

        MEDIA_URL是指從瀏覽器訪問時的地址前綴，舉個例子：
            MEDIA_ROOT=c:\temp\media\photo
            MEDIA_URL="/data/"
        在開發階段,media的處理由django處理：

           訪問http://localhost/data/abc/a.png就是訪問c:\temp\media\photo\abc\a.png

           在模板裏面這樣寫<img src="/media/abc/a.png">

           在部署階段最大的不一樣在於你必須讓web服務器來處理media文件，所以你必須在web服務器中配置，
           以便能讓web服務器能訪問media文件
           以nginx爲例，能夠在nginx.conf裏面這樣：

                 location ~/media/{
                       root/temp/
                       break;
                    }

           具體能夠參考如何在nginx部署django的資料。
           
           
           '''

View Code

視圖層之路由配置系統(views)

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

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


參數說明：

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

 '''

2.1 URLconf的正則字符串參數

2.1.1 簡單配置

from django.conf.urls import url

from . import views

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

    '''
    NOTE:
    1 一旦匹配成功則再也不繼續
    2 若要從URL 中捕獲一個值，只須要在它周圍放置一對圓括號。
    3 不須要添加一個前導的反斜槓，由於每一個URL 都有。例如，應該是^articles 而不是 ^/articles。
    4 每一個正則表達式前面的'r' 是可選的可是建議加上。

一些請求的例子：

    /articles/2005/3/ 不匹配任何URL 模式，由於列表中的第三個模式要求月份應該是兩個數字。
    /articles/2003/ 將匹配列表中的第一個模式不是第二個，由於模式按順序匹配，第一個會首先測試是否匹配。
    /articles/2005/03/ 請求將匹配列表中的第三個模式。Django 將調用函數
                       views.month_archive(request, '2005', '03')。
    '''

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

SLASH

2.1.2 有名分組(named group)

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

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

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

from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^articles/2003/$', views.special_case_2003),
    url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$', views.article_detail),
]

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

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

在實際應用中，這意味你的URLconf 會更加明晰且不容易產生參數順序問題的錯誤 —— 你能夠在你的視圖函數定義中從新安排參數的順序。固然，這些好處是以簡潔爲代價；有些開發人員認爲命名組語法醜陋而繁瑣。

2.1.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等等 —— 都將路由到相同的函數。

2.1.4 捕獲的參數永遠是字符串

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

url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),

views.year_archive() 的year 參數將是一個字符串

2.1.5 指定視圖參數的默認值

有一個方便的小技巧是指定視圖參數的默認值。下面是一個URLconf 和視圖的示例：

# URLconf
from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^blog/$', views.page),
    url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
]

# View (in blog/views.py)
def page(request, num="1"):

    ...

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

2.1.6 Including other URLconfs

#At any point, your urlpatterns can 「include」 other URLconf modules. This
#essentially 「roots」 a set of URLs below other ones.

#For example, here’s an excerpt of the URLconf for the Django website itself.
#It includes a number of other URLconfs:


from django.conf.urls import include, url

urlpatterns = [
   url(r'^admin/', admin.site.urls),
   url(r'^blog/', include('blog.urls')),
]

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

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

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

例如：

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^blog/(?P<year>[0-9]{4})/$', views.year_archive, {'foo': 'bar'}),
]

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

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

2.3 URL 的反向解析

在使用Django 項目時，一個常見的需求是得到URL 的最終形式，以用於嵌入到生成的內容中（視圖中和顯示給用戶的URL等）或者用於處理服務器端的導航（重定向等）。

人們強烈但願不要硬編碼這些URL（費力、不可擴展且容易產生錯誤）或者設計一種與URLconf 絕不相關的專門的URL 生成機制，由於這樣容易致使必定程度上產生過時的URL。

換句話講，須要的是一個DRY 機制。除了其它有點，它還容許設計的URL 能夠自動更新而不用遍歷項目的源代碼來搜索並替換過時的URL。

獲取一個URL 最開始想到的信息是處理它視圖的標識（例如名字），查找正確的URL 的其它必要的信息有視圖參數的類型（位置參數、關鍵字參數）和值。

Django 提供一個辦法是讓URL 映射是URL 設計惟一的地方。你填充你的URLconf，而後能夠雙向使用它：

根據用戶/瀏覽器發起的URL 請求，它調用正確的Django 視圖，並從URL 中提取它的參數須要的值。
根據Django 視圖的標識和將要傳遞給它的參數的值，獲取與之關聯的URL。

第一種方式是咱們在前面的章節中一直討論的用法。第二種方式叫作反向解析URL、反向URL 匹配、反向URL 查詢或者簡單的URL 反查。

在須要URL 的地方，對於不一樣層級，Django 提供不一樣的工具用於URL 反查：

在模板中：使用url 模板標籤。
在Python 代碼中：使用django.core.urlresolvers.reverse() 函數。
在更高層的與處理Django 模型實例相關的代碼中：使用get_absolute_url() 方法。

例子：

考慮下面的URLconf：

from django.conf.urls import url

from . import views

urlpatterns = [
    #...
    url(r'^articles/([0-9]{4})/$', views.year_archive, name='news-year-archive'),
    #...
]

根據這裏的設計，某一年nnnn對應的歸檔的URL是/articles/nnnn/。

你能夠在模板的代碼中使用下面的方法得到它們：

<a href="{% url 'news-year-archive' 2012 %}">2012 Archive</a>

<ul>
{% for yearvar in year_list %}
<li><a href="{% url 'news-year-archive' yearvar %}">{{ yearvar }} Archive</a></li>
{% endfor %}
</ul>

在Python 代碼中，這樣使用：

from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect

def redirect_to_year(request):
    # ...
    year = 2006
    # ...
    return HttpResponseRedirect(reverse('news-year-archive', args=(year,)))

若是出於某種緣由決定按年歸檔文章發佈的URL應該調整一下，那麼你將只須要修改URLconf 中的內容。

在某些場景中，一個視圖是通用的，因此在URL 和視圖之間存在多對一的關係。對於這些狀況，當反查URL 時，只有視圖的名字還不夠。

2.4 命名URL 模式

爲了完成上面例子中的URL 反查，你將須要使用命名的URL 模式。URL 的名稱使用的字符串能夠包含任何你喜歡的字符。不僅限制在合法的Python 名稱。

當命名你的URL 模式時，請確保使用的名稱不會與其它應用中名稱衝突。若是你的URL 模式叫作comment，而另一個應用中也有一個一樣的名稱，當你在模板中使用這個名稱的時候不能保證將插入哪一個URL。

在URL 名稱中加上一個前綴，好比應用的名稱，將減小衝突的可能。咱們建議使用myapp-comment 而不是comment。

2.5 CBV

url(r'^login.html$', views.Login.as_view()),

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
from django.views import View
class Login(View):
    
    def dispatch(self, request, *args, **kwargs):
        print('before')
        obj = super(Login,self).dispatch(request, *args, **kwargs)
        print('after')
        return obj

    def get(self,request):
       
        return render(request,'login.html')

    def post(self,request):
        print(request.POST.get('user'))
        return HttpResponse('Login.post')

d視圖層之視圖函數(views)

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

一個簡單的視圖

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

from django.http import HttpResponse
import datetime

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

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

首先，咱們從 django.http模塊導入了HttpResponse類，以及Python的datetime庫。
接着，咱們定義了current_datetime函數。它就是視圖函數。每一個視圖函數都使用HttpRequest對象做爲第一個參數，而且一般稱之爲request。

注意,視圖函數的名稱並不重要；不須要用一個統一的命名方式來命名，以便讓Django識別它。咱們將其命名爲current_datetime，是由於這個名稱可以精確地反映出它的功能。
這個視圖會返回一個HttpResponse對象，其中包含生成的響應。每一個視圖函數都負責返回一個HttpResponse對象。

HttpRequest對象

屬性：

'''
path：       請求頁面的全路徑，不包括域名

method：     請求中使用的HTTP方法的字符串表示。全大寫表示。例如

               if  req.method=="GET":

                         do_something()

               elif req.method=="POST":

                         do_something_else()

GET:         包含全部HTTP GET參數的類字典對象

POST：       包含全部HTTP POST參數的類字典對象

COOKIES:     包含全部cookies的標準Python字典對象；keys和values都是字符串。

FILES：      包含全部上傳文件的類字典對象；FILES中的每個Key都是<input type="file" name="" />標籤中
             name屬性的值，FILES中的每個value同時也是一個標準的python字典對象，包含下面三個Keys：

             filename：      上傳文件名，用字符串表示
             content_type:   上傳文件的Content Type
             content：       上傳文件的原始內容


user：       是一個django.contrib.auth.models.User對象，表明當前登錄的用戶。若是訪問用戶當前
             沒有登錄，user將被初始化爲django.contrib.auth.models.AnonymousUser的實例。你
             能夠經過user的is_authenticated()方法來辨別用戶是否登錄：
             if req.user.is_authenticated();只有激活Django中的AuthenticationMiddleware
             時該屬性纔可用

session：    惟一可讀寫的屬性，表明當前會話的字典對象；本身有激活Django中的session支持時該屬性纔可用。

'''

方法：

get_full_path()

注意：鍵值對的值是多個的時候,好比checkbox類型的input標籤，select標籤，須要用：

request.POST.getlist("hobby")

render 函數

render(request, template_name[, context]）

結合一個給定的模板和一個給定的上下文字典，並返回一個渲染後的 HttpResponse 對象。

參數：
     request： 用於生成響應的請求對象。

     template_name：要使用的模板的完整名稱，可選的參數

     context：添加到模板上下文的一個字典。默認是一個空字典。若是字典中的某個值是可調用的，視圖將在渲染模板以前調用它。

     content_type：生成的文檔要使用的MIME類型。默認爲DEFAULT_CONTENT_TYPE 設置的值。

     status：響應的狀態碼。默認爲200。

redirect 函數

參數能夠是：

一個模型：將調用模型的get_absolute_url() 函數
一個視圖，能夠帶有參數：將使用urlresolvers.reverse 來反向解析名稱
一個絕對的或相對的URL，將原封不動的做爲重定向的位置。

默認返回一個臨時的重定向；傳遞permanent=True 能夠返回一個永久的重定向。

示例:

你能夠用多種方式使用redirect() 函數。

傳遞一個對象

將調用get_absolute_url() 方法來獲取重定向的URL：

from django.shortcuts import redirect

def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object)

傳遞一個視圖的名稱

能夠帶有位置參數和關鍵字參數；將使用reverse() 方法反向解析URL：　

def my_view(request):
    ...
    return redirect('some-view-name', foo='bar')

傳遞要重定向的一個硬編碼的URL

def my_view(request):
    ...
    return redirect('/some/url/')

也能夠是一個完整的URL：

def my_view(request):
    ...
    return redirect('http://example.com/')

默認狀況下，redirect() 返回一個臨時重定向。以上全部的形式都接收一個permanent 參數；若是設置爲True，將返回一個永久的重定向：

def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object, permanent=True)

跳轉（重定向）應用

-----------------------------------url.py

 url(r"login",   views.login),
 url(r"yuan_back",   views.yuan_back),

-----------------------------------views.py
def login(req):
    if req.method=="POST":
        if 1:
            # return redirect("/yuan_back/")
            name="yuanhao"

            return render(req,"my backend.html",locals())

    return render(req,"login.html",locals())


def yuan_back(req):

    name="苑昊"

    return render(req,"my backend.html",locals())

-----------------------------------login.html

<form action="/login/" method="post">
    <p>姓名<input type="text" name="username"></p>
    <p>性別<input type="text" name="sex"></p>
    <p>郵箱<input type="text" name="email"></p>
    <p><input type="submit" value="submit"></p>
</form>
-----------------------------------my backend.html
<h1>用戶{{ name }}你好</h1>

View Code

注意：render和redirect的區別:

一、 if 頁面須要模板語言渲染,須要的將數據庫的數據加載到html,那麼render方法則不會顯示這一部分。

二、 the most important: url沒有跳轉到/yuan_back/,而是還在/login/,因此當刷新後又得從新登陸。

模板層(template)

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

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

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

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

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

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

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

python的模板：HTML代碼＋模板語法

模版包括在使用時會被值替換掉的變量，和控制模版邏輯的標籤。

def current_time(req):
    # ================================原始的視圖函數
    # import datetime
    # now=datetime.datetime.now()
    # html="<html><body>如今時刻：<h1>%s.</h1></body></html>" %now


    # ================================django模板修改的視圖函數
    # from django.template import Template,Context
    # now=datetime.datetime.now()
    # t=Template('<html><body>如今時刻是:<h1>{{current_date}}</h1></body></html>')
    # #t=get_template('current_datetime.html')
    # c=Context({'current_date':str(now)})
    # html=t.render(c)
    #
    # return HttpResponse(html)


    #另外一種寫法(推薦)
    import datetime
    now=datetime.datetime.now()
    return render(req, 'current_datetime.html', {'current_date':str(now)[:19]})

模板語法之變量

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

語法：

 {{var_name}}

views：

def index(request):
    import datetime
    s="hello"
    l=[111,222,333]    # 列表
    dic={"name":"yuan","age":18}  # 字典
    date = datetime.date(1993, 5, 2)   # 日期對象

    class Person(object):
        def __init__(self,name):
            self.name=name

    person_yuan=Person("yuan")  # 自定義類對象
    person_egon=Person("egon")
    person_alex=Person("alex")

    person_list=[person_yuan,person_egon,person_alex]


    return render(request,"index.html",{"l":l,"dic":dic,"date":date,"person_list":person_list})

template：

<h4>{{s}}</h4>
<h4>列表:{{ l.0 }}</h4>
<h4>列表:{{ l.2 }}</h4>
<h4>字典:{{ dic.name }}</h4>
<h4>日期:{{ date.year }}</h4>
<h4>類對象列表:{{ person_list.0.name }}</h4>

注意：句點符也能夠用來引用對象的方法(無參數方法)。

<h4>字典:{{ dic.name.upper }}</h4>

模板之過濾器

語法：

{{obj|filter__name:param}}

`default`

若是一個變量是false或者爲空，使用給定的默認值。不然，使用變量的值。例如：

{{ value|default:"nothing" }}

length

返回值的長度。它對字符串和列表都起做用。例如：

{{ value|length }}

若是 value 是 ['a', 'b', 'c', 'd']，那麼輸出是 4。

`filesizeformat`

將值格式化爲一個「人類可讀的」文件尺寸（例如 '13 KB', '4.1 MB', '102 bytes', 等等）。例如：

{{ value|filesizeformat }}

若是 value 是 123456789，輸出將會是 117.7 MB。　　

date

若是 value=datetime.datetime.now()

{{ value|date:"Y-m-d" }}

slice

若是 value="hello world"

{{ value|slice:"2:-1" }}

truncatechars

若是字符串字符多於指定的字符數量，那麼會被截斷。截斷的字符串將以可翻譯的省略號序列（「...」）結尾。

參數：要截斷的字符數

例如：

{{ value|truncatechars:9 }}

若是value是「Joel 是 a >，輸出將爲「Joel i ...」。

safe

Django的模板中會對HTML標籤和JS等語法標籤進行自動轉義，緣由顯而易見，這樣是爲了安全。可是有的時候咱們可能不但願這些HTML元素被轉義，好比咱們作一個內容管理系統，後臺添加的文章中是通過修飾的，這些修飾多是經過一個相似於FCKeditor編輯加註了HTML修飾符的文本，若是自動轉義的話顯示的就是保護HTML標籤的源文件。爲了在Django中關閉HTML的自動轉義有兩種方式，若是是一個單獨的變量咱們能夠經過過濾器「|safe」的方式告訴Django這段代碼是安全的沒必要轉義。好比：

value="<a href="">點擊</a>"

{{ value|safe}}

這裏簡單介紹一些經常使用的模板的過濾器，更多詳見

模板之標籤　

標籤看起來像是這樣的： {% tag %}。標籤比變量更加複雜：一些在輸出中建立文本，一些經過循環或邏輯來控制流程，一些加載其後的變量將使用到的額外信息到模版中。

一些標籤須要開始和結束標籤（例如{% tag %} ...標籤內容 ... {% endtag %}）。

for標籤

遍歷每個元素：

{% for person in person_list %}
    <p>{{ person.name }}</p>
{% endfor %}

能夠利用{% for obj in list reversed %}反向完成循環。

遍歷一個字典：

{% for key,val in dic.items %}
    <p>{{ key }}:{{ val }}</p>
{% endfor %}

注：循環序號能夠經過｛｛forloop｝｝顯示　　

forloop.counter	        The current iteration of the loop (1-indexed)
forloop.counter0	The current iteration of the loop (0-indexed)
forloop.revcounter	The number of iterations from the end of the loop (1-indexed)
forloop.revcounter0	The number of iterations from the end of the loop (0-indexed)
forloop.first	        True if this is the first time through the loop
forloop.last	        True if this is the last time through the loop

for ... empty

for 標籤帶有一個可選的{% empty %} 從句，以便在給出的組是空的或者沒有被找到時，能夠有所操做。

{% for person in person_list %}
    <p>{{ person.name }}</p>

{% empty %}
    <p>sorry,no person here</p>
{% endfor %}

if 標籤

{% if %}會對一個變量求值，若是它的值是「True」（存在、不爲空、且不是boolean類型的false值），對應的內容塊會輸出。

{% if num > 100 or num < 0 %}
    <p>無效</p>
{% elif num > 80 and num < 100 %}
    <p>優秀</p>
{% else %}
    <p>湊活吧</p>
{% endif %}

with

使用一個簡單地名字緩存一個複雜的變量，當你須要使用一個「昂貴的」方法（好比訪問數據庫）不少次的時候是很是有用的

例如：

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

csrf_token

這個標籤用於跨站請求僞造保護

自定義標籤和過濾器

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

二、在app中建立templatetags模塊(模塊名只能是templatetags)

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

from django import template
from django.utils.safestring import mark_safe

register = template.Library()   #register的名字是固定的,不可改變


@register.filter
def filter_multi(v1,v2):
    return  v1 * v2


@register.simple_tag
def simple_tag_multi(v1,v2):
    return  v1 * v2


@register.simple_tag
def my_input(id,arg):
    result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
    return mark_safe(result)

四、在使用自定義simple_tag和filter的html文件中導入以前建立的 my_tags.py

{% load my_tags %}

五、使用simple_tag和filter（如何調用）

-------------------------------.html
{% load xxx %}   
     
# num=12
{{ num|filter_multi:2 }} #24

{{ num|filter_multi:"[22,333,4444]" }}

{% simple_tag_multi 2 5 %}  參數不限,但不能放在if for語句中
{% simple_tag_multi num 5 %}

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

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

模板繼承 (extend)

Django模版引擎中最強大也是最複雜的部分就是模版繼承了。模版繼承可讓您建立一個基本的「骨架」模版，它包含您站點中的所有元素，而且能夠定義可以被子模版覆蓋的 blocks 。

經過從下面這個例子開始，能夠容易的理解模版繼承：

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>{% block title %}My amazing site{%/span> endblock %}</title>
</head>

<body>
    <div id="sidebar">
        {% block sidebar %}
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
        {% endblock %}
    </div>

    <div id="content">
        {% block content %}{% endblock %}
    </div>
</body>
</html>

這個模版，咱們把它叫做 base.html，它定義了一個能夠用於兩列排版頁面的簡單HTML骨架。「子模版」的工做是用它們的內容填充空的blocks。

在這個例子中， block 標籤訂義了三個能夠被子模版內容填充的block。 block 告訴模版引擎：子模版可能會覆蓋掉模版中的這些位置。

子模版可能看起來是這樣的：

{% extends "base.html" %}

{% block title %}My amazing blog{% endblock %}

{% block content %}
{% for entry in blog_entries %}
    <h2>{{ entry.title }}</h2>
    <p>{{ entry.body }}</p>
{% endfor %}
{% endblock %}

extends 標籤是這裏的關鍵。它告訴模版引擎，這個模版「繼承」了另外一個模版。當模版系統處理這個模版時，首先，它將定位父模版——在此例中，就是「base.html」。

那時，模版引擎將注意到 base.html 中的三個 block 標籤，並用子模版中的內容來替換這些block。根據 blog_entries 的值，輸出可能看起來是這樣的：

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>My amazing blog</title>
</head>

<body>
    <div id="sidebar">
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
    </div>

    <div id="content">
        <h2>Entry one</h2>
        <p>This is my first entry.</p>

        <h2>Entry two</h2>
        <p>This is my second entry.</p>
    </div>
</body>
</html>

請注意，子模版並無定義 sidebar block，因此係統使用了父模版中的值。父模版的 {% block %} 標籤中的內容老是被用做備選內容（fallback）。

這種方式使代碼獲得最大程度的複用，而且使得添加內容到共享的內容區域更加簡單，例如，部分範圍內的導航。

這裏是使用繼承的一些提示：

若是你在模版中使用 {% extends %} 標籤，它必須是模版中的第一個標籤。其餘的任何狀況下，模版繼承都將沒法工做。
在base模版中設置越多的 {% block %} 標籤越好。請記住，子模版沒必要定義所有父模版中的blocks，因此，你能夠在大多數blocks中填充合理的默認內容，而後，只定義你須要的那一個。多一點鉤子總比少一點好。
若是你發現你本身在大量的模版中複製內容，那可能意味着你應該把內容移動到父模版中的一個 {% block %} 中。
If you need to get the content of the block from the parent template, the {{ block.super }} variable will do the trick. This is useful if you want to add to the contents of a parent block instead of completely overriding it. Data inserted using {{ block.super }} will not be automatically escaped (see the next section), since it was already escaped, if necessary, in the parent template.
爲了更好的可讀性，你也能夠給你的 {% endblock %} 標籤一個名字。例如：
```
{% block content %}
...
{% endblock content %}　　
```
在大型模版中，這個方法幫你清楚的看到哪個　 {% block %} 標籤被關閉了。

最後，請注意您並不能在一個模版中定義多個相同名字的 block 標籤。這個限制的存在是由於block標籤的做用是「雙向」的。這個意思是，block標籤不只提供了一個坑去填，它還在 _父模版_中定義了填坑的內容。若是在一個模版中有兩個名字同樣的 block 標籤，模版的父模版將不知道使用哪一個block的內容。

Django-model基礎

ORM

映射關係：

　　　  表名  <－－－－－－－> 類名

       字段  <－－－－－－－> 屬性

　　　　表記錄 <－－－－－－－>類實例對象

建立表(創建模型)

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

做者模型：一個做者有姓名和年齡。

做者詳細模型：把做者的詳情放到詳情表，包含生日，手機號，家庭住址等信息。做者詳情模型和做者模型之間是一對一的關係（one-to-one）

出版商模型：出版商有名稱，所在城市以及email。

書籍模型：書籍有書名和出版日期，一本書可能會有多個做者，一個做者也能夠寫多本書，因此做者和書籍的關係就是多對多的關聯關係(many-to-many);一本書只應該由一個出版商出版，因此出版商和書籍是一對多關聯關係(one-to-many)。

模型創建以下：

class Author(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    age=models.IntegerField()

    # 與AuthorDetail創建一對一的關係
    authorDetail=models.OneToOneField(to="AuthorDetail")

class AuthorDetail(models.Model):

    nid = models.AutoField(primary_key=True)
    birthday=models.DateField()
    telephone=models.BigIntegerField()
    addr=models.CharField( max_length=64)
   
class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    city=models.CharField( max_length=32)
    email=models.EmailField()


class Book(models.Model):

    nid = models.AutoField(primary_key=True)
    title = models.CharField( max_length=32)
    publishDate=models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2)
    keepNum=models.IntegerField()
    commentNum=models.IntegerField()

    # 與Publish創建一對多的關係,外鍵字段創建在多的一方
    publish=models.ForeignKey(to="Publish",to_field="nid")

    # 與Author表創建多對多的關係,ManyToManyField能夠建在兩個模型中的任意一個，自動建立第三張表
    authors=models.ManyToManyField(to='Author')

經過logging能夠查看翻譯成的sql語句

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

注意事項：

一、表的名稱myapp_modelName，是根據模型中的元數據自動生成的，也能夠覆寫爲別的名稱　　

二、id 字段是自動添加的

三、對於外鍵字段，Django 會在字段名上添加"_id" 來建立數據庫中的列名

四、這個例子中的CREATE TABLE SQL 語句使用PostgreSQL 語法格式，要注意的是Django 會根據settings 中指定的數據庫類型來使用相應的SQL 語句。

五、定義好模型以後，你須要告訴Django _使用_這些模型。你要作的就是修改配置文件中的INSTALL_APPSZ中設置，在其中添加models.py所在應用的名稱。

六、外鍵字段 ForeignKey 有一個 null=True 的設置(它容許外鍵接受空值 NULL)，你能夠賦給它空值 None 。

字段選項

每一個字段有一些特有的參數，例如，CharField須要max_length參數來指定VARCHAR數據庫字段的大小。還有一些適用於全部字段的通用參數。這些參數在文檔中有詳細定義，這裏咱們只簡單介紹一些最經常使用的：

(1)null

若是爲True，Django 將用NULL 來在數據庫中存儲空值。 默認值是 False.

(1)blank

若是爲True，該字段容許不填。默認爲False。
要注意，這與 null 不一樣。null純粹是數據庫範疇的，而 blank 是數據驗證範疇的。
若是一個字段的blank=True，表單的驗證將容許該字段是空值。若是字段的blank=False，該字段就是必填的。

(2)default

字段的默認值。能夠是一個值或者可調用對象。若是可調用 ，每有新對象被建立它都會被調用。

(3)primary_key

若是爲True，那麼這個字段就是模型的主鍵。若是你沒有指定任何一個字段的primary_key=True，
Django 就會自動添加一個IntegerField字段作爲主鍵，因此除非你想覆蓋默認的主鍵行爲，
不然不必設置任何一個字段的primary_key=True。

(4)unique

若是該值設置爲 True, 這個數據字段的值在整張表中必須是惟一的

(5)choices
由二元組組成的一個可迭代對象（例如，列表或元組），用來給字段提供選擇項。 若是設置了choices ，默認的表單將是一個選擇框而不是標準的文本框，並且這個選擇框的選項就是choices 中的選項。

這是一個關於 choices 列表的例子：

YEAR_IN_SCHOOL_CHOICES = (
    ('FR', 'Freshman'),
    ('SO', 'Sophomore'),
    ('JR', 'Junior'),
    ('SR', 'Senior'),
    ('GR', 'Graduate'),
)
每一個元組中的第一個元素，是存儲在數據庫中的值；第二個元素是在管理界面或 ModelChoiceField 中用做顯示的內容。 在一個給定的 model 類的實例中，想獲得某個 choices 字段的顯示值，就調用 get_FOO_display 方法(這裏的 FOO 就是 choices 字段的名稱 )。例如：

from django.db import models

class Person(models.Model):
    SHIRT_SIZES = (
        ('S', 'Small'),
        ('M', 'Medium'),
        ('L', 'Large'),
    )
    name = models.CharField(max_length=60)
    shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)


>>> p = Person(name="Fred Flintstone", shirt_size="L")
>>> p.save()
>>> p.shirt_size
'L'
>>> p.get_shirt_size_display()
'Large'

View Code

更多詳見模型字段參考

一旦你創建好數據模型以後，django會自動生成一套數據庫抽象的API，可讓你執行關於表記錄的增刪改查的操做。

添加表記錄

普通字段

方式1
publish_obj=Publish(name="人民出版社",city="北京",email="renMin@163.com")
publish_obj.save() # 將數據保存到數據庫

方式2 
返回值publish_obj是添加的記錄對象
publish_obj=Publish.objects.create(name="人民出版社",city="北京",email="renMin@163.com")

外鍵字段

 方式1:
    publish_obj=Publish.objects.get(nid=1)
    Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=665,pageNum=334,publish=publish_obj)

 方式2:
    Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=665,pageNum=334,publish_id=1)

關鍵點：book_obj.publish是什麼？

多對多字段

book_obj=Book.objects.create(title="追風箏的人",publishDate="2012-11-12",price=69,pageNum=314,publish_id=1)

author_yuan=Author.objects.create(name="yuan",age=23,authorDetail_id=1)
author_egon=Author.objects.create(name="egon",age=32,authorDetail_id=2)

book_obj.authors.add(author_egon,author_yuan)    #  將某個特定的 model 對象添加到被關聯對象集合中。   =======    book_obj.authors.add(*[])

book_obj.authors.create()      #建立並保存一個新對象，而後將這個對象加被關聯對象的集合中，而後返回這個新對象。

關鍵點：book_obj.authors是什麼？　　

解除關係：

book_obj.authors.remove()     # 將某個特定的對象從被關聯對象集合中去除。    ======   book_obj.authors.remove(*[])
book_obj.authors.clear()       #清空被關聯對象集合。

class RelatedManager

"關聯管理器"是在一對多或者多對多的關聯上下文中使用的管理器。它存在於下面兩種狀況：

ForeignKey關係的「另外一邊」。像這樣：

from django.db import models

class Reporter(models.Model):
    # ...
    pass

class Article(models.Model):
    reporter = models.ForeignKey(Reporter)

在上面的例子中，管理器reporter.article_set擁有下面的方法。

ManyToManyField關係的兩邊：

class Topping(models.Model):
    # ...
    pass

class Pizza(models.Model):
    toppings = models.ManyToManyField(Topping)

這個例子中，topping.pizza_set 和pizza.toppings都擁有下面的方法。

add(obj1[, obj2, ...])

把指定的模型對象添加到關聯對象集中。

例如：

>>> b = Blog.objects.get(id=1)
>>> e = Entry.objects.get(id=234)
>>> b.entry_set.add(e) # Associates Entry e with Blog b.

在上面的例子中，對於ForeignKey關係，e.save()由關聯管理器調用，執行更新操做。然而，在多對多關係中使用add()並不會調用任何 save()方法，而是由QuerySet.bulk_create()建立關係。

create(**kwargs)

建立一個新的對象，保存對象，並將它添加到關聯對象集之中。返回新建立的對象：

>>> b = Blog.objects.get(id=1)
>>> e = b.entry_set.create(
...     headline='Hello',
...     body_text='Hi',
...     pub_date=datetime.date(2005, 1, 1)
... )

# No need to call e.save() at this point -- it's already been saved.

這徹底等價於（不過更加簡潔於）：

>>> b = Blog.objects.get(id=1)
>>> e = Entry(
...     blog=b,
...     headline='Hello',
...     body_text='Hi',
...     pub_date=datetime.date(2005, 1, 1)
... )
>>> e.save(force_insert=True)

要注意咱們並不須要指定模型中用於定義關係的關鍵詞參數。在上面的例子中，咱們並無傳入blog參數給create()。Django會明白新的 Entry對象blog 應該添加到b中。

remove(obj1[, obj2, ...])

從關聯對象集中移除執行的模型對象：

>>> b = Blog.objects.get(id=1)
>>> e = Entry.objects.get(id=234)
>>> b.entry_set.remove(e) # Disassociates Entry e from Blog b.

對於ForeignKey對象，這個方法僅在null=True時存在。

clear()

從關聯對象集中移除一切對象。

>>> b = Blog.objects.get(id=1)
>>> b.entry_set.clear()

注意這樣不會刪除對象 —— 只會刪除他們之間的關聯。

就像 remove() 方法同樣，clear()只能在 null=True的ForeignKey上被調用。

注意

對於全部類型的關聯字段，add()、create()、remove()和clear()都會立刻更新數據庫。換句話說，在關聯的任何一端，都不須要再調用save()方法。

直接賦值：

經過賦值一個新的可迭代的對象，關聯對象集能夠被總體替換掉。

>>> new_list = [obj1, obj2, obj3]
>>> e.related_set = new_list

若是外鍵關係知足null=True，關聯管理器會在添加new_list中的內容以前，首先調用clear()方法來解除關聯集中一切已存在對象的關聯。不然， new_list中的對象會在已存在的關聯的基礎上被添加。　　

查詢表記錄

查詢相關API

 <1> all():                 查詢全部結果

 <2> filter(**kwargs):      它包含了與所給篩選條件相匹配的對象

 <3> get(**kwargs):         返回與所給篩選條件相匹配的對象，返回結果有且只有一個，
                            若是符合篩選條件的對象超過一個或者沒有都會拋出錯誤。

 <5> exclude(**kwargs):     它包含了與所給篩選條件不匹配的對象

 <4> values(*field):        返回一個ValueQuerySet——一個特殊的QuerySet，運行後獲得的並非一系列
                            model的實例化對象，而是一個可迭代的字典序列

 <9> values_list(*field):   它與values()很是類似，它返回的是一個元組序列，values返回的是一個字典序列

 <6> order_by(*field):      對查詢結果排序

 <7> reverse():             對查詢結果反向排序

 <8> distinct():            從返回結果中剔除重複紀錄

 <10> count():              返回數據庫中匹配查詢(QuerySet)的對象數量。

 <11> first():              返回第一條記錄

 <12> last():               返回最後一條記錄

 <13> exists():             若是QuerySet包含數據，就返回True，不然返回False

注意：必定區分object與querySet的區別！！！

雙下劃線之單表查詢

   models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 獲取id大於1 且 小於10的值

   models.Tb1.objects.filter(id__in=[11, 22, 33])   # 獲取id等於十一、2二、33的數據
   models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

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

   models.Tb1.objects.filter(id__range=[1, 2])      # 範圍bettwen and

   startswith，istartswith, endswith, iendswith

基於對象的跨表查詢

一對多查詢（Publish 與 Book）

正向查詢(按字段：publish)：

# 查詢nid=1的書籍的出版社所在的城市

book_obj=Book.objects.get(nid=1)
print(book_obj.publish.city) # book_obj.publish 是nid=1的書籍對象關聯的出版社對象

反向查詢(按表名：book_set)：

# 查詢 人民出版社出版過的全部書籍

    publish=Publish.objects.get(name="人民出版社")

    book_list=publish.book_set.all()  # 與人民出版社關聯的全部書籍對象集合

    for book_obj in book_list:
        print(book_obj.title)

一對一查詢(Author 與 AuthorDetail)

正向查詢(按字段：authorDetail)：

# 查詢egon做者的手機號

    author_egon=Author.objects.get(name="egon")
    print(author_egon.authorDetail.telephone)

反向查詢(按表名：author)：

# 查詢全部住址在北京的做者的姓名

    authorDetail_list=AuthorDetail.objects.filter(addr="beijing")

    for obj in authorDetail_list:
        print(obj.author.name)

多對多查詢 (Author 與 Book)

正向查詢(按字段：authors)：

# 金瓶眉全部做者的名字以及手機號

    book_obj=Book.objects.filter(title="金瓶眉").first()

    authors=book_obj.authors.all()

    for author_obj in authors:

        print(author_obj.name,author_obj.authorDetail.telephone)

反向查詢(按表名：book_set)：

# 查詢egon出過的全部書籍的名字

    author_obj=Author.objects.get(name="egon")
    book_list=author_obj.book_set.all() #與egon做者相關的全部書籍

    for book_obj in book_list:
        print(book_obj.title)

注意：

你能夠經過在 ForeignKey() 和ManyToManyField的定義中設置 related_name 的值來覆寫 FOO_set 的名稱。例如，若是 Article model 中作一下更改： publish = ForeignKey(Blog, related_name='bookList')，那麼接下來就會如咱們看到這般：

 # 查詢 人民出版社出版過的全部書籍

    publish=Publish.objects.get(name="人民出版社")

    book_list=publish.bookList.all()  # 與人民出版社關聯的全部書籍對象集合

基於雙下劃線的跨表查詢

Django 還提供了一種直觀而高效的方式在查詢(lookups)中表示關聯關係，它能自動確認 SQL JOIN 聯繫。要作跨關係查詢，就使用兩個下劃線來連接模型(model)間關聯字段的名稱，直到最終連接到你想要的 model 爲止。

# 練習1:  查詢人民出版社出版過的全部書籍的名字與價格(一對多)

    # 正向查詢 按字段:publish

    queryResult=Book.objects
　　　　　　　　　　　　.filter(publish__name="人民出版社")
　　　　　　　　　　　　.values_list("title","price")

    # 反向查詢 按表名:book

    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("book__title","book__price")



# 練習2: 查詢egon出過的全部書籍的名字(多對多)

    # 正向查詢 按字段:authors:
    queryResult=Book.objects
　　　　　　　　　　　　.filter(authors__name="yuan")
　　　　　　　　　　　　.values_list("title")

    # 反向查詢 按表名:book
    queryResult=Author.objects
　　　　　　　　　　　　　　.filter(name="yuan")
　　　　　　　　　　　　　　.values_list("book__title","book__price")


# 練習3: 查詢人民出版社出版過的全部書籍的名字以及做者的姓名


    # 正向查詢
    queryResult=Book.objects
　　　　　　　　　　　　.filter(publish__name="人民出版社")
　　　　　　　　　　　　.values_list("title","authors__name")
    # 反向查詢
    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("book__title","book__authors__age","book__authors__name")


# 練習4: 手機號以151開頭的做者出版過的全部書籍名稱以及出版社名稱

    queryResult=Book.objects
　　　　　　　　　　　　.filter(authors__authorDetail__telephone__regex="151")
　　　　　　　　　　　　.values_list("title","publish__name")

注意：

反向查詢時，若是定義了related_name ，則用related_name替換表名，例如： publish = ForeignKey(Blog, related_name='bookList')：

# 練習1:  查詢人民出版社出版過的全部書籍的名字與價格(一對多)

    # 反向查詢 再也不按表名:book,而是related_name:bookList

    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("bookList__title","bookList__price")

聚合查詢與分組查詢

`聚合：aggregate`(*args, **kwargs)

# 計算全部圖書的平均價格
    >>> from django.db.models import Avg
    >>> Book.objects.all().aggregate(Avg('price'))
    {'price__avg': 34.35}

aggregate()是QuerySet 的一個終止子句，意思是說，它返回一個包含一些鍵值對的字典。鍵的名稱是聚合值的標識符，值是計算出來的聚合值。鍵的名稱是按照字段和聚合函數的名稱自動生成出來的。若是你想要爲聚合值指定一個名稱，能夠向聚合子句提供它。

>>> Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 34.35}

若是你但願生成不止一個聚合，你能夠向aggregate()子句中添加另外一個參數。因此，若是你也想知道全部圖書價格的最大值和最小值，能夠這樣查詢：

>>> from django.db.models import Avg, Max, Min
>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

分組：annotate()　

爲QuerySet中每個對象都生成一個獨立的彙總值。　

(1) 練習：統計每一本書的做者個數

    bookList=Book.objects.annotate(authorsNum=Count('authors'))
    for book_obj in bookList:
        print(book_obj.title,book_obj.authorsNum)

SELECT 
"app01_book"."nid", 
"app01_book"."title", 
"app01_book"."publishDate", 
"app01_book"."price", 
"app01_book"."pageNum", 
"app01_book"."publish_id", 
COUNT("app01_book_authors"."author_id") AS "authorsNum" 
FROM "app01_book" LEFT OUTER JOIN "app01_book_authors" 
ON ("app01_book"."nid" = "app01_book_authors"."book_id") 
GROUP BY 
"app01_book"."nid", 
"app01_book"."title", 
"app01_book"."publishDate", 
"app01_book"."price", 
"app01_book"."pageNum", 
"app01_book"."publish_id"

sql

(2) 若是想對所查詢對象的關聯對象進行聚合：

練習：統計每個出版社的最便宜的書

    publishList=Publish.objects.annotate(MinPrice=Min("book__price"))

    for publish_obj in publishList:
        print(publish_obj.name,publish_obj.MinPrice)

annotate的返回值是querySet，若是不想遍歷對象，能夠用上valuelist：

queryResult= Publish.objects
　　　　　　　　　　　　.annotate(MinPrice=Min("book__price"))
　　　　　　　　　　　　.values_list("name","MinPrice")
print(queryResult)

方式2:　

queryResult=Book.objects.values("publish__name").annotate(MinPrice=Min('price'))

注意：values內的字段即group by的字段

(3) 統計每一本以py開頭的書籍的做者個數：

 queryResult=Book.objects
　　　　　　　　　　 .filter(title__startswith="Py")
　　　　　　　　　 　.annotate(num_authors=Count('authors'))

(4) 統計不止一個做者的圖書：

queryResult=Book.objects
　　　　　　　　　　.annotate(num_authors=Count('authors'))
　　　　　　　　　　.filter(num_authors__gt=1)

(5) 根據一本圖書做者數量的多少對查詢集 QuerySet進行排序:

Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')

(6) 查詢各個做者出的書的總價格:

# 按author表的全部字段 group by
    queryResult=Author.objects
　　　　　　　　　　　　　　.annotate(SumPrice=Sum("book__price"))
　　　　　　　　　　　　　　.values_list("name","SumPrice")
    print(queryResult)
    
#按authors__name group by
    queryResult2=Book.objects.values("authors__name")
　　　　　　　　　　　　　　.annotate(SumPrice=Sum("price"))
　　　　　　　　　　　　　　.values_list("authors__name","SumPrice")
    print(queryResult2)

F查詢與Q查詢

F查詢

在上面全部的例子中，咱們構造的過濾器都只是將字段值與某個常量作比較。若是咱們要對兩個字段的值作比較，那該怎麼作呢？

Django 提供 F() 來作這樣的比較。F() 的實例能夠在查詢中引用字段，來比較同一個 model 實例中兩個不一樣字段的值。

 # 查詢評論數大於收藏數的書籍

    from django.db.models import F
    Book.objects.filter(commnetNum__lt=F('keepNum'))

Django 支持 F() 對象之間以及 F() 對象和常數之間的加減乘除和取模的操做。

# 查詢評論數大於收藏數2倍的書籍
    Book.objects.filter(commnetNum__lt=F('keepNum')*2)

修改操做也可使用F函數,好比將每一本書的價格提升30元：

Book.objects.all().update(price=F("price")+30)

Q查詢

filter() 等方法中的關鍵字參數查詢都是一塊兒進行「AND」的。若是你須要執行更復雜的查詢（例如OR 語句），你可使用Q 對象。

from django.db.models import Q
Q(title__startswith='Py')

Q 對象可使用& 和| 操做符組合起來。當一個操做符在兩個Q 對象上使用時，它產生一個新的Q 對象。

bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))

等同於下面的SQL WHERE 子句：

WHERE name ="yuan" OR name ="egon"

你能夠組合& 和| 操做符以及使用括號進行分組來編寫任意複雜的Q 對象。同時，Q 對象可使用~ 操做符取反，這容許組合正常的查詢和取反(NOT) 查詢：

 bookList=Book.objects.filter(Q(authors__name="yuan") & ~Q(publishDate__year=2017)).values_list("title")

查詢函數能夠混合使用Q 對象和關鍵字參數。全部提供給查詢函數的參數（關鍵字參數或Q 對象）都將"AND」在一塊兒。可是，若是出現Q 對象，它必須位於全部關鍵字參數的前面。例如：

    bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),
                                  title__icontains="python"
                                 )

修改表記錄

注意：

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

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

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

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

刪除表記錄

刪除方法就是 delete()。它運行時當即刪除對象而不返回任何值。例如：

e.delete()

你也能夠一次性刪除多個對象。每一個 QuerySet 都有一個 delete() 方法，它一次性刪除 QuerySet 中全部的對象。

例如，下面的代碼將刪除 pub_date 是2005年的 Entry 對象：

Entry.objects.filter(pub_date__year=2005).delete()

要牢記這一點：不管在什麼狀況下，QuerySet 中的 delete() 方法都只使用一條 SQL 語句一次性刪除全部對象，而並非分別刪除每一個對象。若是你想使用在 model 中自定義的 delete() 方法，就要自行調用每一個對象的delete 方法。(例如，遍歷 QuerySet，在每一個對象上調用 delete()方法)，而不是使用 QuerySet 中的 delete()方法。

在 Django 刪除對象時，會模仿 SQL 約束 ON DELETE CASCADE 的行爲，換句話說，刪除一個對象時也會刪除與它相關聯的外鍵對象。例如：

b = Blog.objects.get(pk=1)
# This will delete the Blog and all of its Entry objects.
b.delete()

要注意的是： delete() 方法是 QuerySet 上的方法，但並不適用於 Manager 自己。這是一種保護機制，是爲了不意外地調用 Entry.objects.delete() 方法致使全部的記錄被誤刪除。若是你確認要刪除全部的對象，那麼你必須顯式地調用：

Entry.objects.all().delete()

Django-model進階

QuerySet

可切片

使用Python 的切片語法來限制查詢集記錄的數目。它等同於SQL 的LIMIT 和OFFSET 子句。

>>> Entry.objects.all()[:5]      # (LIMIT 5)

>>> Entry.objects.all()[5:10] # (OFFSET 5 LIMIT 5)

不支持負的索引（例如Entry.objects.all()[-1]）。一般，查詢集 的切片返回一個新的查詢集 —— 它不會執行查詢。

可迭代

articleList=models.Article.objects.all()

for article in articleList:
    print(article.title)

惰性查詢

查詢集 是惰性執行的 —— 建立查詢集不會帶來任何數據庫的訪問。你能夠將過濾器保持一成天，直到查詢集 須要求值時，Django 纔會真正運行這個查詢。

    queryResult=models.Article.objects.all() # not hits database

    print(queryResult) # hits database

    for article in queryResult:
        print(article.title)    # hits database

通常來講，只有在「請求」查詢集 的結果時纔會到數據庫中去獲取它們。當你確實須要結果時，查詢集 經過訪問數據庫來求值。關於求值發生的準確時間，參見什麼時候計算查詢集。

緩存機制

每一個查詢集都包含一個緩存來最小化對數據庫的訪問。理解它是如何工做的將讓你編寫最高效的代碼。

在一個新建立的查詢集中，緩存爲空。首次對查詢集進行求值 —— 同時發生數據庫查詢 ——Django 將保存查詢的結果到查詢集的緩存中並返回明確請求的結果（例如，若是正在迭代查詢集，則返回下一個結果）。接下來對該查詢集 的求值將重用緩存的結果。

請牢記這個緩存行爲，由於對查詢集使用不當的話，它會坑你的。例如，下面的語句建立兩個查詢集，對它們求值，而後扔掉它們：

print([a.title for a in models.Article.objects.all()])
print([a.create_time for a in models.Article.objects.all()])

這意味着相同的數據庫查詢將執行兩次，顯然倍增了你的數據庫負載。同時，還有可能兩個結果列表並不包含相同的數據庫記錄，由於在兩次請求期間有可能有Article被添加進來或刪除掉。爲了不這個問題，只需保存查詢集並從新使用它：

queryResult=models.Article.objects.all()
print([a.title for a in queryResult])
print([a.create_time for a in queryResult])

什麼時候查詢集不會被緩存?

查詢集不會永遠緩存它們的結果。當只對查詢集的部分進行求值時會檢查緩存，若是這個部分不在緩存中，那麼接下來查詢返回的記錄都將不會被緩存。因此，這意味着使用切片或索引來限制查詢集將不會填充緩存。

例如，重複獲取查詢集對象中一個特定的索引將每次都查詢數據庫：

>>> queryset = Entry.objects.all()
>>> print queryset[5] # Queries the database
>>> print queryset[5] # Queries the database again

然而，若是已經對所有查詢集求值過，則將檢查緩存：

>>> queryset = Entry.objects.all()
>>> [entry for entry in queryset] # Queries the database
>>> print queryset[5] # Uses cache
>>> print queryset[5] # Uses cache

下面是一些其它例子，它們會使得所有的查詢集被求值並填充到緩存中：

>>> [entry for entry in queryset]
>>> bool(queryset)
>>> entry in queryset
>>> list(queryset)

注：簡單地打印查詢集不會填充緩存。

queryResult=models.Article.objects.all()
print(queryResult) #  hits database
print(queryResult) #  hits database

exists()與iterator()方法

exists：

簡單的使用if語句進行判斷也會徹底執行整個queryset而且把數據放入cache，雖然你並不須要這些數據！爲了不這個，能夠用exists()方法來檢查是否有數據：

 if queryResult.exists():
    #SELECT (1) AS "a" FROM "blog_article" LIMIT 1; args=()
        print("exists...")

iterator:

當queryset很是巨大時，cache會成爲問題。

處理成千上萬的記錄時，將它們一次裝入內存是很浪費的。更糟糕的是，巨大的queryset可能會鎖住系統進程，讓你的程序瀕臨崩潰。要避免在遍歷數據的同時產生queryset cache，可使用iterator()方法來獲取數據，處理完數據就將其丟棄。

objs = Book.objects.all().iterator()
# iterator()能夠一次只從數據庫獲取少許數據，這樣能夠節省內存
for obj in objs:
    print(obj.title)
#BUT,再次遍歷沒有打印,由於迭代器已經在上一次遍歷(next)到最後一次了,沒得遍歷了
for obj in objs:
    print(obj.title)

固然，使用iterator()方法來防止生成cache，意味着遍歷同一個queryset時會重複執行查詢。因此使 #用iterator()的時候要小心，確保你的代碼在操做一個大的queryset時沒有重複執行查詢。

總結:

queryset的cache是用於減小程序對數據庫的查詢，在一般的使用下會保證只有在須要的時候纔會查詢數據庫。使用exists()和iterator()方法能夠優化程序對內存的使用。不過，因爲它們並不會生成queryset cache，可能會形成額外的數據庫查詢。　

中介模型

處理相似搭配 pizza 和 topping 這樣簡單的多對多關係時，使用標準的ManyToManyField 就能夠了。可是，有時你可能須要關聯數據到兩個模型之間的關係上。

例如，有這樣一個應用，它記錄音樂家所屬的音樂小組。咱們能夠用一個ManyToManyField 表示小組和成員之間的多對多關係。可是，有時你可能想知道更多成員關係的細節，好比成員是什麼時候加入小組的。

對於這些狀況，Django 容許你指定一箇中介模型來定義多對多關係。你能夠將其餘字段放在中介模型裏面。源模型的ManyToManyField 字段將使用through 參數指向中介模型。對於上面的音樂小組的例子，代碼以下：

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=128)

    def __str__(self):              # __unicode__ on Python 2
        return self.name

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, through='Membership')

    def __str__(self):              # __unicode__ on Python 2
        return self.name

class Membership(models.Model):
    person = models.ForeignKey(Person)
    group = models.ForeignKey(Group)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

既然你已經設置好ManyToManyField 來使用中介模型（在這個例子中就是Membership），接下來你要開始建立多對多關係。你要作的就是建立中介模型的實例：

>>> ringo = Person.objects.create(name="Ringo Starr")
>>> paul = Person.objects.create(name="Paul McCartney")
>>> beatles = Group.objects.create(name="The Beatles")
>>> m1 = Membership(person=ringo, group=beatles,
...     date_joined=date(1962, 8, 16),
...     invite_reason="Needed a new drummer.")
>>> m1.save()
>>> beatles.members.all()
[<Person: Ringo Starr>]
>>> ringo.group_set.all()
[<Group: The Beatles>]
>>> m2 = Membership.objects.create(person=paul, group=beatles,
...     date_joined=date(1960, 8, 1),
...     invite_reason="Wanted to form a band.")
>>> beatles.members.all()
[<Person: Ringo Starr>, <Person: Paul McCartney>]

與普通的多對多字段不一樣，你不能使用add、 create和賦值語句（好比，beatles.members = [...]）來建立關係：

# THIS WILL NOT WORK
>>> beatles.members.add(john)
# NEITHER WILL THIS
>>> beatles.members.create(name="George Harrison")
# AND NEITHER WILL THIS
>>> beatles.members = [john, paul, ringo, george]

爲何不能這樣作？這是由於你不能只建立 Person和 Group之間的關聯關係，你還要指定 Membership模型中所須要的全部信息；而簡單的add、create 和賦值語句是作不到這一點的。因此它們不能在使用中介模型的多對多關係中使用。此時，惟一的辦法就是建立中介模型的實例。

remove()方法被禁用也是出於一樣的緣由。可是clear() 方法倒是可用的。它能夠清空某個實例全部的多對多關係：

>>> # Beatles have broken up
>>> beatles.members.clear()
>>> # Note that this deletes the intermediate model instances
>>> Membership.objects.all()
[]

查詢優化

表數據

class UserInfo(AbstractUser):
    """
    用戶信息
    """
    nid = models.BigAutoField(primary_key=True)
    nickname = models.CharField(verbose_name='暱稱', max_length=32)
    telephone = models.CharField(max_length=11, blank=True, null=True, unique=True, verbose_name='手機號碼')
    avatar = models.FileField(verbose_name='頭像',upload_to = 'avatar/',default="/avatar/default.png")
    create_time = models.DateTimeField(verbose_name='建立時間', auto_now_add=True)

    fans = models.ManyToManyField(verbose_name='粉絲們',
                                  to='UserInfo',
                                  through='UserFans',
                                  related_name='f',
                                  through_fields=('user', 'follower'))

    def __str__(self):
        return self.username

class UserFans(models.Model):
    """
    互粉關係表
    """
    nid = models.AutoField(primary_key=True)
    user = models.ForeignKey(verbose_name='博主', to='UserInfo', to_field='nid', related_name='users')
    follower = models.ForeignKey(verbose_name='粉絲', to='UserInfo', to_field='nid', related_name='followers')

class Blog(models.Model):

    """
    博客信息
    """
    nid = models.BigAutoField(primary_key=True)
    title = models.CharField(verbose_name='我的博客標題', max_length=64)
    site = models.CharField(verbose_name='我的博客後綴', max_length=32, unique=True)
    theme = models.CharField(verbose_name='博客主題', max_length=32)
    user = models.OneToOneField(to='UserInfo', to_field='nid')
    def __str__(self):
        return self.title

class Category(models.Model):
    """
    博主我的文章分類表
    """
    nid = models.AutoField(primary_key=True)
    title = models.CharField(verbose_name='分類標題', max_length=32)

    blog = models.ForeignKey(verbose_name='所屬博客', to='Blog', to_field='nid')

class Article(models.Model):

    nid = models.BigAutoField(primary_key=True)
    title = models.CharField(max_length=50, verbose_name='文章標題')
    desc = models.CharField(max_length=255, verbose_name='文章描述')
    read_count = models.IntegerField(default=0)
    comment_count= models.IntegerField(default=0)
    up_count = models.IntegerField(default=0)
    down_count = models.IntegerField(default=0)
    category = models.ForeignKey(verbose_name='文章類型', to='Category', to_field='nid', null=True)
    create_time = models.DateField(verbose_name='建立時間')
    blog = models.ForeignKey(verbose_name='所屬博客', to='Blog', to_field='nid')
    tags = models.ManyToManyField(
        to="Tag",
        through='Article2Tag',
        through_fields=('article', 'tag'),
)


class ArticleDetail(models.Model):
    """
    文章詳細表
    """
    nid = models.AutoField(primary_key=True)
    content = models.TextField(verbose_name='文章內容', )

    article = models.OneToOneField(verbose_name='所屬文章', to='Article', to_field='nid')


class Comment(models.Model):
    """
    評論表
    """
    nid = models.BigAutoField(primary_key=True)
    article = models.ForeignKey(verbose_name='評論文章', to='Article', to_field='nid')
    content = models.CharField(verbose_name='評論內容', max_length=255)
    create_time = models.DateTimeField(verbose_name='建立時間', auto_now_add=True)

    parent_comment = models.ForeignKey('self', blank=True, null=True, verbose_name='父級評論')
    user = models.ForeignKey(verbose_name='評論者', to='UserInfo', to_field='nid')

    up_count = models.IntegerField(default=0)

    def __str__(self):
        return self.content

class ArticleUpDown(models.Model):
    """
    點贊表
    """
    nid = models.AutoField(primary_key=True)
    user = models.ForeignKey('UserInfo', null=True)
    article = models.ForeignKey("Article", null=True)
    models.BooleanField(verbose_name='是否贊')

class CommentUp(models.Model):
    """
    點贊表
    """
    nid = models.AutoField(primary_key=True)
    user = models.ForeignKey('UserInfo', null=True)
    comment = models.ForeignKey("Comment", null=True)


class Tag(models.Model):
    nid = models.AutoField(primary_key=True)
    title = models.CharField(verbose_name='標籤名稱', max_length=32)
    blog = models.ForeignKey(verbose_name='所屬博客', to='Blog', to_field='nid')



class Article2Tag(models.Model):
    nid = models.AutoField(primary_key=True)
    article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
    tag = models.ForeignKey(verbose_name='標籤', to="Tag", to_field='nid')

select_related

簡單使用

對於一對一字段（OneToOneField）和外鍵字段（ForeignKey），可使用select_related 來對QuerySet進行優化。

select_related 返回一個QuerySet，當執行它的查詢時它沿着外鍵關係查詢關聯的對象的數據。它會生成一個複雜的查詢並引發性能的損耗，可是在之後使用外鍵關係時將不須要數據庫查詢。

簡單說，在對QuerySet使用select_related()函數後，Django會獲取相應外鍵對應的對象，從而在以後須要的時候沒必要再查詢數據庫了。

下面的例子解釋了普通查詢和select_related() 查詢的區別。

查詢id=2的文章的分類名稱,下面是一個標準的查詢：

    # Hits the database.
    article=models.Article.objects.get(nid=2)

    # Hits the database again to get the related Blog object.
    print(article.category.title)

'''

SELECT 
    "blog_article"."nid", 
    "blog_article"."title", 
    "blog_article"."desc", 
    "blog_article"."read_count", 
    "blog_article"."comment_count", 
    "blog_article"."up_count", 
    "blog_article"."down_count", 
    "blog_article"."category_id", 
    "blog_article"."create_time",
     "blog_article"."blog_id", 
     "blog_article"."article_type_id" 
             FROM "blog_article" 
             WHERE "blog_article"."nid" = 2; args=(2,)

SELECT
     "blog_category"."nid", 
     "blog_category"."title", 
     "blog_category"."blog_id"
              FROM "blog_category" 
              WHERE "blog_category"."nid" = 4; args=(4,)


'''

若是咱們使用select_related()函數：

articleList=models.Article.objects.select_related("category").all()


    for article_obj in articleList:
        #  Doesn't hit the database, because article_obj.category
        #  has been prepopulated in the previous query.
        print(article_obj.category.title)

SELECT 
	 "blog_article"."nid", 
	 "blog_article"."title", 
	 "blog_article"."desc",
	 "blog_article"."read_count", 
	 "blog_article"."comment_count", 
	 "blog_article"."up_count", 
	 "blog_article"."down_count",
	 "blog_article"."category_id", 
	 "blog_article"."create_time", 
	 "blog_article"."blog_id", 
	 "blog_article"."article_type_id", 

	 "blog_category"."nid", 
	 "blog_category"."title", 
	 "blog_category"."blog_id" 

FROM "blog_article" 
LEFT OUTER JOIN "blog_category" ON ("blog_article"."category_id" = "blog_category"."nid");

多外鍵查詢

這是針對category的外鍵查詢，若是是另一個外鍵呢？讓咱們一塊兒看下：

article=models.Article.objects.select_related("category").get(nid=1)
print(article.articledetail)

觀察logging結果，發現依然須要查詢兩次，因此須要改成：

article=models.Article.objects.select_related("category","articledetail").get(nid=1)
print(article.articledetail)

或者：

article=models.Article.objects
　　　　　　　　　　　　　.select_related("category")
　　　　　　　　　　　　　.select_related("articledetail")
　　　　　　　　　　　　　.get(nid=1)  # django 1.7 支持鏈式操做
print(article.articledetail)

 SELECT 

	 "blog_article"."nid", 
	 "blog_article"."title", 
	 ......

	 "blog_category"."nid", 
	 "blog_category"."title",
	 "blog_category"."blog_id", 

	 "blog_articledetail"."nid",
	 "blog_articledetail"."content",
	 "blog_articledetail"."article_id" 

    FROM "blog_article" 
    LEFT OUTER JOIN "blog_category" ON ("blog_article"."category_id" = "blog_category"."nid")
    LEFT OUTER JOIN "blog_articledetail" ON ("blog_article"."nid" = "blog_articledetail"."article_id") 
    WHERE "blog_article"."nid" = 1; args=(1,)

深層查詢

# 查詢id=1的文章的用戶姓名

    article=models.Article.objects.select_related("blog").get(nid=1)
    print(article.blog.user.username)

依然須要查詢兩次：

SELECT 
	"blog_article"."nid", 
	"blog_article"."title", 
	......

	 "blog_blog"."nid", 
	 "blog_blog"."title", 

   FROM "blog_article" INNER JOIN "blog_blog" ON ("blog_article"."blog_id" = "blog_blog"."nid") 
   WHERE "blog_article"."nid" = 1; 




SELECT 
	"blog_userinfo"."password", 
	"blog_userinfo"."last_login",
	......

FROM "blog_userinfo" 
WHERE "blog_userinfo"."nid" = 1;

這是由於第一次查詢沒有query到userInfo表，因此，修改以下：

article=models.Article.objects.select_related("blog__user").get(nid=1)
print(article.blog.user.username)

SELECT 

"blog_article"."nid", "blog_article"."title",
......

 "blog_blog"."nid", "blog_blog"."title", 
......

 "blog_userinfo"."password", "blog_userinfo"."last_login",
......

FROM "blog_article"

INNER JOIN "blog_blog" ON ("blog_article"."blog_id" = "blog_blog"."nid") 

INNER JOIN "blog_userinfo" ON ("blog_blog"."user_id" = "blog_userinfo"."nid") 
WHERE "blog_article"."nid" = 1;

總結

select_related主要針一對一和多對一關係進行優化。
select_related使用SQL的JOIN語句進行優化，經過減小SQL查詢的次數來進行優化、提升性能。
能夠經過可變長參數指定須要select_related的字段名。也能夠經過使用雙下劃線「__」鏈接字段名來實現指定的遞歸查詢。
沒有指定的字段不會緩存，沒有指定的深度不會緩存，若是要訪問的話Django會再次進行SQL查詢。
也能夠經過depth參數指定遞歸的深度，Django會自動緩存指定深度內全部的字段。若是要訪問指定深度外的字段，Django會再次進行SQL查詢。
也接受無參數的調用，Django會盡量深的遞歸查詢全部的字段。但注意有Django遞歸的限制和性能的浪費。
Django >= 1.7，鏈式調用的select_related至關於使用可變長參數。Django < 1.7，鏈式調用會致使前邊的select_related失效，只保留最後一個。

prefetch_related()

對於多對多字段（ManyToManyField）和一對多字段，可使用prefetch_related()來進行優化。

prefetch_related()和select_related()的設計目的很類似，都是爲了減小SQL查詢的數量，可是實現的方式不同。後者是經過JOIN語句，在SQL查詢內解決問題。可是對於多對多關係，使用SQL語句解決就顯得有些不太明智，由於JOIN獲得的表將會很長，會致使SQL語句運行時間的增長和內存佔用的增長。如有n個對象，每一個對象的多對多字段對應Mi條，就會生成Σ(n)Mi 行的結果表。

prefetch_related()的解決方法是，分別查詢每一個表，而後用Python處理他們之間的關係。

# 查詢全部文章關聯的全部標籤
    article_obj=models.Article.objects.all()
    for i in article_obj:

        print(i.tags.all())  #4篇文章: hits database 5

改成prefetch_related：

# 查詢全部文章關聯的全部標籤
    article_obj=models.Article.objects.prefetch_related("tags").all()
    for i in article_obj:

        print(i.tags.all())  #4篇文章: hits database 2

SELECT "blog_article"."nid",
               "blog_article"."title", 
               ......

FROM "blog_article";



SELECT
  ("blog_article2tag"."article_id") AS "_prefetch_related_val_article_id", 
  "blog_tag"."nid", 
  "blog_tag"."title",
  "blog_tag"."blog_id"
   FROM "blog_tag"
  INNER JOIN "blog_article2tag" ON ("blog_tag"."nid" = "blog_article2tag"."tag_id") 
  WHERE "blog_article2tag"."article_id" IN (1, 2, 3, 4);

extra

extra(select=None, where=None, params=None, 
      tables=None, order_by=None, select_params=None)

有些狀況下，Django的查詢語法難以簡單的表達複雜的 WHERE 子句，對於這種狀況, Django 提供了 extra() QuerySet修改機制 — 它能在 QuerySet生成的SQL從句中注入新子句

extra能夠指定一個或多個 參數,例如 select, where or tables. 這些參數都不是必須的，可是你至少要使用一個!要注意這些額外的方式對不一樣的數據庫引擎可能存在移植性問題.(由於你在顯式的書寫SQL語句),除非萬不得已,儘可能避免這樣作

參數之select

The select 參數可讓你在 SELECT 從句中添加其餘字段信息，它應該是一個字典，存放着屬性名到 SQL 從句的映射。

queryResult=models.Article
　　　　　　　　　　　.objects.extra(select={'is_recent': "create_time > '2017-09-05'"})

結果集中每一個 Entry 對象都有一個額外的屬性is_recent, 它是一個布爾值，表示 Article對象的create_time 是否晚於2017-09-05.

練習：

# in sqlite:
    article_obj=models.Article.objects
　　　　　　　　　　　　　　.filter(nid=1)
　　　　　　　　　　　　　　.extra(select={"standard_time":"strftime('%%Y-%%m-%%d',create_time)"})
　　　　　　　　　　　　　　.values("standard_time","nid","title")
    print(article_obj)
    # <QuerySet [{'title': 'MongoDb 入門教程', 'standard_time': '2017-09-03', 'nid': 1}]>

參數之`where` / `tables`

您可使用where定義顯式SQL WHERE子句 - 也許執行非顯式鏈接。您可使用tables手動將表添加到SQL FROM子句。

where和tables都接受字符串列表。全部where參數均爲「與」任何其餘搜索條件。

舉例來說：

queryResult=models.Article
　　　　　　　　　　　.objects.extra(where=['nid in (1,3) OR title like "py%" ','nid>2'])

總體插入

建立對象時，儘量使用bulk_create()來減小SQL查詢的數量。例如：

Entry.objects.bulk_create([
    Entry(headline="Python 3.0 Released"),
    Entry(headline="Python 3.1 Planned")
])

...更優於：

Entry.objects.create(headline="Python 3.0 Released")
Entry.objects.create(headline="Python 3.1 Planned")

注意該方法有不少注意事項，因此確保它適用於你的狀況。

這也能夠用在ManyToManyFields中，因此：

my_band.members.add(me, my_friend)

...更優於：

my_band.members.add(me)
my_band.members.add(my_friend)

...其中Bands和Artists具備多對多關聯。

博客轉自：http://www.cnblogs.com/yuanchenqi/articles/7629939.html

相關標籤/搜索

每日一句

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

Django框架_URLconf、Views、template、ORM

目錄:

1、Django-MTV

2、Django-model基礎

3、Django-model進階

MTV模型

Django基本命令

一、下載Django：

二、建立一個django project

三、在mysite目錄下建立應用

四、啓動django項目

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

六、清空數據庫

七、建立超級管理員

八、Django 項目環境終端

九、Django 項目環境終端

十、更多命令

11 靜態文件配置

視圖層之路由配置系統(views)

2.1 URLconf的正則字符串參數

2.1.1 簡單配置

2.1.2 有名分組(named group)

2.1.3 URLconf 在什麼上查找

2.1.4 捕獲的參數永遠是字符串

2.1.5 指定視圖參數的默認值

2.1.6 Including other URLconfs

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

2.3 URL 的反向解析

2.4 命名URL 模式

2.5 CBV

d視圖層之視圖函數(views)

一個簡單的視圖

HttpRequest對象

render 函數

redirect 函數

傳遞一個對象

傳遞一個視圖的名稱

傳遞要重定向的一個硬編碼的URL

跳轉（重定向）應用

模板層(template)

模板語法之變量

模板之過濾器

default

length

filesizeformat

date

slice

truncatechars

safe

模板之標籤

for標籤

for ... empty

if 標籤

with

csrf_token

自定義標籤和過濾器

模板繼承 (extend)

Django-model基礎

ORM

建立表(創建模型)

字段選項

添加表記錄

普通字段

外鍵字段

多對多字段

class RelatedManager

查詢表記錄

查詢相關API

雙下劃線之單表查詢

基於對象的跨表查詢

一對多查詢（Publish 與 Book）

一對一查詢(Author 與 AuthorDetail)

多對多查詢 (Author 與 Book)

基於雙下劃線的跨表查詢

聚合查詢與分組查詢

聚合：aggregate(*args, **kwargs)

分組：annotate()

F查詢與Q查詢

F查詢

Q查詢

`default`

`filesizeformat`

模板之標籤　

`聚合：aggregate`(*args, **kwargs)

分組：annotate()　

參數之`where` / `tables`