Django搭建簡易博客教程(01)-Django簡介

時間 2019-11-16

原文原文鏈接

寫做目的

喜歡一個學習觀點以教促學, 一直以來, 學習的時候常常會發現, 某個方法某個問題本身已經明白了, 可是在教給別人的時候確說不清楚, 因此慢慢的學會了以教促學這種方法, 在教給別人知識的同時也可以提高本身對語言, 對框架的理解.php

但願達到的目標：html

但願能寫出一個系列文章, 我也不知道到底能寫多少
可以讓認真閱讀這個系列的文章的人, 能在讀完以後作出一個簡單的博客
但願可以加深本身對Django的理解

Django簡介

Django是Python中目前風靡的Web Framework, 那麼什麼叫作Framework呢, 框架可以幫助你把程序的總體架構搭建好, 而咱們所須要作的工做就是填寫邏輯, 而框架可以在合適的時候調用你寫的邏輯, 而不須要咱們本身去調用邏輯, 讓Web開發變的更敏捷.python

Django是一個高級Python Web框架, 鼓勵快速,簡潔, 以程序設計的思想進行開發. 經過使用這個框架, 能夠減小不少開發麻煩, 使你更專一於編寫本身的app, 而不須要重複造輪子. Django免費而且開源.mysql

Django特色:

徹底免費並開源源代碼
快速高效開發
使用MTV架構(熟悉Web開發的應該會說是MVC架構)
強大的可擴展性.

Django的工做方式:

用戶在瀏覽器中輸入URL後的回車, 瀏覽器會對URL進行檢查, 首先判斷協議,若是是http就按照 Web 來處理, 然互調用DNS查詢, 將域名轉換爲IP地址, 而後通過網絡傳輸到達對應Web服務器, 服務器對url進行解析後, 調用View中的邏輯(MTV中的V), 其中又涉及到Model(MTV中的M), 與數據庫的進行交互, 將數據發到Template(MTV中的T)進行渲染, 而後發送到瀏覽器中, 瀏覽器以合適的方式呈現給用戶nginx

但願到這裏你能夠大致的瞭解Django 的工做方式，若是還不太明白也沒有關係，到後面咱們會詳細的瞭解的，截止到我這這篇教程，市場上用python 2.X 和 python 3.X 的在人數方面大致持平了，因此，當你看到這個地方的時候還可能有一個小困惑，那就是：我到底應該學習什麼版本的python呢？！圖樣圖森破。。。記住答案是 python3 。聽哥的沒錯!!git

可是學習 Django ，這對於任務時間剛開始學習的人，都有一個必須搞清楚的問題。根據官網信息：程序員

根據官網信息：（2018-03-05）web

Django 版本	python 信息
1.8	2.7, 3.2 (until the end of 2016), 3.3, 3.4, 3.5
1.9 1.10	2.7, 3.4, 3.5
1.11	2.7, 3.4, 3.5, 3.6
2.0	3.4, 3.5, 3.6
2.1	3.5, 3.6, 3.7

重點是2017年末發佈的2.0版將再也不支持Python2!

因此，若是你的工做環境不強制指定版本，那麼不管是從Python學習仍是Django學習而言，Python3都是你最好的選擇！

Django makes it easier to build better Web apps more quickly and with less code.正則表達式
Django 讓你以更快的速度、更少的代碼、更輕鬆的方式搭建更好的 Web 應用。sql

本教程將帶你使用 Django 快速開發屬於本身的博客網站。

Django的流程和命令行工具（正式內容下節開始）

Django的實現流程：

安裝Django

命令：pip install django
添加環境變量；

建立project(項目名字：mysite)

命令：django-admin startproject mysite

建立APP(app名字：app01)

python manage.py startapp app01

setting配置：

在 INSTALLED_APPS 中註冊app01；

編寫邏輯與路由 url.py ;view.py
使用模板

render(req,"index.html")

啓動項目

命令：python manage.py runserver

以上爲最最基本的操做，因此，沒有涉及model.py數據庫的操做。

Django的命令行工具

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

<1> 建立一個django工程 :

django-admin.py startproject mysite

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

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

在mysite目錄下建立blog應用:

python manage.py startapp blog

<3>啓動django項目：

python manage.py runserver 8080

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

<4>同步數據庫

python manage.py makemigrations  # 生成同步數據庫的腳本

python manage.py migrate  # 同步數據庫

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

　這個時候當咱們訪問http://127.0.0.1:8080/admin/　時，會出現：

<５>建立超級用戶

執行命令：

python manage.py createsuperuser

python manage.py changepassword username  #　修改用戶名密碼

設置好用戶名密碼就可使用後臺了。

<6>清空數據庫：

python manage.py flush

<7>啓動交互界面：

python manage.py shell

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

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

:fa-gears: Django的配置文件(settings)

:fa-map-marker: 靜態文件交由web服務器處理，Django自己不處理靜態文件。簡單的處理邏輯以下：（以nginx爲例）

若是是靜態文件，則由nginx直接處理；
若是不是，則交由Django處理，Django根據urls.py裏面的規則進行匹配；

以上是部署到web服務器後的處理方式。

爲了便於開發，Django提供了在開發環境中對靜態文件的處理機制，方法是這樣：

在INSTALLED_APPS裏面加入django.contrib.staticfiles,
在urls.py裏面加入：

if settings.DEBUG:  
           urlpatterns += patterns('', url(r'^media/(?P<path>.*)$', 
           'django.views.static.serve', {'document_root': settings.MEDIA_ROOT }),   
            url(r'^static/(?P<path>.*)$',
          'django.views.static.serve',{'document_root':settings.STATIC_ROOT}), )

這樣就能夠直接在開發階段直接使用靜態文件了。

Django URL (路由系統)

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

其形式爲：

urlpatterns = [
    url(正則表達式, views視圖函數，參數，別名),     # 注意是中括號
]

參數說明：

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

Here’s a sample URLconf:

from django.conf.urls import url
from django.contrib import admin

from app01 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})/$', views.year_archive),  #no_named group

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

]

升級版----命名分組：

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),
]

再升級版----Including other URLconfs

from django.conf.urls import include, url

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

再再升級版----name param（設置別名）

urlpatterns = [
    url(r'^index', include('blog.urls'), name='bieming'),
]


#####################
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
     <form action="{% url 'bieming' %}" method="post">
         用戶名:<input type="text" name="username">
         密碼:<input type="password" name="password">
         <input type="submit" value="submit">
     </form>
</body>
</html>
#######################

Django Views（視圖函數）

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

http請求：HttpRequest對象
http響應：HttpResponse對象

所在位置：django.http

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

HttpRequest對象的屬性和方法：

path：請求頁面的全路徑，不包括域名
method：請求中使用的HTTP方法的字符串表示。全大寫表示。例如

if req.method == "GET":
    do_something()
elif req.method=="POST":
    do_something_else()

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

服務器收到空的POST請求的狀況也是可能發生的，也就是說，表單form經過HTTP POST方法提交請求，可是表單中可能沒有數據，所以不能使用if req.POST來判斷是否使用了HTTP POST 方法；應該使用 if req.method=="POST"
COOKIES: 包含全部cookies的標準Python字典對象；keys和values都是字符串。
FILES：包含全部上傳文件的類字典對象；FILES中的每個Key都是<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支持時該屬性纔可用。
注意一個經常使用方法：request.POST.getlist('')

HttpResponse對象：

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

HttpResponse類在django.http.HttpResponse

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

頁面渲染： render()（推薦） render_to_response(),
頁面跳轉： redirect("路徑")
locals()：能夠直接將函數中全部的變量傳給模板

Template基礎

模板系統的介紹

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

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now  # 這種寫法low 爆了
    return HttpResponse(html)

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

對頁面設計進行的任何改變都必須對 Python 代碼進行相應的修改。站點設計的修改每每比底層 Python 代碼的修改要頻繁得多，所以若是能夠在不進行 Python 代碼修改的狀況下變動設計，那將會方便得多。
Python 代碼編寫和 HTML 設計是兩項不一樣的工做，大多數專業的網站開發環境都將他們分配給不一樣的人員（甚至不一樣部門）來完成。設計者和HTML/CSS的編碼人員不該該被要求去編輯Python的代碼來完成他們的工做。
程序員編寫 Python代碼和設計人員製做模板兩項工做同時進行的效率是最高的，遠勝於讓一我的等待另外一我的完成對某個既包含 Python又包含 HTML 的文件的編輯工做。

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

: 模板語法

1. 模版的組成：

組成：HTML代碼＋邏輯控制代碼

2. 邏輯控制代碼的組成

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

{{var_name}}    # 語法格式

2.1.1 Template和Context對象

>>> python manange.py shell  (進入該django項目的環境)
>>> from django.template import Context, Template
>>> t = Template('My name is {{ name }}.')
>>> c = Context({'name': 'Stephane'})
>>> t.render(c)
'My name is Stephane.'


# 同一模板，多個上下文，一旦有了模板對象，你就能夠經過它渲染多個context，不管什麼時候咱們均可以
# 像這樣使用同一模板源渲染多個context，只進行 一次模板建立而後屢次調用render()方法渲染會
# 更爲高效：
# Low
for name in ('John', 'Julie', 'Pat'):
    t = Template('Hello, {{ name }}')
    print t.render(Context({'name': name}))

# Good
t = Template('Hello, {{ name }}')
for name in ('John', 'Julie', 'Pat'):
    print t.render(Context({'name': name}))

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

from django.shortcuts import render,HttpResponse
from django.template.loader import get_template #記得導入
# Create your views here.


import datetime
from django.template import Template,Context

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



# def current_time(req):

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

#另外一種寫法(推薦)

def current_time(req):

    now=datetime.datetime.now()

    return render(req, 'current_datetime.html', {'current_date':now})

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

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

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

#最好是用幾個例子來講明一下。
# 首先，句點可用於訪問列表索引，例如：

>>> from django.template import Template, Context
>>> t = Template('Item 2 is {{ items.2 }}.')
>>> c = Context({'items': ['apples', 'bananas', 'carrots']})
>>> t.render(c)
'Item 2 is carrots.'

#假設你要向模板傳遞一個 Python 字典。 要經過字典鍵訪問該字典的值，可以使用一個句點：
>>> from django.template import Template, Context
>>> person = {'name': 'Sally', 'age': '43'}
>>> t = Template('{{ person.name }} is {{ person.age }} years old.')
>>> c = Context({'person': person})
>>> t.render(c)
'Sally is 43 years old.'

#一樣，也能夠經過句點來訪問對象的屬性。 比方說， Python 的 datetime.date 對象有
#year 、 month 和 day 幾個屬性，你一樣能夠在模板中使用句點來訪問這些屬性：

>>> from django.template import Template, Context
>>> import datetime
>>> d = datetime.date(1993, 5, 2)
>>> d.year
>>> d.month
>>> d.day
>>> t = Template('The month is {{ date.month }} and the year is {{ date.year }}.')
>>> c = Context({'date': d})
>>> t.render(c)
'The month is 5 and the year is 1993.'

# 這個例子使用了一個自定義的類，演示了經過實例變量加一點(dots)來訪問它的屬性，這個方法適
# 用於任意的對象。
>>> from django.template import Template, Context
>>> class Person(object):
...     def __init__(self, first_name, last_name):
...         self.first_name, self.last_name = first_name, last_name
>>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.')
>>> c = Context({'person': Person('John', 'Smith')})
>>> t.render(c)
'Hello, John Smith.'

# 點語法也能夠用來引用對象的方法。 例如，每一個 Python 字符串都有 upper() 和 isdigit()
# 方法，你在模板中可使用一樣的句點語法來調用它們：
>>> from django.template import Template, Context
>>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}')
>>> t.render(Context({'var': 'hello'}))
'hello -- HELLO -- False'
>>> t.render(Context({'var': '123'}))
'123 -- 123 -- True'

# 注意這裏調用方法時並* 沒有* 使用圓括號 並且也沒法給該方法傳遞參數；你只能調用不需參數的方法。

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

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

# 1  add          ：   給變量加上相應的值
#
# 2  addslashes   :    給變量中的引號前加上斜線
#
# 3  capfirst     :    首字母大寫
#
# 4  cut          ：   從字符串中移除指定的字符
#
# 5  date         ：   格式化日期字符串
#
# 6  default      ：   若是值是False,就替換成設置的默認值，不然就是用原本的值
#
# 7  default_if_none:  若是值是None，就替換成設置的默認值，不然就使用原本的值


#實例:

#value1="aBcDe"
{{ value1|upper }}

#value2=5
{{ value2|add:3 }}<br>

#value3='he  llo wo r ld'
{{ value3|cut:' ' }}<br>

#import datetime
#value4=datetime.datetime.now()
{{ value4|date:'Y-m-d' }}<br>

#value5=[]
{{ value5|default:'空的' }}<br>

#value6='<a href="#">跳轉</a>'

{{ value6 }}

{% autoescape off %}
  {{ value6 }}
{% endautoescape %}

{{ value6|safe }}<br>

{{ value6|striptags }}

#value7='1234'
{{ value7|filesizeformat }}<br>
{{ value7|first }}<br>
{{ value7|length }}<br>
{{ value7|slice:":-1" }}<br>

#value8='http://www.baidu.com/?a=1&b=3'
{{ value8|urlencode }}<br>
value9='hello I am lowenve'

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

{% tags %}

2.2.1 {% if %} 的使用

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

{% if num >= 100 and 8 %}

    {% if num > 200 %}
        <p>num大於200</p>
    {% else %}
        <p>num大於100小於200</p>
    {% endif %}

{% elif num < 100%}
    <p>num小於100</p>

{% else %}
    <p>num等於100</p>

{% endif %}


{% if %} 標籤接受and，or或者not來測試多個變量值或者否認一個給定的變量
{% if %} 標籤不容許同一標籤裏同時出現and和or，不然邏輯容易產生歧義，例以下面的標籤是不合法的：

{% if obj1 and obj2 or obj3 %}

2.2.2 {% for %}的使用

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

<ul>
{% for obj in list %}
    <li>{{ obj.name }}</li>
{% endfor %}
</ul>


#在標籤裏添加reversed來反序循環列表：

    {% for obj in list reversed %}
    ...
    {% endfor %}

#{% for %}標籤能夠嵌套：

    {% for country in countries %}
        <h1>{{ country.name }}</h1>
        <ul>
         {% for city in country.city_list %}
            <li>{{ city }}</li>
         {% endfor %}
        </ul>
    {% endfor %}


#系統不支持中斷循環，系統也不支持continue語句，{% for %}標籤內置了一個forloop模板變量，
#這個變量含有一些屬性能夠提供給你一些關於循環的信息

1，forloop.counter表示循環的次數，它從1開始計數，第一次循環設爲1:

    {% for item in todo_list %}
        <p>{{ forloop.counter }}: {{ item }}</p>
    {% endfor %}
2，forloop.counter0 相似於forloop.counter，但它是從0開始計數，第一次循環設爲0
3，forloop.revcounter
4，forloop.revcounter0
5，forloop.first當第一次循環時值爲True，在特別狀況下頗有用：

    
    {% for object in objects %}   
         {% if forloop.first %}<li class="first">{% else %}<li>{% endif %}   
         {{ object }}   
        </li>  
    {% endfor %}  
    
# 富有魔力的forloop變量只能在循環中獲得，當模板解析器到達{% endfor %}時forloop就消失了
# 若是你的模板context已經包含一個叫forloop的變量，Django會用{% for %}標籤替代它
# Django會在for標籤的塊中覆蓋你定義的forloop變量的值
# 在其餘非循環的地方，你的forloop變量仍然可用


#{% empty %}

{{li }}
      {%  for i in li %}
          <li>{{ forloop.counter0 }}----{{ i }}</li>
      {% empty %}
          <li>this is empty!</li>
      {% endfor %}

#         [11, 22, 33, 44, 55]
#            0----11
#            1----22
#            2----33
#            3----44
#            4----55

2.2.3 {%csrf_token%}：csrf_token標籤

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

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

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

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

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

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

2.2.6 {% verbatim %}: 禁止render

{% verbatim %}
    {{ hello }}
{% endverbatim %}

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

2.3 自定義filter和simple_tag

a、在app中建立templatetags模塊(必須的)
b、建立任意 .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)

c、在使用自定義simple_tag和filter的html文件中導入以前建立的 my_tags.py ：{% load my_tags %}
d、使用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 %}

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

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

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

2.4 extend模板繼承

2.4.1 include 模板標籤

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

2.4.2 extend(繼承)模板標籤

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

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

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

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

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
<html lang="en">
<head>
    <title>The current time</title>
</head>
<body>
    <h1>My helpful timestamp site</h1>
    <p>It is now {{ current_date }}.</p>
 
    <hr>
    <p>Thanks for visiting my site.</p>
</body>
</html>

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

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
<html lang="en">
<head>
    <title>Future time</title>
</head>
<body>
    <h1>My helpful timestamp site</h1>
    <p>In {{ hour_offset }} hour(s), it will be {{ next_time }}.</p>
 
    <hr>
    <p>Thanks for visiting my site.</p>
</body>
</html>

很明顯，咱們剛纔重複了大量的 HTML 代碼。想象一下，若是有一個更典型的網站，它有導航條、樣式表，可能還有一些 JavaScript 代碼，事情必將以向每一個模板填充各類冗餘的 HTML 而了結。

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

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

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

<hr>
    <p>Thanks for visiting my site.</p>
</body>
</html>

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

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

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

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
<html lang="en">
<head>
    <title>{% block title %}{% endblock %}</title>
</head>
<body>
    <h1>My helpful timestamp site</h1>
    {% block content %}{% endblock %}
    {% block footer %}
    <hr>
    <p>Thanks for visiting my site.</p>
    {% endblock %}
</body>
</html>

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

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

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

{% extends "base.html" %}
 
{% block title %}The current time{% endblock %}
 
{% block content %}
<p>It is now {{ current_date }}.</p>
{% endblock %}

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

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

看起來很漂亮是否是？每一個模板只包含對本身而言獨一無二的代碼。無需多餘的部分。若是想進行站點級的設計修改，僅需修改 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> 爲每種類型的頁面建立獨立的模板，例如論壇頁面或者圖片庫。這些模板拓展相應的區域模板。

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

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

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

:fa-institution: Models

:tw-1f338:數據庫的配置

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

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

2. mysql驅動程序

MySQLdb(mysql python)
mysqlclient
MySQL
PyMySQL(純python的mysql驅動程序)

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

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

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql', 

        'NAME': 'books',    #你的數據庫名稱

        'USER': 'root',   #你的數據庫用戶名

        'PASSWORD': '', #你的數據庫密碼

        'HOST': '', #你的數據庫主機，留空默認爲localhost

        'PORT': '3306', #你的數據庫端口

    }

}

注意：

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(對象關係映射)

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

優勢：

ORM使得咱們的通用數據庫交互變得簡單易行，並且徹底不用考慮該死的SQL語句。快速開發，由此而來。
能夠避免一些新手程序猿寫sql語句帶來的性能問題。

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

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

缺點：

性能有所犧牲，不過如今的各類ORM框架都在嘗試各類方法，好比緩存，延遲加載登來減輕這個問題。效果很顯著。
對於個別複雜查詢，ORM仍然力不從心，爲了解決這個問題，ORM通常也支持寫raw sql。
經過QuerySet的query屬性查詢對應操做的sql語句

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

下面要開始學習Django ORM語法了，爲了更好的理解，咱們來作一個基本的書籍/做者/出版商數據庫結構。咱們這樣作是由於這是一個衆所周知的例子，不少SQL有關的書籍也經常使用這個舉例。

:tw-1f351: 表(模型)的建立：

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

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

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

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

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

from django.db import models<br>
class Publisher(models.Model):
    name = models.CharField(max_length=30, verbose_name="名稱")
    address = models.CharField("地址", max_length=50)
    city = models.CharField('城市',max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()
 
    class Meta:
        verbose_name = '出版商'
        verbose_name_plural = verbose_name
 
    def __str__(self):
        return self.name
 
class Author(models.Model):
    name = models.CharField(max_length=30)
    def __str__(self):
        return self.name
 
class AuthorDetail(models.Model):
    sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))
    email = models.EmailField()
    address = models.CharField(max_length=50)
    birthday = models.DateField()
    author = models.OneToOneField(Author)
 
class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
    def __str__(self):
        return self.title

注意1：記得在settings裏的INSTALLED_APPS中加入'app01',而後再同步數據庫。
注意2: models.ForeignKey("Publish") & models.ForeignKey(Publish)

:tw-1f34e: 分析代碼：

每一個數據模型都是django.db.models.Model的子類，它的父類Model包含了全部必要的和數據庫交互的方法。並提供了一個簡介漂亮的定義數據庫字段的語法。
每一個模型至關於單個數據庫表（多對多關係例外，會多生成一張關係表），每一個屬性也是這個表中的字段。屬性名就是字段名，它的類型（例如CharField）至關於數據庫的字段類型（例如varchar）。你們能夠留意下其它的類型都和數據庫裏的什麼字段對應。
模型之間的三種關係：一對一，一對多，多對多。
一對一：實質就是在主外鍵（author_id就是foreign key）的關係基礎上，給外鍵加了一個UNIQUE＝True的屬性；
一對多：就是主外鍵關係；（foreign key）
多對多：(ManyToManyField) 自動建立第三張表(固然咱們也能夠本身建立第三張表：兩個foreign key)

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

<1> CharField
    #字符串字段, 用於較短的字符串.
    #CharField 要求必須有一個參數 maxlength, 用於從數據庫層和Django校驗層限制該字段所容許的最大字符數.

<2> IntegerField
    #用於保存一個整數.

<3> FloatField
    # 一個浮點數. 必須 提供兩個參數:
    #
    # 參數    描述
    # max_digits    總位數(不包括小數點和符號)
    # decimal_places    小數位數
        # 舉例來講, 要保存最大值爲 999 (小數點後保存2位),你要這樣定義字段:
        #
        # models.FloatField(..., max_digits=5, decimal_places=2)
        # 要保存最大值一百萬(小數點後保存10位)的話,你要這樣定義:
        #
        # models.FloatField(..., max_digits=19, decimal_places=10)
        # admin 用一個文本框(<input type="text">)表示該字段保存的數據.

<4> AutoField
    # 一個 IntegerField, 添加記錄時它會自動增加. 你一般不須要直接使用這個字段; 
    # 自定義一個主鍵：my_id=models.AutoField(primary_key=True)
    # 若是你不指定主鍵的話,系統會自動添加一個主鍵字段到你的 model.

<5> BooleanField
    # A true/false field. admin 用 checkbox 來表示此類字段.

<6> TextField
    # 一個容量很大的文本字段.
    # admin 用一個 <textarea> (文本區域)表示該字段數據.(一個多行編輯框).

<7> EmailField
    # 一個帶有檢查Email合法性的 CharField,不接受 maxlength 參數.

<8> DateField
    # 一個日期字段. 共有下列額外的可選參數:
    # Argument    描述
    # auto_now    當對象被保存時,自動將該字段的值設置爲當前時間.一般用於表示 "last-modified" 時間戳.
    # auto_now_add    當對象首次被建立時,自動將該字段的值設置爲當前時間.一般用於表示對象建立時間.
    #（僅僅在admin中有意義...)

<9> DateTimeField
    #  一個日期時間字段. 相似 DateField 支持一樣的附加選項.

<10> ImageField
    # 相似 FileField, 不過要校驗上傳對象是不是一個合法圖片.#它有兩個可選參數:height_field和width_field,
    # 若是提供這兩個參數,則圖片將按提供的高度和寬度規格保存.     
<11> FileField
    # 一個文件上傳字段.
     #要求一個必須有的參數: upload_to, 一個用於保存上載文件的本地文件系統路徑. 這個路徑必須包含 strftime #formatting, 
    #該格式將被上載文件的 date/time 
    #替換(so that uploaded files don't fill up the given directory).
    # admin 用一個<input type="file">部件表示該字段保存的數據(一個文件上傳部件) .

    #注意：在一個 model 中使用 FileField 或 ImageField 須要如下步驟:
    #（1）在你的 settings 文件中, 定義一個完整路徑給 MEDIA_ROOT 以便讓 Django在此處保存上傳文件.
    # (出於性能考慮,這些文件並不保存到數據庫.) 定義MEDIA_URL 做爲該目錄的公共 URL. 要確保該目錄對
    #  WEB服務器用戶賬號是可寫的.
    #（2） 在你的 model 中添加 FileField 或 ImageField, 並確保定義了 upload_to 選項,以告訴 Django
    # 使用 MEDIA_ROOT 的哪一個子目錄保存上傳文件.你的數據庫中要保存的只是文件的路徑(相對於 MEDIA_ROOT). 
    # 出於習慣你必定很想使用 Django 提供的 get_<#fieldname>_url 函數.舉例來講,若是你的 ImageField 
    # 叫做 mug_shot, 你就能夠在模板中以 {{ object.#get_mug_shot_url }} 這樣的方式獲得圖像的絕對路徑.

<12> URLField
    # 用於保存 URL. 若 verify_exists 參數爲 True (默認), 給定的 URL 會預先檢查是否存在( 即URL是否被有效裝入且
    # 沒有返回404響應).
    # admin 用一個 <input type="text"> 文本框表示該字段保存的數據(一個單行編輯框)

<13> NullBooleanField
    # 相似 BooleanField, 不過容許 NULL 做爲其中一個選項. 推薦使用這個字段而不要用 BooleanField 加 null=True 選項
    # admin 用一個選擇框 <select> (三個可選擇的值: "Unknown", "Yes" 和 "No" ) 來表示這種字段數據.

<14> SlugField
    # "Slug" 是一個報紙術語. slug 是某個東西的小小標記(短籤), 只包含字母,數字,下劃線和連字符.#它們一般用於URLs
    # 若你使用 Django 開發版本,你能夠指定 maxlength. 若 maxlength 未指定, Django 會使用默認長度: 50.  #在
    # 之前的 Django 版本,沒有任何辦法改變50 這個長度.
    # 這暗示了 db_index=True.
    # 它接受一個額外的參數: prepopulate_from, which is a list of fields from which to auto-#populate 
    # the slug, via JavaScript,in the object's admin form: models.SlugField
    # (prepopulate_from=("pre_name", "name"))prepopulate_from 不接受 DateTimeFields.

<13> XMLField
    #一個校驗值是否爲合法XML的 TextField,必須提供參數: schema_path, 它是一個用來校驗文本的 RelaxNG schema #的文件系統路徑.

<14> FilePathField
    # 可選項目爲某個特定目錄下的文件名. 支持三個特殊的參數, 其中第一個是必須提供的.
    # 參數    描述
    # path    必需參數. 一個目錄的絕對文件系統路徑. FilePathField 據此獲得可選項目. 
    # Example: "/home/images".
    # match    可選參數. 一個正則表達式, 做爲一個字符串, FilePathField 將使用它過濾文件名.  
    # 注意這個正則表達式只會應用到 base filename 而不是
    # 路徑全名. Example: "foo.*\.txt^", 將匹配文件 foo23.txt 卻不匹配 bar.txt 或 foo23.gif.
    # recursive可選參數.要麼 True 要麼 False. 默認值是 False. 是否包括 path 下面的所有子目錄.
    # 這三個參數能夠同時使用.
    # match 僅應用於 base filename, 而不是路徑全名. 那麼,這個例子:
    # FilePathField(path="/home/images", match="foo.*", recursive=True)
    # ...會匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif

<15> IPAddressField
    # 一個字符串形式的 IP 地址, (i.e. "24.124.1.30").
<16># CommaSeparatedIntegerField
    # 用於存放逗號分隔的整數值. 相似 CharField, 必需要有maxlength參數.

:tw-1f349: Field重要參數

<1> null ： 數據庫中字段是否能夠爲空

<2> blank： django的 Admin 中添加數據時是否可容許空值

<3> default：設定缺省值

<4> editable：若是爲假，admin模式下將不能改寫。缺省爲真

<5> primary_key：設置主鍵，若是沒有設置django建立表時會自動加上：
    id = meta.AutoField('ID', primary_key=True)
    primary_key=True implies blank=False, null=False and unique=True. Only one
    primary key is allowed on an object.

<6> unique：數據惟一

<7> verbose_name　　Admin中字段的顯示名稱

<8> validator_list：有效性檢查。非有效產生 django.core.validators.ValidationError 錯誤


<9> db_column，db_index 若是爲真將爲此字段建立索引

<10>choices：一個用來選擇值的2維元組。第一個值是實際存儲的值，第二個用來方便進行選擇。
    如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),)
    gender = models.CharField(max_length=2,choices = SEX_CHOICES)

:tw-1f485: 表的操做(增刪改查)：

:tw-2795: 增(create , save)

from app01.models import *

    #create方式一:   Author.objects.create(name='Alvin')

    #create方式二:   Author.objects.create(**{"name":"alex"})

    #save方式一:     author=Author(name="alvin")
                    author.save()

    #save方式二:     author=Author()
                    author.name="alvin"
                    author.save()

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

#一對多(ForeignKey):

    #方式一: 因爲綁定一對多的字段,好比publish,存到數據庫中的字段名叫publish_id,因此咱們能夠直接給這個
    #       字段設定對應值:
           Book.objects.create(title='php',
                               publisher_id=2,   #這裏的2是指爲該book對象綁定了Publisher表中id=2的行對象
                               publication_date='2017-7-7',
                               price=99)


    #方式二:
    #       <1> 先獲取要綁定的Publisher對象:
        pub_obj=Publisher(name='河大出版社',address='保定',city='保定',
                state_province='河北',country='China',website='http://www.hbu.com')
    OR  pub_obj=Publisher.objects.get(id=1)

    #       <2>將 publisher_id=2 改成  publisher=pub_obj

#多對多(ManyToManyField()):

    author1=Author.objects.get(id=1)
    author2=Author.objects.filter(name='alvin')[0]
    book=Book.objects.get(id=1)
    book.authors.add(author1,author2)
    #等同於:
    book.authors.add(*[author1,author2])
    book.authors.remove(*[author1,author2])
    #-------------------
    book=models.Book.objects.filter(id__gt=1)
    authors=models.Author.objects.filter(id=1)[0]
    authors.book_set.add(*book)
    authors.book_set.remove(*book)
    #-------------------
    book.authors.add(1)
    book.authors.remove(1)
    authors.book_set.add(1)
    authors.book_set.remove(1)

#注意: 若是第三張表是經過models.ManyToManyField()自動建立的,那麼綁定關係只有上面一種方式
#     若是第三張表是本身建立的:
     class Book2Author(models.Model):
            author=models.ForeignKey("Author")
            Book=  models.ForeignKey("Book")
#     那麼就還有一種方式:
            author_obj=models.Author.objects.filter(id=2)[0]
            book_obj  =models.Book.objects.filter(id=3)[0]

            s=models.Book2Author.objects.create(author_id=1,Book_id=2)
            s.save()
            s=models.Book2Author(author=author_obj,Book_id=1)
            s.save()

:tw-2796: 刪（delete）

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

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

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

#正向
book = models.Book.objects.filter(id=1)

#刪除第三張表中和女孩1關聯的全部關聯信息
book.author.clear()        #清空與book中id=1 關聯的全部數據
book.author.remove(2)  #能夠爲id
book.author.remove(*[1,2,3,4])     #能夠爲列表,前面加*

#反向
author = models.Author.objects.filter(id=1)
author.book_set.clear() #清空與boy中id=1 關聯的全部數據

改（update和save）

實例：

注意：

第二種方式修改不能用get的緣由是：update是QuerySet對象的方法，get返回的是一個model對象，它沒有update方法，而filter返回的是一個QuerySet對象(filter裏面的條件可能有多個條件符合，好比name＝'alvin',可能有兩個name＝'alvin'的行數據)。
在「插入和更新數據」小節中，咱們有提到模型的save()方法，這個方法會更新一行裏的全部列。而某些狀況下，咱們只須要更新行裏的某幾列。

#---------------- update方法直接設定對應屬性----------------
    models.Book.objects.filter(id=3).update(title="PHP")
    ##sql:
    ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3)


#--------------- save方法會將全部屬性從新設定一遍,效率低-----------
    obj=models.Book.objects.filter(id=3)[0]
    obj.title="Python"
    obj.save()
# SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", 
# "app01_book"."color", "app01_book"."page_num", 
# "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; 
# 
# UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556,
# "publisher_id" = 1 WHERE "app01_book"."id" = 3;

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

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

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

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

LOGGING

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

obj=Book.objects.filter(id=1)[0]
author=Author.objects.filter(id__gt=2)

obj.author.clear()
obj.author.add(*author)

查（filter，value等)

# 查詢相關API：

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

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

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

#-----------下面的方法都是對查詢的結果再進行處理:好比 objects.filter.values()--------

#  <4>values(*field):        返回一個ValueQuerySet——一個特殊的QuerySet，運行後獲得的並非一系列 model的實例化對象，而是一個可迭代的字典序列
                                     
#  <5>exclude(**kwargs):     它包含了與所給篩選條件不匹配的對象

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

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

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

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

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

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

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

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

補充：

#擴展查詢,有時候DJANGO的查詢API不能方便的設置查詢條件，提供了另外的擴展查詢方法extra:
#extra(select=None, where=None, params=None, tables=None,order_by=None, select_params=None

(1)  Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
(2)  Blog.objects.extra(
        select=SortedDict([('a', '%s'), ('b', '%s')]),
        select_params=('one', 'two'))

(3)  q = Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
     q = q.extra(order_by = ['-is_recent'])

(4)  Entry.objects.extra(where=['headline=%s'], params=['Lennon'])  

extra

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

QuerySet特色：

可迭代的
可切片

#objs=models.Book.objects.all()#[obj1,obj2,ob3...]

    #QuerySet:   可迭代

    # for obj in objs:#每一obj就是一個行對象
    #     print("obj:",obj)
    # QuerySet:  可切片

    # print(objs[1])
    # print(objs[1:4])
    # print(objs[::-1])

QuerySet的高效使用：

<1>Django的queryset是惰性的

     Django的queryset對應於數據庫的若干記錄（row），經過可選的查詢來過濾。例如，下面的代碼會得
     到數據庫中名字爲‘Dave’的全部的人:person_set = Person.objects.filter(first_name="Dave")
     上面的代碼並無運行任何的數據庫查詢。你可使用person_set，給它加上一些過濾條件，或者將它傳給某個函數，
     這些操做都不會發送給數據庫。這是對的，由於數據庫查詢是顯著影響web應用性能的因素之一。

<2>要真正從數據庫得到數據，你能夠遍歷queryset或者使用if queryset,總之你用到數據時就會執行sql.
   爲了驗證這些,須要在settings里加入 LOGGING(驗證方式)
        obj=models.Book.objects.filter(id=3)
        # for i in obj:
        #     print(i)

        # if obj:
        #     print("ok")

<3>queryset是具備cache的
     當你遍歷queryset時，全部匹配的記錄會從數據庫獲取，而後轉換成Django的model。這被稱爲執行
    （evaluation）.這些model會保存在queryset內置的cache中，這樣若是你再次遍歷這個queryset，
     你不須要重複運行通用的查詢。
        obj=models.Book.objects.filter(id=3)

        # for i in obj:
        #     print(i)
                          ## models.Book.objects.filter(id=3).update(title="GO")
                          ## obj_new=models.Book.objects.filter(id=3)
        # for i in obj:
        #     print(i)   #LOGGING只會打印一次

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

            obj = Book.objects.filter(id=4)
            #  exists()的檢查能夠避免數據放入queryset的cache。
            if obj.exists():
                print("hello world!")

<5>當queryset很是巨大時，cache會成爲問題

     處理成千上萬的記錄時，將它們一次裝入內存是很浪費的。更糟糕的是，巨大的queryset可能會鎖住系統
     進程，讓你的程序瀕臨崩潰。要避免在遍歷數據的同時產生queryset cache，可使用iterator()方法
     來獲取數據，處理完數據就將其丟棄。
        objs = Book.objects.all().iterator()
        # iterator()能夠一次只從數據庫獲取少許數據，這樣能夠節省內存
        for obj in objs:
            print(obj.name)
        #BUT,再次遍歷沒有打印,由於迭代器已經在上一次遍歷(next)到最後一次了,沒得遍歷了
        for obj in objs:
            print(obj.name)

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

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

對象查詢，單表條件查詢，多表條件關聯查詢

#--------------------對象形式的查找--------------------------
    # 正向查找
    ret1=models.Book.objects.first()
    print(ret1.title)
    print(ret1.price)
    print(ret1.publisher)
    print(ret1.publisher.name)  #由於一對多的關係因此ret1.publisher是一個對象,而不是一個queryset集合

    # 反向查找
    ret2=models.Publish.objects.last()
    print(ret2.name)
    print(ret2.city)
    #如何拿到與它綁定的Book對象呢?
    print(ret2.book_set.all()) #ret2.book_set是一個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,

#----------------了不得的雙下劃線(__)之多表條件關聯查詢---------------

# 正向查找(條件)

#     ret3=models.Book.objects.filter(title='Python').values('id')
#     print(ret3)#[{'id': 1}]

      #正向查找(條件)之一對多

      ret4=models.Book.objects.filter(title='Python').values('publisher__city')
      print(ret4)  #[{'publisher__city': '北京'}]

      #正向查找(條件)之多對多
      ret5=models.Book.objects.filter(title='Python').values('author__name')
      print(ret5)
      ret6=models.Book.objects.filter(author__name="alex").values('title')
      print(ret6)

      #注意
      #正向查找的publisher__city或者author__name中的publisher,author是book表中綁定的字段
      #一對多和多對多在這裏用法沒區別

# 反向查找(條件)

    #反向查找之一對多:
    ret8=models.Publisher.objects.filter(book__title='Python').values('name')
    print(ret8)#[{'name': '人大出版社'}]  注意,book__title中的book就是Publisher的關聯表名

    ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors')
    print(ret9)#[{'book__authors': 1}, {'book__authors': 2}]

    #反向查找之多對多:
    ret10=models.Author.objects.filter(book__title='Python').values('name')
    print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}]

    #注意
    #正向查找的book__title中的book是表名Book
    #一對多和多對多在這裏用法沒區別

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

聚合查詢和分組查詢

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

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

from django.db.models import Avg,Min,Sum,Max

從整個查詢集生成統計值。好比，你想要計算全部在售書的平均價錢。Django的查詢語法提供了一種方式描述全部
圖書的集合。

>>> Book.objects.all().aggregate(Avg('price'))
{'price__avg': 34.35}

aggregate()子句的參數描述了咱們想要計算的聚合值，在這個例子中，是Book模型中price字段的平均值

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


若是你也想知道全部圖書價格的最大值和最小值，能夠這樣查詢：
>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

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

查詢alex出的書總價格

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

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

F查詢和Q查詢

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

# F 使用查詢條件的值,專門取對象中某列值的操做

    # from django.db.models import F
    # models.Tb1.objects.update(num=F('num')+1)


# Q 構建搜索條件
    from django.db.models import Q

    #1 Q對象(django.db.models.Q)能夠對關鍵字參數進行封裝，從而更好地應用多個查詢
    q1=models.Book.objects.filter(Q(title__startswith='P')).all()
    print(q1)#[<Book: Python>, <Book: Perl>]

    # 二、能夠組合使用&,|操做符，當一個操做符是用於兩個Q的對象,它產生一個新的Q對象。
    Q(title__startswith='P') | Q(title__startswith='J')

    # 三、Q對象能夠用~操做符放在前面表示否認，也可容許否認與不否認形式的組合
    Q(title__startswith='P') | ~Q(pub_date__year=2005)

    # 四、應用範圍：

    # Each lookup function that takes keyword-arguments (e.g. filter(),
    #  exclude(), get()) can also be passed one or more Q objects as
    # positional (not-named) arguments. If you provide multiple Q object
    # arguments to a lookup function, the arguments will be 「AND」ed
    # together. For example:

    Book.objects.get(
        Q(title__startswith='P'),
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
    )

    #sql:
    # SELECT * from polls WHERE question LIKE 'P%'
    #     AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

    # import datetime
    # e=datetime.date(2005,5,6)  #2005-05-06

    # 五、Q對象能夠與關鍵字參數查詢一塊兒使用，不過必定要把Q對象放在關鍵字參數查詢的前面。
    # 正確：
    Book.objects.get(
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
        title__startswith='P')
    # 錯誤：
    Book.objects.get(
        question__startswith='P',
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))

raw sql

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

admin的配置

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

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

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

一 認識ModelAdmin

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

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

使用register的方法

admin.site.register(Book,MyAdmin)

使用register的裝飾器

@admin.register(Book)

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

list_display: 指定要顯示的字段
search_fields: 指定搜索的字段
list_filter: 指定列表過濾器
ordering：指定排序字段

from django.contrib import admin
from app01.models import *
# Register your models here.

# @admin.register(Book)#----->單給某個表加一個定製
class MyAdmin(admin.ModelAdmin):
    list_display = ("title","price","publisher")
    search_fields = ("title","publisher")
    list_filter = ("publisher",)
    ordering = ("price",)
    fieldsets =[
        (None,               {'fields': ['title']}),
        ('price information', {'fields': ['price',"publisher"], 'classes': ['collapse']}),
    ]

admin.site.register(Book,MyAdmin)
admin.site.register(Publish)
admin.site.register(Author)

部份內容來自於：https://www.cnblogs.com/yuanchenqi/articles/6083427.html