一、Django 簡介
Django 是一個由 Python 寫成的開放源代碼的 Web 應用框架。它最初是被開發來用於管理勞倫斯出版集團旗下的一些以新聞內容為主的網站的，即是 CMS（內容管理系統）軟件。並於2005年7月在 BSD 許可證下發布。這套框架是以比利時的吉普賽爵士吉他手 Django Reinhardt 來命名的。由於 Django 的是在一個快節奏的新聞編輯室環境下開發的，它的目的是使常見的 Web 開發任務，快速和容易。
MTV 模式
Django 采用了 MTV 設計模式
上述圖大概是說：
- URL ( urls.py )請求調度,當有緩存頁面的時候直接返回內容。
- 視圖函數( view.py )執行所請求的操作,通常包括讀寫數據庫。
- 模型( models.py )定義了 Python 中的數據並與之交互。通常包含在一個關系數據庫( MySQL、PostgreSQL SQLite 等),其他數據存儲是可能的( XML、文本文件、LDAP、等)。
- 請求執行任務后,視圖返回一個 HTTP 響應對象(通常是經過數據處理的一個模板)。可選的：視圖可以保存一個版本的 HTTP 響應對象,返回攜帶一個時間戳，來告訴瀏覽器這個視圖的更新時間。
- 模板通常返回 HTML 頁面。Django 模板語言提供了 HTML 的語法及邏輯。
安裝
# pip 安裝 pip install Django==1.10 # 克隆下載最新版本 git clone https://github.com/django/django.git # 導入django模塊 >>> import django >>> print(django.get_version()) 1.10
二、基本配置
1、常用命令
# 查看django版本 $ python -m django --version # 創建項目,名為mysite $ django-admin startproject mysite # 啟動django $ python manage.py runserver $ python manage.py runserver 8080 $ python manage.py runserver 0.0.0.0:8000 # 創建應用程序，確保和 manage.py 是同一目錄 $ python manage.py startapp polls # 運行創造模型變化遷移 $ python manage.py makemigrations # 運行應用模型變化到數據庫 $ python manage.py migrate # admin創建管理員用戶 $ python manage.py createsuperuser
注：自動重新加載 runserver，根據需要開發服務器自動重新加載Python代碼為每個請求。您不需要重新啟動服務器代碼更改生效。然而，像添加文件某些操作不觸發重新啟動，所以你必須重新啟動在這些情況下的服務器。
基本目錄結構及作用：
mysite/ # 項目的容器,名字隨便起 manage.py # 命令行實用工具,以各種方式與該Django項目進行交互 mysite/ # 實際的Python項目 __init__.py # 空文件,導入不出錯 settings.py # 這個Django項目配置 urls.py # 這個Django項目的URL聲明; 一個Django驅動網站的“目錄” wsgi.py # 一個入口點為WSGI兼容的Web服務器，以滿足您的項目
2、配置文件
數據庫
# 由於Django內部連接MySQL時使用的是MySQLdb模塊，而python3中還無此模塊，所以需要使用pymysql來代替 # 如下設置放置的與project同名的配置的 __init__.py文件中 import pymysql pymysql.install_as_MySQLdb()
# 在settings 中修改DATABASES DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME':'dbname', 'USER': 'root', 'PASSWORD': 'xxx', 'HOST': '', 'PORT': '', } }
模板
# 也在settings里修改，放html文件 TEMPLATE_DIRS = ( os.path.join(BASE_DIR,'templates'), )
靜態文件
# 依然在settings里修改添加，放css,js等文件 STATICFILES_DIRS = ( os.path.join(BASE_DIR,'static'), )
三、路由系統
1、URL 調度
一個干凈，優雅的 URL 方案是一個高質量的 Web 應用程序的一個重要的細節。
與 tornado 不同的是一個 url 對應一個函數，而並非一個類。
像是一個新華字典的目錄，對應了 views 函數來進行處理，即這個 url 要用某個指定的 views 函數處理。
來看以下示例，如何動態構造：
from app1 import views urlpatterns = [ url(r'^manage1/(\d*)', views.manage1), url(r'^manage2/(?P<name>\w*)/(?P<id>\d*)', views.manage2), url(r'^manage3/(?P<name>\w*)', views.manage3,{'id':333}), ] # 需要注意 # url多傳了一個參數，那views函數得多接受一個參數
# 對應接收值 def manage1(request, age): print(age) # 18 return HttpResponse('1') def manage2(request, name, id): print(name, id) # nick 18 return HttpResponse('2') def manage3(request, name, id): print(name, id) # nick 666 return HttpResponse('3')
二級路由： 那如果映射 url 太多怎么辦，全寫一個在 urlpatterns 顯得繁瑣，so 二級路由應用而生
# 一級路由規定 app1 開頭的都去 app1.urls 中找 # 二級在詳細規定對應 views 函數 # 一級 urlpatterns = [ url(r'^app1/', include('app1.urls')), ] # 二級 urlpatterns = [ url(r'^1$', views.manage1), ]
2、Django是如何處理一個請求
當用戶請求從您的 Django 的網站頁面，這是該系統遵循以確定哪些 Python 代碼執行的算法：
- Django 請求是 URL 配置模塊配置。通常通過值 ROOT_URLCONF 設置，但如果傳入 HttpRequest 對象具有 urlconf 屬性（由中間件設置），它的值將代替的可以使用 ROOT_URLCONF 的設置。
- Django 的負載是 Python 模塊並尋找變量 urlpatterns。這是一個 django.conf.urls.url() 實例。
- Django 的貫穿每個 URL 模式，從而，在所請求的 URL 匹配的第一個停止。
- 一旦某個正則表達式相匹配，就運行相對應的視圖函數(或基於類的視圖)。該視圖被傳遞以下參數：
- HttpRequest 對象。
- 如果匹配的正則表達式沒有返回命名組，然后從正則表達式比賽是作為位置參數。
- 關鍵詞參數是由由正則表達式匹配的任何命名組，由指定的可選參數的任何覆蓋的 kwargs參數 django.conf.urls.url()。
- 如果沒有正則表達式匹配，或者如果一個異常在這個過程中的任何一點時提出，Django的調用適當的錯誤處理視圖。
3、官方示例
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), ]
筆記注意事項：
- 要捕獲從URL中的值，用括號括起來，會當參數傳入 views 視圖。
- 沒有必要添加一個斜線，因為每個URL都有。例如，它
^articles不是^/articles。 - 在
'r'前面的每個正則表達式字符串中是可選的，但建議。它告訴Python字符串是“原始” -沒有什么字符串中應該進行轉義。
舉例請求：
- 請求
/articles/2005/03/將匹配列表中的第三項。Django的將調用該函數 。views.month_archive(request,'2005', '03') /articles/2005/3/不會匹配任何 URL 模式，因為在列表中的第三項中需要兩位數字的月份。/articles/2003/將匹配的列表，而不是第二個第一圖案，因為該圖案，以便測試，第一個是在第一測試通過。隨意利用順序插入特殊情況是這樣的。在這里，Django的將調用該函數views.special_case_2003(request)/articles/2003不匹配任何這些模式，因為每個模式要求 URL 以斜線結束。/articles/2003/03/03/將匹配的最終格局。Django 的將調用該函數。views.article_detail(request,'2003', '03', '03')
2> 命名組
上面的例子使用了簡單的，非命名的正則表達式組（通過括號）來捕獲 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')views.month_archive(request, '2005', '03') - 請求
/articles/2003/03/03/會調用該函數，views.article_detail(request, year='2003',month='03', day='03')
在實踐中，這意味着你的 URLconf 稍微更明確，不容易參數順序錯誤 - 你可以在你的意見'函數定義重新排序的參數。當然，這些優點來在簡短的費用; 一些開發任務命名組的語法丑陋，太冗長。
匹配/分組算法
這里的URL配置解析器遵循算法，相對於正則表達式命名組與非命名組：
- 如果有任何命名參數，它會使用這些，而忽略非命名參數。
- 否則，它會通過所有非命名參數作為位置參數。
在這兩種情況下，被賦予按任何額外的關鍵字參數傳遞額外的選項來查看功能也將被傳遞給視圖
3> What the URLconf searches against
The URLconf searches against the requested URL, as a normal Python string. This does not include GET or POST parameters, or the domain name.
For example, in a request to https://www.example.com/myapp/, the URLconf will look for myapp/.
In a request to https://www.example.com/myapp/?page=3, the URLconf will look for myapp/.
該URL配置不看請求方法。換言之，所有的請求的方法，GET，POST 等將被路由到為相同的URL，相同的功能。
4> 捕獲的參數總是字符串
每個捕獲的參數發送到視圖作為普通的 Python 字符串，無論什么樣的匹配正則表達式匹配。
例如，在該URL配置行：
url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
...的 year參數傳遞給 views.year_archive()將是一個字符串，
不是一個整數，即使 [0-9]{4} 將只匹配整數字符串。
5> 指定view的默認設置
一個方便的技巧是你的觀點的論據指定默認參數。下面是一個例子的 RLconf 和看法：
# 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"): # Output the appropriate page of blog entries, according to num. ...
在上述的例子中，兩個 URL 模式指向同一個視圖 views.page 但第一圖案不捕獲從 URL 任何東西。如果第一個模式匹配，該 page() 函數將使用它的默認參數 num，"1"。如果第二圖案相匹配時， page()將使用任何 num 值由正則表達式捕獲。
6> 包括其他的URLconf
在任何時候，你urlpatterns可以“include”其他的URLconf模塊。這實質上是“roots”的一套低於其他的網址。
例如，這里的URL配置為節選的Django網站 本身。它包括許多其他的URLconf的：
from django.conf.urls import include, url urlpatterns = [ # ... snip ... url(r'^community/', include('django_website.aggregator.urls')), url(r'^contact/', include('django_website.contact.urls')), # ... snip ... ]
請注意，在這個例子中，正則表達式沒有一個$ （結束字符串匹配字符），但包括尾隨斜線。每當 Django 的遇到 include()（django.conf.urls.include()），它扒關閉任何匹配到該點的URL的一部分，並將剩余的字符串所包含的URL配置用於進一步的處理。
另一種可能性是通過使用的列表，以包括另外的網址格式 url()實例。例如，考慮這個 URL 配置：
from django.conf.urls import include, url from apps.main import views as main_views from credit import views as credit_views extra_patterns = [ url(r'^reports/$', credit_views.report), url(r'^reports/(?P<id>[0-9]+)/$', credit_views.report), url(r'^charge/$', credit_views.charge), ] urlpatterns = [ url(r'^$', main_views.homepage), url(r'^help/', include('apps.help.urls')), url(r'^credit/', include(extra_patterns)), ]
在這個例子中，/credit/reports/URL將被處理 credit_views.report()的Django圖。
從其中單個圖案前綴被重復使用的URLconf去除冗余。
我們可以通過聲明的共同路徑前綴只有一次，分組，例如這個URL配置：
from django.conf.urls import include, url from . import views urlpatterns = [ url(r'^(?P<page_slug>[\w-]+)-(?P<page_id>\w+)/', include([ url(r'^history/$', views.history), url(r'^edit/$', views.edit), url(r'^discuss/$', views.discuss), url(r'^permissions/$', views.permissions), ])), ]
7> 傳遞額外的選項來查看功能
URLconf 有一個掛鈎，可以傳遞額外的參數給您的視圖功能，作為一個 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')
# 處理沖突 這可能有它可以捕獲一個名為關鍵字參數的URL模式，並且還傳遞參數，在其額外的參數字典相同的名稱。發生這種情況時，在字典中的參數將被用來代替在URL捕獲的參數。
傳遞額外的選項來 include()
同樣，您可以通過額外的選項include()。當你通過額外的選項include()，每個中所包含的URL配置線將通過額外的選項。
例如，這兩個URL配置集在功能上是相同的：
# 設置一個： # main.py from django.conf.urls import include, url urlpatterns = [ url(r'^blog/', include('inner'), {'blogid': 3}), ] # inner.py from django.conf.urls import url from mysite import views urlpatterns = [ url(r'^archive/$', views.archive), url(r'^about/$', views.about), ] # 設置兩個 # main.py from django.conf.urls import include, url from mysite import views urlpatterns = [ url(r'^blog/', include('inner')), ] # inner.py from django.conf.urls import url urlpatterns = [ url(r'^archive/$', views.archive, {'blogid': 3}), url(r'^about/$', views.about, {'blogid': 3}), ]
四、視圖層
對邏輯負責處理用戶的請求並返回響應。反回可以是HTML內容的網頁，或重定向，或404錯誤，或一個XML文件，或一個形象......此代碼可以住在任何你想去的地方，只要它在你的Python路徑。
在一個文件中稱將視圖views.py，放在你的項目或應用程序目錄。
1、返回快捷功能
render()
-
render(
request,
template_name,
context=None,
content_type=None,
status=None,
using=None)
[source]
- 結合給定的模板與一個給定的上下文，返回一個字典HttpResponse在渲染文本對象
所需的參數
template_name 一個模板的使用或模板序列名稱全稱。如果序列是給定的，存在於第一個模板將被使用。
可選參數
context 一組字典的值添加到模板中。默認情況下，這是一個空的字典。
content_type MIME類型用於生成文檔。
status 為響應狀態代碼。默認值為200
using 這個名字一個模板引擎的使用將模板。
例子
from django.shortcuts import render def my_view(request): # View code here... return render(request, 'myapp/index.html', { 'foo': 'bar', }, content_type='application/xhtml+xml')
等價於
from django.http import HttpResponse from django.template import loader def my_view(request): # View code here... t = loader.get_template('myapp/index.html') c = {'foo': 'bar'} return HttpResponse(t.render(c, request), content_type='application/xhtml+xml')
render_to_response()
render_to_response(template_name, context=None, content_type=None, status=None, using=None)[source]
這個和 render() 差不多，不推薦，在未來可能廢棄掉
redirect()
redirect(to, permanent=False, *args, **kwargs)[source]
默認情況下，為臨時重定向；通過 permanent=True 設置永久重定向
def my_view(request): ... return redirect('/some/url/') def my_view(request): ... object = MyModel.objects.get(...) return redirect(object, permanent=True)
2、求和響應對象
Django 使用請求和響應對象在系統間傳遞狀態。
當請求一個頁面時，Django 創建一個 HttpRequest對象包含原數據的請求。然后 Django 加載適當的視圖，通過 HttpRequest作為視圖函數的第一個參數。每個視圖負責返回一個HttpResponse目標。
HttpRequest對象
HttpRequest.scheme一個字符串表示請求的方案（HTTP或HTTPS）通常HttpRequest.path
一個字符串的完整路徑的請求HttpRequest.method
請求的HTTP方法。這是保證要大寫 if request.method == 'GET': do_something() elif request.method == 'POST': do_something_else()HttpRequest.GET
字典像包含所有給定的HTTP GET參數對象。HttpRequest.POST
字典像包含所有給定的HTTP POST參數對象，提供請求包含表單數據。HttpRequest.COOKIES
一個標准的Python字典，包含了所有的COOKIES，key和values都是字符串HttpRequest.FILES
字典像對象包含所有上傳的文件。 html 標簽 <input type="file" name="" /> filename # 上傳的文件名 content_type # 上傳文件的類型 content # 上傳文件的內容HttpRequest.META
一個標准的Python字典包含所有可用的HTTP頭。可用標題取決於客戶端和服務器，但這里是一些例子： CONTENT_LENGTH – 請求體的長度（一個字符串）。 CONTENT_TYPE – 請求體的類型。 HTTP_ACCEPT - 為響應–可以接受的內容類型。 HTTP_ACCEPT_ENCODING – 接受編碼的響應 HTTP_ACCEPT_LANGUAGE – 接受語言的反應 HTTP_HOST – 客戶端發送的HTTP主機頭。 HTTP_REFERER – 參考頁面 HTTP_USER_AGENT – 客戶端的用戶代理字符串。 QUERY_STRING – 查詢字符串，作為一個單一的（分析的）字符串。 REMOTE_ADDR – 客戶端的IP地址 REMOTE_HOST – 客戶端的主機名 REMOTE_USER – 用戶通過Web服務器的身份驗證。 REQUEST_METHOD – 字符串，如"GET"或"POST" SERVER_NAME – 服務器的主機名 SERVER_PORT – 服務器的端口（一個字符串）。
HttpResponse對象
對於HttpRequest 對象來說，是由django自動創建的，但是，HttpResponse 對象就必須我們自己創建。每個 view 請求處理方法必須返回一個 HttpResponse 對象。
HttpResponse 類在 django.http.HttpResponse
字符串使用：
典型的用法是通過頁面的內容，為一個字符串
>>> from django.http import HttpResponse >>> response = HttpResponse("Here's the text of the Web page.") >>> response = HttpResponse("Text only, please.", content_type="text/plain") # 如果你想添加內容的增量 >>> response = HttpResponse() >>> response.write("<p>Here's the text of the Web page.</p>") >>> response.write("<p>Here's another paragraph.</p>")
特性與方法：
HttpResponse.content一個bytestring代表內容HttpResponse.charset
一個字符串的字符集表示的響應將編碼HttpResponse.status_code
HTTP狀態代碼為響應碼HttpResponse.streaming
這個屬性永遠為假，一般用於中間件HttpResponse.closed
關閉
方法：
HttpResponse.__init__(content='', content_type=None, status=200, reason=None, charset=None)[source]
實例化類自動執行的方法HttpResponse.__setitem__(header, value)
為給定值給定的標題名稱。都是字符串HttpResponse.__delitem__(header)
刪除標題的名稱。不區分大小寫。HttpResponse.__getitem__(header)
獲取給定標題名稱。不區分大小寫。HttpResponse.has_header(header)
檢查是否具有給定名稱的一個標題HttpResponse.setdefault(header, value)
設置一個標題,除非它已經設置。HttpResponse.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=False)
設置一個cookie。參數跟標准庫的Cookie對象差不多HttpResponse.set_signed_cookie(key, value, salt='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=True)
加密cookice，可以用 HttpRequest.get_signed_cookie() 獲取，當然你也可以加鹽HttpResponse.delete_cookie(key, path='/', domain=None)
刪除Cookie與給定鍵。
HttpResponse子類：
class HttpResponseRedirect[source]
構造函數的第一個參數是必需的–路徑redirectto。這是一個完全合格的URL（例如“https：／／www.yahoo.com /搜索/），沒有一個絕對的路徑（例如域搜索/ /），甚至是相對路徑（如“/”）。在最后的情況下，客戶端瀏覽器將重建完整的URL本身的電流路徑。看到HttpResponse其他optionalconstructor參數。請注意，這將返回一個HTTP狀態代碼302。class HttpResponsePermanentRedirect[source]
像httpresponseredirect，但它返回一個永久重定向（HTTP狀態代碼301）而不是“發現”的重定向（狀態代碼302）class HttpResponseNotModified[source]
構造函數不帶任何參數和NO含量應該被添加到這一反應。使用指定一個頁面沒有被modifiedsince用戶的最后一個請求（狀態代碼304）。class HttpResponseBadRequest[source]
就像HttpResponse但使用400狀態碼class HttpResponseNotFound[source]
就像HttpResponse但使用404狀態碼class HttpResponseForbidden[source]
就像HttpResponse但使用403狀態碼class HttpResponseNotAllowed[source]
像HttpResponse，但使用405狀態碼。第一argumentto構造函數要求准許清單的方法（如（get，后]）class HttpResponseGone[source]
就像HttpResponse但使用410狀態碼class HttpResponseServerError[source]
就像HttpResponse但使用500狀態碼
五、模板層
作為一個Web框架，Django 需要模板。模板包含所需的 HTML 輸出靜態部分以及動態內容插入。
1、模版的執行
def current_datetime(request): now = datetime.datetime.now() html = "<html><body>It is now %s.</body></html>" % now return HttpResponse(html) from django import template t = template.Template('My name is {{ name }}.') c = template.Context({'name': 'Adrian'}) print t.render(c) import datetime from django import template import DjangoDemo.settings now = datetime.datetime.now() fp = open(settings.BASE_DIR+'/templates/Home/Index.html') t = template.Template(fp.read()) fp.close() html = t.render(template.Context({'current_date': now})) return HttpResponse(html from django.template.loader import get_template from django.template import Context from django.http import HttpResponse import datetime def current_datetime(request): now = datetime.datetime.now() t = get_template('current_datetime.html') html = t.render(Context({'current_date': now})) return HttpResponse(html) return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))
2、模版語言
模板中也有自己的語言，該語言可以實現數據展示
- {{ item }}
- {% for item in item_list %} <a>{{ item }}</a> {% endfor %}
forloop.counter
forloop.first
forloop.last - {% if ordered_warranty %} {% else %} {% endif %}
- 母板：{% block title %}{% endblock %}
子板：{% extends "base.html" %}
{% block title %}{% endblock %} - 幫助方法：
{{ item.event_start|date:"Y-m-d H:i:s"}}
{{ bio|truncatewords:"30" }}
{{ my_list|first|upper }}
{{ name|lower }}
3、自定義simple_tag
a、在app中創建templatetags模塊
b、創建任意 .py 文件，如：xx.py
#!/usr/bin/env python #coding:utf-8 from django import template from django.utils.safestring import mark_safe from django.template.base import resolve_variable, Node, TemplateSyntaxError register = template.Library() @register.simple_tag def my_simple_time(v1,v2,v3): return v1 + v2 + v3 @register.simple_tag def my_input(id,arg): result = "<input type='text' id='%s' class='%s' />" %(id,arg,) return mark_safe(result)
c、在使用自定義simple_tag的html文件中導入之前創建的 xx.py 文件名
{% load xx %}
d、使用simple_tag
{% my_simple_time 1 2 3%}
{% my_input 'id_username' 'hide'%}
e、在settings中配置當前app，不然django無法找到自定義的simple_tag
INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'app01', )
六、Model 層
Django提供了一個抽象層（“Model”）的構建和管理Web應用程序的數據。
- 每個模型是一個Python類，子類
d jango.db.models.model - 模型中的每個屬性代表一個數據庫字段。
簡單的例子
from django.db import models class Person(models.Model): first_name = models.CharField(max_length=30) last_name = models.CharField(max_length=30)
參數與字段
1、models.AutoField 自增列 = int(11) 如果沒有的話，默認會生成一個名稱為 id 的列，如果要顯示的自定義一個自增列，必須將給列設置為主鍵 primary_key=True。 2、models.CharField 字符串字段 必須 max_length 參數 3、models.BooleanField 布爾類型=tinyint(1) 不能為空，Blank=True 4、models.ComaSeparatedIntegerField 用逗號分割的數字=varchar 繼承CharField，所以必須 max_lenght 參數 5、models.DateField 日期類型 date 對於參數，auto_now = True 則每次更新都會更新這個時間；auto_now_add 則只是第一次創建添加，之后的更新不再改變。 6、models.DateTimeField 日期類型 datetime 同DateField的參數 7、models.Decimal 十進制小數類型 = decimal 必須指定整數位max_digits和小數位decimal_places 8、models.EmailField 字符串類型（正則表達式郵箱） =varchar 對字符串進行正則表達式 9、models.FloatField 浮點類型 = double 10、models.IntegerField 整形 11、models.BigIntegerField 長整形 integer_field_ranges = { 'SmallIntegerField': (-32768, 32767), 'IntegerField': (-2147483648, 2147483647), 'BigIntegerField': (-9223372036854775808, 9223372036854775807), 'PositiveSmallIntegerField': (0, 32767), 'PositiveIntegerField': (0, 2147483647), } 12、models.IPAddressField 字符串類型（ip4正則表達式） 13、models.GenericIPAddressField 字符串類型（ip4和ip6是可選的） 參數protocol可以是：both、ipv4、ipv6 驗證時，會根據設置報錯 14、models.NullBooleanField 允許為空的布爾類型 15、models.PositiveIntegerFiel 正Integer 16、models.PositiveSmallIntegerField 正smallInteger 17、models.SlugField 減號、下划線、字母、數字 18、models.SmallIntegerField 數字 數據庫中的字段有：tinyint、smallint、int、bigint 19、models.TextField 字符串=longtext 20、models.TimeField 時間 HH:MM[:ss[.uuuuuu]] 21、models.URLField 字符串，地址正則表達式 22、models.BinaryField 二進制 23、models.ImageField 圖片 24、models.FilePathField 文件
1、null=True 數據庫中字段是否可以為空 2、blank=True django的 Admin 中添加數據時是否可允許空值 3、primary_key = False 主鍵，對AutoField設置主鍵后，就會代替原來的自增 id 列 4、auto_now 和 auto_now_add auto_now 自動創建---無論添加或修改，都是當前操作的時間 auto_now_add 自動創建---永遠是創建時的時間 5、choices GENDER_CHOICE = ( (u'M', u'Male'), (u'F', u'Female'), ) gender = models.CharField(max_length=2,choices = GENDER_CHOICE) 6、max_length 7、default 默認值 8、verbose_name Admin中字段的顯示名稱 9、name|db_column 數據庫中的字段名稱 10、unique=True 不允許重復 11、db_index = True 數據庫索引 12、editable=True 在Admin里是否可編輯 13、error_messages=None 錯誤提示 14、auto_created=False 自動創建 15、help_text 在Admin中提示幫助信息 16、validators=[] 17、upload-to
連表結構
- 一對多：models.ForeignKey(其他表)
- 多對多：models.ManyToManyField(其他表)
- 一對一：models.OneToOneField(其他表)
操作表
1、基本操作
# 增 models.Tb1.objects.create(c1='xx', c2='oo') # 增加一條數據，可以接受字典類型數據 **kwargs obj = models.Tb1(c1='xx', c2='oo') obj.save() # 查 models.Tb1.objects.get(id=123) # 獲取單條數據，不存在則報錯（不建議） models.Tb1.objects.all() # 獲取全部 models.Tb1.objects.filter(name='seven') # 獲取指定條件的數據 # 刪 models.Tb1.objects.filter(name='nick').delete() # 刪除指定條件的數據 # 改models.Tb1.objects.filter(name='nick').update(gender='0') # 將指定條件的數據更新，均支持 **kwargs obj = models.Tb1.objects.get(id=1) obj.c1 = '111' obj.save() # 修改單條數據
2、進階操作（了不起的雙下划線）
利用雙下划線將字段和對應的操作連接起來
# 獲取個數 models.Tb1.objects.filter(name='nick').count() # 大於，小於 models.Tb1.objects.filter(id__gt=1) # 獲取id大於1的值 models.Tb1.objects.filter(id__lt=10) # 獲取id小於10的值 models.Tb1.objects.filter(id__lt=10, id__gt=1) # 獲取id大於1 且 小於10的值 # in models.Tb1.objects.filter(id__in=[11, 22, 33]) # 獲取id等於11、22、33的數據 models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # contains models.Tb1.objects.filter(name__contains="ven") models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感 models.Tb1.objects.exclude(name__icontains="ven") # range models.Tb1.objects.filter(id__range=[1, 2]) # 范圍bettwen and # 其他類似 # startswith，istartswith, endswith, iendswith, # order by models.Tb1.objects.filter(name='nick').order_by('id') # asc models.Tb1.objects.filter(name='nick').order_by('-id') # desc # limit 、offset models.Tb1.objects.all()[10:20] # group by from django.db.models import Count, Min, Max, Sum models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num')) # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
3、連表操作（了不起的雙下划線）
利用雙下划線和 _set 將表之間的操作連接起來
class UserProfile(models.Model): user_info = models.OneToOneField('UserInfo') username = models.CharField(max_length=64) password = models.CharField(max_length=64) def __unicode__(self): return self.username class UserInfo(models.Model): user_type_choice = ( (0, u'普通用戶'), (1, u'高級用戶'), ) user_type = models.IntegerField(choices=user_type_choice) name = models.CharField(max_length=32) email = models.CharField(max_length=32) address = models.CharField(max_length=128) def __unicode__(self): return self.name class UserGroup(models.Model): caption = models.CharField(max_length=64) user_info = models.ManyToManyField('UserInfo') def __unicode__(self): return self.caption class Host(models.Model): hostname = models.CharField(max_length=64) ip = models.GenericIPAddressField() user_group = models.ForeignKey('UserGroup') def __unicode__(self): return self.hostname
user_info_obj = models.UserInfo.objects.filter(id=1).first() print user_info_obj.user_type print user_info_obj.get_user_type_display() print user_info_obj.userprofile.password user_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first() print user_info_obj.keys() print user_info_obj.values()
# 添加一對多 dic = { "hostname": "名字1", "ip": "192.168.1.1", "user_group_id": 1, # 加對象則為"user_group" } models.Host.objects.create(**dic) # 正向查一對多 host_obj = models.Host.objects.all() print(type(host_obj), # <class 'django.db.models.query.QuerySet'> host_obj) # <QuerySet [<Host: 名字1>]> for item in host_obj: print(item.hostname) print(item.user_group.caption) print(item.user_group.user_info.values()) # <QuerySet [{'name': 'nick', 'user_type': 1, 'id': 1, 'email': '630571017@qq.com', 'address': '128號'}]> usergroup_obj = models.Host.objects.filter(user_group__caption='標題1') print(usergroup_obj) # 反向查一對多 usergroup_obj = models.UserGroup.objects.get(id=1) print(usergroup_obj.caption) ret = usergroup_obj.host_set.all() # 所有關於id=1的host print(ret) obj = models.UserGroup.objects.filter(host__ip='192.168.1.1').\ values('host__id', 'host__hostname') print(obj) # <QuerySet [{'host__id': 1, 'host__hostname': '名字1'}]>
user_info_obj = models.UserInfo.objects.get(name='nick') user_info_objs = models.UserInfo.objects.all() group_obj = models.UserGroup.objects.get(caption='CTO') group_objs = models.UserGroup.objects.all() # 添加數據 #group_obj.user_info.add(user_info_obj) #group_obj.user_info.add(*user_info_objs) # 刪除數據 #group_obj.user_info.remove(user_info_obj) #group_obj.user_info.remove(*user_info_objs) # 添加數據 #user_info_obj.usergroup_set.add(group_obj) #user_info_obj.usergroup_set.add(*group_objs) # 刪除數據 #user_info_obj.usergroup_set.remove(group_obj) #user_info_obj.usergroup_set.remove(*group_objs) # 獲取數據 #print group_obj.user_info.all() #print group_obj.user_info.all().filter(id=1) # 獲取數據 #print user_info_obj.usergroup_set.all() #print user_info_obj.usergroup_set.all().filter(caption='CTO') #print user_info_obj.usergroup_set.all().filter(caption='DBA') # 添加多對多 # userinfo_id_1 = models.UserInfo.objects.filter(id=1) # usergroup_id_1 = models.UserGroup.objects.filter(id=1).first() # usergroup_id_1.user_info.add(*userinfo_id_1)
# F 使用查詢條件的值（用原來的值操作） # # from django.db.models import F # models.Tb1.objects.update(num=F('num')+1) # Q 構建搜索條件 from django.db.models import Q # con = Q() # # q1 = Q() # q1.connector = 'OR' # q1.children.append(('id', 1)) # q1.children.append(('id', 10)) # q1.children.append(('id', 9)) # # q2 = Q() # q2.connector = 'OR' # q2.children.append(('c1', 1)) # q2.children.append(('c1', 10)) # q2.children.append(('c1', 9)) # # con.add(q1, 'AND') # con.add(q2, 'AND') # # models.Tb1.objects.filter(con)
from django.db import connection cursor = connection.cursor() cursor.execute("""SELECT * from app1_userinfo where name = %s""", ['nick']) row = cursor.fetchone() print(row)
注意：xx_set中的【_set】是多對多中的固定搭配
擴展：
a、自定義上傳
def upload_file(request): if request.method == "POST": obj = request.FILES.get('fafafa') f = open(obj.name, 'wb') for chunk in obj.chunks(): f.write(chunk) f.close() return render(request, 'file.html')
b、Form上傳文件實例
<form method="post" action="/view1/" enctype="multipart/form-data"> <input type="file" name="ExcelFile" id="id_ExcelFile" /> <input type="submit" value="提交" /> </form>
class FileForm(forms.Form): ExcelFile = forms.FileField()
from django.db import models class UploadFile(models.Model): userid = models.CharField(max_length = 30) file = models.FileField(upload_to = './upload/') date = models.DateTimeField(auto_now_add=True)
def UploadFile(request): uf = AssetForm.FileForm(request.POST,request.FILES) if uf.is_valid(): upload = models.UploadFile() upload.userid = 1 upload.file = uf.cleaned_data['ExcelFile'] upload.save() print upload.file
c、ajax上傳文件實例
<div> {{ up.ExcelFile }} <input type="button" id="submitj" value="提交" /> </div> <script src="/static/js/jquery-2.1.4.min.js"></script> <script> $('#submitj').bind("click",function () { var file = $('#id_ExcelFile')[0].files[0]; var form = new FormData(); form.append('ExcelFile', file); $.ajax({ type:'POST', url: '/view1/', data: form, processData: false, // tell jQuery not to process the data contentType: false, // tell jQuery not to set contentType success: function(arg){ console.log(arg); } }) }) </script>
class FileForm(forms.Form): ExcelFile = forms.FileField()
from django.db import models class UploadFile(models.Model): userid = models.CharField(max_length = 30) file = models.FileField(upload_to = './upload/') date = models.DateTimeField(auto_now_add=True)
from study1 import forms def UploadFile(request): uf = AssetForm.FileForm(request.POST,request.FILES) if uf.is_valid(): upload = models.UploadFile() upload.userid = 1 upload.file = uf.cleaned_data['ExcelFile'] upload.save() print upload.file return render(request, 'file.html', locals())
七、Form
django中的Form一般有兩種功能：
- 輸入html
- 驗證用戶輸入
#!/usr/bin/env python # -*- coding:utf-8 -*- import re from django import forms from django.core.exceptions import ValidationError def mobile_validate(value): mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$') if not mobile_re.match(value): raise ValidationError('手機號碼格式錯誤') class PublishForm(forms.Form): user_type_choice = ( (0, u'普通用戶'), (1, u'高級用戶'), ) user_type = forms.IntegerField(widget=forms.widgets.Select(choices=user_type_choice, attrs={'class': "form-control"})) title = forms.CharField(max_length=20, min_length=5, error_messages={'required': u'標題不能為空', 'min_length': u'標題最少為5個字符', 'max_length': u'標題最多為20個字符'}, widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': u'標題5-20個字符'})) memo = forms.CharField(required=False, max_length=256, widget=forms.widgets.Textarea(attrs={'class': "form-control no-radius", 'placeholder': u'詳細描述', 'rows': 3})) phone = forms.CharField(validators=[mobile_validate, ], error_messages={'required': u'手機不能為空'}, widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': u'手機號碼'})) email = forms.EmailField(required=False, error_messages={'required': u'郵箱不能為空','invalid': u'郵箱格式錯誤'}, widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': u'郵箱'}))
def publish(request): ret = {'status': False, 'data': '', 'error': '', 'summary': ''} if request.method == 'POST': request_form = PublishForm(request.POST) if request_form.is_valid(): request_dict = request_form.clean() print request_dict ret['status'] = True else: error_msg = request_form.errors.as_json() ret['error'] = json.loads(error_msg) return HttpResponse(json.dumps(ret))
擴展：ModelForm
在使用Model和Form時，都需要對字段進行定義並指定類型，通過ModelForm則可以省去From中字段的定義
class AdminModelForm(forms.ModelForm): class Meta: model = models.Admin #fields = '__all__' fields = ('username', 'email') widgets = { 'email' : forms.PasswordInput(attrs={'class':"alex"}), }
八、認證系統auth
auth模塊是Django提供的標准權限管理系統,可以提供用戶身份認證, 用戶組管理,並且可以和admin模塊配合使用.
在INSTALLED_APPS中添加'django.contrib.auth'使用該APP, auth模塊默認啟用.
model
from django.contrib.auth.models import User # 數據庫中該表名為auth_user. CREATE TABLE "auth_user" ( "id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "password" varchar(128) NOT NULL, "last_login" datetime NULL, "is_superuser" bool NOT NULL, "first_name" varchar(30) NOT NULL, "last_name" varchar(30) NOT NULL, "email" varchar(254) NOT NULL, "is_staff" bool NOT NULL, "is_active" bool NOT NULL, "date_joined" datetime NOT NULL, "username" varchar(30) NOT NULL UNIQUE )
新建用戶
user = User.objects.create_user(username, email, password) user.save() # 不存儲用戶密碼明文而是存儲一個Hash值
認證用戶
from django.contrib.auth import authenticate user = authenticate(username=username, password=password) # 認證用戶的密碼是否有效, 若有效則返回代表該用戶的user對象, 若無效則返回None. # 該方法不檢查is_active標志位.
修改密碼
user.set_password(new_password) # 以下實例為先認證通過后才可以修改密碼 user = auth.authenticate(username=username, password=old_password) if user is not None: user.set_password(new_password) user.save()
登錄
from django.contrib.auth import login # login向session中添加SESSION_KEY, 便於對用戶進行跟蹤: 'login(request, user)' # login不進行認證,也不檢查is_active標志位 # 實例 user = authenticate(username=username, password=password) if user is not None: if user.is_active: login(request, user)
退出登錄
# logout會移除request中的user信息, 並刷新session from django.contrib.auth import logout def logout_view(request): logout(request)
只允許登錄的用戶訪問
@login_required修飾器修飾的view函數會先通過session key檢查是否登錄, 已登錄用戶可以正常的執行操作, 未登錄用戶將被重定向到login_url指定的位置.
若未指定login_url參數, 則重定向到settings.LOGIN_URL
from django.contrib.auth.decorators import login_required @login_required(login_url='/accounts/login/') def userinfo(request): ... # settings 配置 LOGIN_URL = '/index/' # views @login_required def userinfo(request): ...
九、跨站請求偽造
簡介
django為用戶實現防止跨站請求偽造的功能，通過中間件 django.middleware.csrf.CsrfViewMiddleware 來完成。而對於django中設置防跨站請求偽造功能有分為全局和局部。
全局：
中間件 django.middleware.csrf.CsrfViewMiddleware
局部：
- @csrf_protect，為當前函數強制設置防跨站請求偽造功能，即便settings中沒有設置全局中間件。
- @csrf_exempt，取消當前函數防跨站請求偽造功能，即便settings中設置了全局中間件。
注：from django.views.decorators.csrf import csrf_exempt,csrf_protect
應用
1、普通表單
veiw中設置返回值： return render_to_response('Account/Login.html',data,context_instance=RequestContext(request)) 或者 return render(request, 'xxx.html', data) html中設置Token: {% csrf_token %}
2、Ajax
對於傳統的form，可以通過表單的方式將token再次發送到服務端，而對於ajax的話，使用如下方式。
# view.py from django.template.context import RequestContext # Create your views here. def test(request): if request.method == 'POST': print request.POST return HttpResponse('ok') return render_to_response('app01/test.html',context_instance=RequestContext(request))
# text.html <!DOCTYPE html> <html> <head lang="en"> <meta charset="UTF-8"> <title></title> </head> <body> {% csrf_token %} <input type="button" onclick="Do();" value="Do it"/> <script src="/static/plugin/jquery/jquery-1.8.0.js"></script> <script src="/static/plugin/jquery/jquery.cookie.js"></script> <script type="text/javascript"> var csrftoken = $.cookie('csrftoken'); function csrfSafeMethod(method) { // these HTTP methods do not require CSRF protection return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method)); } $.ajaxSetup({ beforeSend: function(xhr, settings) { if (!csrfSafeMethod(settings.type) && !this.crossDomain) { xhr.setRequestHeader("X-CSRFToken", csrftoken); } } }); function Do(){ $.ajax({ url:"/app01/test/", data:{id:1}, type:'POST', success:function(data){ console.log(data); } }); } </script> </body> </html>
更多：https://docs.djangoproject.com/en/dev/ref/csrf/#ajax
十、分頁
Django內置分頁
Paginator
自定義分頁
#!/usr/bin/env python # _*_coding:utf-8_*_ from django.utils.safestring import mark_safe class PageInfo(object): def __init__(self,current,totalItem,peritems=5): self.__current=current self.__peritems=peritems self.__totalItem=totalItem def From(self): return (self.__current-1)*self.__peritems def To(self): return self.__current*self.__peritems def TotalPage(self): #總頁數 result=divmod(self.__totalItem,self.__peritems) if result[1]==0: return result[0] else: return result[0]+1 def Custompager(baseurl,currentPage,totalpage): #基礎頁，當前頁，總頁數 perPager=11 #總頁數<11 #0 -- totalpage #總頁數>11 #當前頁大於5 currentPage-5 -- currentPage+5 #currentPage+5是否超過總頁數,超過總頁數，end就是總頁數 #當前頁小於5 0 -- 11 begin=0 end=0 if totalpage <= 11: begin=0 end=totalpage else: if currentPage>5: begin=currentPage-5 end=currentPage+5 if end > totalpage: end=totalpage else: begin=0 end=11 pager_list=[] if currentPage<=1: first="<a href=''>首頁</a>" else: first="<a href='%s%d'>首頁</a>" % (baseurl,1) pager_list.append(first) if currentPage<=1: prev="<a href=''>上一頁</a>" else: prev="<a href='%s%d'>上一頁</a>" % (baseurl,currentPage-1) pager_list.append(prev) for i in range(begin+1,end+1): if i == currentPage: temp="<a href='%s%d' class='selected'>%d</a>" % (baseurl,i,i) else: temp="<a href='%s%d'>%d</a>" % (baseurl,i,i) pager_list.append(temp) if currentPage>=totalpage: next="<a href='#'>下一頁</a>" else: next="<a href='%s%d'>下一頁</a>" % (baseurl,currentPage+1) pager_list.append(next) if currentPage>=totalpage: last="<a href=''>末頁</a>" else: last="<a href='%s%d'>末頁</a>" % (baseurl,totalpage) pager_list.append(last) result=''.join(pager_list) return mark_safe(result) #把字符串轉成html語言
十一、Cookice
獲取Cookie：
request.COOKIES['key'] request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None) 參數： default: 默認值 salt: 加密鹽 max_age: 后台控制過期時間
設置Cookie：
rep = HttpResponse(...) 或 rep ＝ render(request, ...) rep.set_cookie(key,value,...) rep.set_signed_cookie(key,value,salt='加密鹽',...) 參數： key, 鍵 value='', 值 max_age=None, 超時時間 expires=None, 超時時間(IE requires expires, so set it if hasn't been already.) path='/', Cookie生效的路徑，/ 表示根路徑，特殊的：跟路徑的cookie可以被任何url的頁面訪問 domain=None, Cookie生效的域名 secure=False, https傳輸 httponly=False 只能http協議傳輸，無法被JavaScript獲取（不是絕對，底層抓包可以獲取到也可以被覆蓋）
由於cookie保存在客戶端的電腦上，所以，JavaScript和jquery也可以操作cookie。
<script src='/static/js/jquery.cookie.js'></script> $.cookie("list_pager_num", 30,{ path: '/' });
十二、Session
Django中默認支持Session，其內部提供了5種類型的Session供開發者使用：
- 數據庫（默認）
- 緩存
- 文件
- 緩存+數據庫
- 加密cookie
1、數據庫Session
Django默認支持Session，並且默認是將Session數據存儲在數據庫中，即：django_session 表中。 a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.db' # 引擎（默認） SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在瀏覽器上時的key，即：sessionid＝隨機字符串（默認） SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路徑（默認） SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名（默認） SESSION_COOKIE_SECURE = False # 是否Https傳輸cookie（默認） SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http傳輸（默認） SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）（默認） SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否關閉瀏覽器使得Session過期（默認） SESSION_SAVE_EVERY_REQUEST = False # 是否每次請求都保存Session，默認修改之后才保存（默認） b. 使用 def index(request): # 獲取、設置、刪除Session中數據 request.session['k1'] request.session.get('k1',None) request.session['k1'] = 123 request.session.setdefault('k1',123) # 存在則不設置 del request.session['k1'] # 所有 鍵、值、鍵值對 request.session.keys() request.session.values() request.session.items() request.session.iterkeys() request.session.itervalues() request.session.iteritems() # 用戶session的隨機字符串 request.session.session_key # 將所有Session失效日期小於當前日期的數據刪除 request.session.clear_expired() # 檢查 用戶session的隨機字符串 在數據庫中是否 request.session.exists("session_key") # 刪除當前用戶的所有Session數據 request.session.delete("session_key") ...
2、緩存Session
a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.cache' # 引擎 SESSION_CACHE_ALIAS = 'default' # 使用的緩存別名（默認內存緩存，也可以是memcache），此處別名依賴緩存的設置 SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在瀏覽器上時的key，即：sessionid＝隨機字符串 SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路徑 SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名 SESSION_COOKIE_SECURE = False # 是否Https傳輸cookie SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http傳輸 SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周） SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否關閉瀏覽器使得Session過期 SESSION_SAVE_EVERY_REQUEST = False # 是否每次請求都保存Session，默認修改之后才保存 b. 使用 同上
3、文件Session
a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎 SESSION_FILE_PATH = None # 緩存文件路徑，如果為None，則使用tempfile模塊獲取一個臨時地址tempfile.gettempdir() # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在瀏覽器上時的key，即：sessionid＝隨機字符串 SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路徑 SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名 SESSION_COOKIE_SECURE = False # 是否Https傳輸cookie SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http傳輸 SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周） SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否關閉瀏覽器使得Session過期 SESSION_SAVE_EVERY_REQUEST = False # 是否每次請求都保存Session，默認修改之后才保存 b. 使用 同上
4、緩存+數據庫Session
數據庫用於做持久化，緩存用於提高效率 a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db' # 引擎 b. 使用 同上
5、加密cookie Session
a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies' # 引擎 b. 使用 同上
擴展：Session用戶驗證
def login(func): def wrap(request, *args, **kwargs): # 如果未登陸，跳轉到指定頁面 if request.path == '/test/': return redirect('http://www.baidu.com') return func(request, *args, **kwargs) return wrap
6、Redis 實現
環境安裝
pip install django-redis pip install django-redis-cache pip install django-redis-sessions
1> 配置django-redis-sessions
在settings.py中配置
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies' # SESSION_ENGINE = 'redis_sessions.session' SESSION_REDIS_HOST = 'localhost' SESSION_REDIS_PORT = 6379 SESSION_REDIS_DB = 0 SESSION_REDIS_PASSWORD = 'password' SESSION_REDIS_PREFIX = 'session' SESSION_COOKIE_NAME = 'session_name' SESSION_COOKIE_AGE = '60*20' # 超時時間 # If you prefer domain socket connection, you can just add this line instead of SESSION_REDIS_HOST and SESSION_REDIS_PORT. SESSION_REDIS_UNIX_DOMAIN_SOCKET_PATH = '/var/run/redis/redis.sock'
配置完成后可測試如下:
$ pip install django nose redis # Make sure you have redis running on localhost:6379 (poem)[beginman@beginman poem]$ nosetests ---------------------------------------------------------------------- Ran 0 tests in 0.001s OK
2> 配置django-redis-sessions
在settings.py中配置
CACHES = { "default": { "BACKEND": "django_redis.cache.RedisCache", "LOCATION": [ "redis://:password@IP0.0.0.0:6379", ], "OPTIONS": { # "CLIENT_CLASS": "django_redis.client.DefaultClient", "CONNECTION_POOL_KWARGS": {"max_connections": 100}, # 連接池 } } }
CACHES = { 'default': { 'BACKEND': 'redis_cache.RedisCache', 'LOCATION': '<host>:<port>', 'OPTIONS': { 'DB': 1, 'PASSWORD': '', 'PARSER_CLASS': 'redis.connection.HiredisParser', 'CONNECTION_POOL_CLASS': 'redis.BlockingConnectionPool', 'CONNECTION_POOL_CLASS_KWARGS': { 'max_connections': 50, 'timeout': 20, } }, }, }
3>django實現redis的存取
# Start by importing your default cache: from django.core.cache import cache # Store data under a-unique-key: cache.set('a-unique-key', 'this is a string which will be cached') # Later on you can retrieve it in another function: cache.get('a-unique-key') # Will return None if key is not found in cache # You can specify a default value: cache.get('another-unique-key', 'default value') # You can store multiple values at once: cache.set_many({'a': 1, 'b': 2, 'c': 3}) # And fetch multiple values: cache.get_many(['a', 'b', 'c']) # returns {'a': 1, 'b': 2, 'c': 3} # You can store complex types in the cache: cache.set('a-unique-key', { 'string' : 'this is a string', 'int' : 42, 'list' : [1, 2, 3], 'tuple' : (1, 2, 3), 'dict' : {'A': 1, 'B' : 2}, })
更多：http://niwinz.github.io/django-redis/latest/#_installation
十三、緩存
由於Django是動態網站，所有每次請求均會去數據進行相應的操作，當程序訪問量大時，耗時必然會更加明顯，最簡單解決方式是使用：緩存，緩存將一個某個views的返回值保存至內存或者memcache中，5分鍾內再有人來訪問時，則不再去執行view中的操作，而是直接從內存或者Redis中之前緩存的內容拿到，並返回。
Django中提供了6種緩存方式：
- 開發調試
- 內存
- 文件
- 數據庫
- Memcache緩存（python-memcached模塊）
- Memcache緩存（pylibmc模塊）
1、配置
a、開發調試
# 此為開始調試用，實際內部不做任何操作 # 配置： CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.dummy.DummyCache', # 引擎 'TIMEOUT': 300, # 緩存超時時間（默認300，None表示永不過期，0表示立即過期） 'OPTIONS':{ 'MAX_ENTRIES': 300, # 最大緩存個數（默認300） 'CULL_FREQUENCY': 3, # 緩存到達最大個數之后，剔除緩存個數的比例，即：1/CULL_FREQUENCY（默認3） }, 'KEY_PREFIX': '', # 緩存key的前綴（默認空） 'VERSION': 1, # 緩存key的版本（默認1） 'KEY_FUNCTION' 函數名 # 生成key的函數（默認函數會生成為：【前綴:版本:key】） } } # 自定義key def default_key_func(key, key_prefix, version): """ Default function to generate keys. Constructs the key used by all other methods. By default it prepends the `key_prefix'. KEY_FUNCTION can be used to specify an alternate function with custom key making behavior. """ return '%s:%s:%s' % (key_prefix, version, key) def get_key_func(key_func): """ Function to decide which key function to use. Defaults to ``default_key_func``. """ if key_func is not None: if callable(key_func): return key_func else: return import_string(key_func) return default_key_func
b、內存
# 此緩存將內容保存至內存的變量中 # 配置： CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'unique-snowflake', } } # 注：其他配置同開發調試版本
c、文件
# 此緩存將內容保存至文件 # 配置： CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', 'LOCATION': '/var/tmp/django_cache', } } # 注：其他配置同開發調試版本
d、數據庫
# 此緩存將內容保存至數據庫 # 配置： CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.db.DatabaseCache', 'LOCATION': 'my_cache_table', # 數據庫表 } } # 注：執行創建表命令 python manage.py createcachetable
e、Memcache緩存（python-memcached模塊）
# 此緩存使用python-memcached模塊連接memcache CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': '127.0.0.1:11211', } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': 'unix:/tmp/memcached.sock', } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': [ '172.19.26.240:11211', '172.19.26.242:11211', ] } }
f、Memcache緩存（pylibmc模塊）
# 此緩存使用pylibmc模塊連接memcache CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache', 'LOCATION': '127.0.0.1:11211', } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache', 'LOCATION': '/tmp/memcached.sock', } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache', 'LOCATION': [ '172.19.26.240:11211', '172.19.26.242:11211', ] } }
2、應用
a、 全站使用
使用中間件，經過一系列的認證等操作，如果內容在緩存中存在，則使用FetchFromCacheMiddleware獲取內容並返回給用戶，當返回給用戶之前，判斷緩存中是否已經存在，如果不存在則UpdateCacheMiddleware會將緩存保存至緩存，從而實現全站緩存 MIDDLEWARE = [ 'django.middleware.cache.UpdateCacheMiddleware', # 其他中間件... 'django.middleware.cache.FetchFromCacheMiddleware', ] CACHE_MIDDLEWARE_ALIAS = "" CACHE_MIDDLEWARE_SECONDS = "" CACHE_MIDDLEWARE_KEY_PREFIX = ""
b、單獨視圖緩存
方式一： from django.views.decorators.cache import cache_page @cache_page(60 * 15) def my_view(request): ... 方式二： from django.views.decorators.cache import cache_page urlpatterns = [ url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)), ]
c、局部視圖使用
a. 引入TemplateTag {% load cache %} b. 使用緩存 {% cache 5000 緩存key %} 緩存內容 {% endcache %}
更多：猛擊這里
十四、序列化
關於Django中的序列化主要應用在將數據庫中檢索的數據返回給客戶端用戶，特別的Ajax請求一般返回的為Json格式。
1、serializers
from django.core import serializers ret = models.BookType.objects.all() data = serializers.serialize("json", ret)
2、json.dumps
import json #ret = models.BookType.objects.all().values('caption') ret = models.BookType.objects.all().values_list('caption') ret=list(ret) result = json.dumps(ret)
由於json.dumps時無法處理datetime日期，所以可以通過自定義處理器來做擴展，如：
import json from datetime import date from datetime import datetime class JsonCustomEncoder(json.JSONEncoder): def default(self, field): if isinstance(field, datetime): return o.strftime('%Y-%m-%d %H:%M:%S') elif isinstance(field, date): return o.strftime('%Y-%m-%d') else: return json.JSONEncoder.default(self, field) # ds = json.dumps(d, cls=JsonCustomEncoder)
十五、中間件
django 中的中間件（middleware），在django中，中間件其實就是一個類，在請求到來和結束后，django會根據自己的規則在合適的時機執行中間件中相應的方法。
在django項目的settings模塊中，有一個 MIDDLEWARE_CLASSES 變量，其中每一個元素就是一個中間件，如下圖。
與mange.py在同一目錄下的文件夾 wupeiqi/middleware下的auth.py文件中的Authentication類
中間件中可以定義四個方法，分別是：
- process_request(self,request)
- process_view(self, request, callback, callback_args, callback_kwargs)
- process_template_response(self,request,response)
- process_exception(self, request, exception)
- process_response(self, request, response)
以上方法的返回值可以是None和HttpResonse對象，如果是None，則繼續按照django定義的規則向下執行，如果是HttpResonse對象，則直接將該對象返回給用戶。
自定義中間件
1、創建中間件類
class RequestExeute(object): def process_request(self,request): pass def process_view(self, request, callback, callback_args, callback_kwargs): i =1 pass def process_exception(self, request, exception): pass def process_response(self, request, response): return response
2、注冊中間件
MIDDLEWARE_CLASSES = ( 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.auth.middleware.SessionAuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', 'wupeiqi.middleware.auth.RequestExeute', )
十六、信號
Django中提供了“信號調度”，用於在框架執行操作時解耦。通俗來講，就是一些動作發生的時候，信號允許特定的發送者去提醒一些接受者。
1、Django內置信號
Model signals pre_init # django的modal執行其構造方法前，自動觸發 post_init # django的modal執行其構造方法后，自動觸發 pre_save # django的modal對象保存前，自動觸發 post_save # django的modal對象保存后，自動觸發 pre_delete # django的modal對象刪除前，自動觸發 post_delete # django的modal對象刪除后，自動觸發 m2m_changed # django的modal中使用m2m字段操作第三張表（add,remove,clear）前后，自動觸發 class_prepared # 程序啟動時，檢測已注冊的app中modal類，對於每一個類，自動觸發 Management signals pre_migrate # 執行migrate命令前，自動觸發 post_migrate # 執行migrate命令后，自動觸發 Request/response signals request_started # 請求到來前，自動觸發 request_finished # 請求結束后，自動觸發 got_request_exception # 請求異常后，自動觸發 Test signals setting_changed # 使用test測試修改配置文件時，自動觸發 template_rendered # 使用test測試渲染模板時，自動觸發 Database Wrappers connection_created # 創建數據庫連接時，自動觸發
對於Django內置的信號，僅需注冊指定信號，當程序執行相應操作時，自動觸發注冊函數：
from django.core.signals import request_finished from django.core.signals import request_started from django.core.signals import got_request_exception from django.db.models.signals import class_prepared from django.db.models.signals import pre_init, post_init from django.db.models.signals import pre_save, post_save from django.db.models.signals import pre_delete, post_delete from django.db.models.signals import m2m_changed from django.db.models.signals import pre_migrate, post_migrate from django.test.signals import setting_changed from django.test.signals import template_rendered from django.db.backends.signals import connection_created def callback(sender, **kwargs): print("xxoo_callback") print(sender,kwargs) xxoo.connect(callback) # xxoo指上述導入的內容
from django.core.signals import request_finished from django.dispatch import receiver @receiver(request_finished) def my_callback(sender, **kwargs): print("Request finished!")
2、自定義信號
a. 定義信號
import django.dispatch pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])
b. 注冊信號
def callback(sender, **kwargs): print("callback") print(sender,kwargs) pizza_done.connect(callback)
c. 觸發信號
from 路徑 import pizza_done pizza_done.send(sender='seven',toppings=123, size=456)
由於內置信號的觸發者已經集成到Django中，所以其會自動調用，而對於自定義信號則需要開發者在任意位置觸發。
更多：猛擊這里
十七、admin
django amdin是django提供的一個后台管理頁面，改管理頁面提供完善的html和css，使得你在通過Model創建完數據庫表之后，就可以對數據進行增刪改查，而使用django admin 則需要以下步驟：
- 創建后台管理員
- 配置url
- 注冊和配置django admin后台管理頁面
1、創建后台管理員
python manage.py createsuperuser
2、配置后台管理url
url(r'^admin/', include(admin.site.urls))
3、注冊和配置django admin 后台管理頁面
a、在admin中執行如下配置
from django.contrib import admin from app01 import models admin.site.register(models.UserType) admin.site.register(models.UserInfo) admin.site.register(models.UserGroup) admin.site.register(models.Asset)
b、設置數據表名稱
class UserType(models.Model): name = models.CharField(max_length=50) class Meta: verbose_name = '用戶類型' verbose_name_plural = '用戶類型'
c、打開表之后，設定默認顯示，需要在model中作如下配置
class UserType(models.Model): name = models.CharField(max_length=50) def __unicode__(self): return self.name
from django.contrib import admin from app01 import models class UserInfoAdmin(admin.ModelAdmin): list_display = ('username', 'password', 'email') admin.site.register(models.UserType) admin.site.register(models.UserInfo,UserInfoAdmin) admin.site.register(models.UserGroup) admin.site.register(models.Asset)
d、為數據表添加搜索功能
from django.contrib import admin from app01 import models class UserInfoAdmin(admin.ModelAdmin): list_display = ('username', 'password', 'email') search_fields = ('username', 'email') admin.site.register(models.UserType) admin.site.register(models.UserInfo,UserInfoAdmin) admin.site.register(models.UserGroup) admin.site.register(models.Asset)
e、添加快速過濾
from django.contrib import admin from app01 import models class UserInfoAdmin(admin.ModelAdmin): list_display = ('username', 'password', 'email') search_fields = ('username', 'email') list_filter = ('username', 'email') admin.site.register(models.UserType) admin.site.register(models.UserInfo,UserInfoAdmin) admin.site.register(models.UserGroup) admin.site.register(models.Asset)
更多：http://docs.30c.org/djangobook2/chapter06/