Python下有許多款不同的 Web 框架。Django是重量級選手中最有代表性的一位。許多成功的網站和APP都基於Django。
Django是一個開放源代碼的Web應用框架，由Python寫成。
Django遵守BSD版權，初次發布於2005年7月, 並於2008年9月發布了第一個正式版本1.0 。
Django采用了MVC的軟件設計模式，即模型M，視圖V和控制器C。
Django 安裝
在安裝 Django 前，系統需要已經安裝了Python的開發環境。接下來我們來具體看下不同系統下Django的安裝。
Window 下安裝 Django
如果你還未安裝Python環境需要先下載Python安裝包。
1、Python 下載地址：https://www.python.org/downloads/
2、Django 下載地址：https://www.djangoproject.com/download/
注意：目前Django 1.6.x以上版本已經完全兼容Python 3.x。
Python 安裝(已安裝的可跳過)
安裝Python你只需要下載python-x.x.x.msi文件，然后一直點擊"Next"按鈕即可。
安裝完成后你需要設置Python環境變量。 右擊計算機->屬性->高級->環境變量->修改系統變量path，添加Python安裝地址，本文實例使用的是C:\Python33，你需要根據你實際情況來安裝。
Django 安裝
下載 Django 壓縮包，解壓並和Python安裝目錄放在同一個根目錄，進入 Django 目錄，執行python setup.py install，然后開始安裝，Django將要被安裝到Python的Lib下site-packages。
然后是配置環境變量，將這幾個目錄添加到系統環境變量中： C:/Python33/Lib/site-packages/django;C:/Python33/Scripts。 添加完成后就可以使用Django的django-admin.py命令新建工程了。
檢查是否安裝成功
輸入以下命令進行檢查:
python
import django django.get_version()
如果輸出了Django的版本號說明安裝正確。
Linux 上安裝 Django
yum 安裝方法
以下安裝位於 Centos Linux 環境下安裝，如果是你的 Linux 系統是 ubuntu 請使用 apt-get 命令。
默認情況下 Linux 環境已經支持了Python。你可以在終端輸入Python命令來查看是否已經安裝。
Python 2.7.3 (default, Aug 1 2012, 05:14:39) [GCC 4.6.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>>
安裝 setuptools
命令：
yum install setuptools
完成之后，就可以使用 easy_install 命令安裝 django
easy_install django
之后我們在python解釋器輸入以下代碼：
[root@solar django]# python Python 2.7.3 (default, May 15 2014, 14:49:08) [GCC 4.8.0] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import django >>> django.VERSION (1, 6, 5, 'final', 0) >>>
我們可以看到輸出了Django的版本號，說明安裝成功。
pip 命令安裝方法
pip install Django
源碼安裝方法
下載源碼包：https://www.djangoproject.com/download/
輸入以下命令並安裝：
tar xzvf Django-X.Y.tar.gz # 解壓下載包 cd Django-X.Y # 進入 Django 目錄 python setup.py install # 執行安裝命令
安裝成功后 Django 位於 Python 安裝目錄的 site-packages 目錄下。
Mac 下安裝
下載
從這里下載最新的穩定版本：DJango-1.x.y.tar.gz，在頁面右側列表下載，如下圖：
記住是最新的官方版本哦.其中x.y是版本號。進入你下載該文件的文件夾目錄，執行如下命令:（Mac下默認是/Users/xxx/Downloads，xxx是你的用戶名）
$ tar zxvf Django-1.x.y.tar.gz
你也可以從 Github 上下載最新版，地址：https://github.com/django/django：
git clone https://github.com/django/django.git
安裝
進入解壓后的目錄：
cd Django-1.x.y sudo python setup.py install
安裝成功后會輸出以下信息：
…… Processing dependencies for Django==1.x.y Finished processing dependencies for Django==1.x.y
再進入我們的站點目錄，創建 Django 項目：
$ django-admin.py startproject testdj
啟動服務：
cd testdj # 切換到我們創建的項目 $ python manage.py runserver …… Starting development server at http://127.0.0.1:8000/ Quit the server with CONTROL-C.
以上信息說明，項目已啟動，訪問地址為http://127.0.0.1:8000/。
Django 創建第一個項目
本章我們將介紹Django 管理工具及如何使用 Django 來創建項目，第一個項目我們以 HelloWorld 來命令項目。
Django 管理工具
安裝 Django 之后，您現在應該已經有了可用的管理工具 django-admin.py。我們可以使用 django-admin.py 來創建一個項目:
我們可以來看下django-admin.py的命令介紹:
[root@solar ~]# django-admin.py Usage: django-admin.py subcommand [options] [args] Options: -v VERBOSITY, --verbosity=VERBOSITY Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, 3=very verbose output --settings=SETTINGS The Python path to a settings module, e.g. "myproject.settings.main". If this isn't provided, the DJANGO_SETTINGS_MODULE environment variable will be used. --pythonpath=PYTHONPATH A directory to add to the Python path, e.g. "/home/djangoprojects/myproject". --traceback Raise on exception --version show program's version number and exit -h, --help show this help message and exit Type 'django-admin.py help <subcommand>' for help on a specific subcommand. Available subcommands: [django] check cleanup compilemessages createcachetable ……省略部分……
創建第一個項目
使用 django-admin.py 來創建 HelloWorld 項目：
django-admin.py startproject HelloWorld
創建完成后我們可以查看下項目的目錄結構：
[root@solar ~]# cd HelloWorld/ [root@solar HelloWorld]# tree . |-- HelloWorld | |-- __init__.py | |-- settings.py | |-- urls.py | `-- wsgi.py `-- manage.py
目錄說明：
- HelloWorld: 項目的容器。
- manage.py: 一個實用的命令行工具，可讓你以各種方式與該 Django 項目進行交互。
- HelloWorld/__init__.py: 一個空文件，告訴 Python 該目錄是一個 Python 包。
- HelloWorld/settings.py: 該 Django 項目的設置/配置。
- HelloWorld/urls.py: 該 Django 項目的 URL 聲明; 一份由 Django 驅動的網站"目錄"。
- HelloWorld/wsgi.py: 一個 WSGI 兼容的 Web 服務器的入口，以便運行你的項目。
接下來我們進入 HelloWorld 目錄輸入以下命令，啟動服務器：
python manage.py runserver 0.0.0.0:8000
0.0.0.0讓其它電腦可連接到開發服務器，8000為端口號。如果不說明，那么端口號默認為8000。
在瀏覽器輸入你服務器的ip及端口號，如果正常啟動，輸出結果如下：
視圖和 URL 配置
在先前創建的 HelloWorld 目錄下的 HelloWorld 目錄新建一個 view.py 文件，並輸入代碼：
from django.http import HttpResponse def hello(request): return HttpResponse("Hello world ! ")
接着，綁定 URL 與視圖函數。打開 urls.py 文件，刪除原來代碼，將以下代碼復制粘貼到 urls.py 文件中：
from django.conf.urls import * from HelloWorld.view import hello urlpatterns = patterns("", ('^hello/$', hello), )
整個目錄結構如下：
[root@solar HelloWorld]# tree . |-- HelloWorld | |-- __init__.py | |-- __init__.pyc | |-- settings.py | |-- settings.pyc | |-- urls.py # url 配置 | |-- urls.pyc | |-- view.py # 添加的視圖文件 | |-- view.pyc # 編譯后的視圖文件 | |-- wsgi.py | `-- wsgi.pyc `-- manage.py
完成后，啟動 Django 開發服務器，並在瀏覽器訪問打開瀏覽器並訪問：
Django 模板
在上一章節中我們使用 django.http.HttpResponse() 來輸出"Hello World！"。該方式將數據與視圖混合在一起，不符合Django的MVC思想。
本章節我們將為大家詳細介紹 Django 模板的應用，模板是一個文本，用於分離文檔的表現形式和內容。
模板應用實例
我們接着上一章節的項目將在 HelloWorld 目錄底下創建 templates 目錄並建立 hello.html文件，整個目錄結構如下：
HelloWorld/ |-- HelloWorld | |-- __init__.py | |-- __init__.pyc | |-- settings.py | |-- settings.pyc | |-- urls.py | |-- urls.pyc | |-- view.py | |-- view.pyc | |-- wsgi.py | `-- wsgi.pyc |-- manage.py `-- templates `-- hello.html
hello.html 文件代碼如下：
<h1>{{ hello }}</h1>
從模板中我們知道變量使用了雙括號。
接下來我們需要向Django說明模板文件的路徑，修改HelloWorld/settings.py，修改 TEMPLATES 中的 DIRS 為[BASE_DIR+"/templates",]，如下所示:
TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [BASE_DIR+"/templates",], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ]
我們現在修改 view.py，增加一個新的對象，用於向模板提交數據：
# -*- coding: utf-8 -*- #from django.http import HttpResponse from django.shortcuts import render def hello(request): context = {} context['hello'] = 'Hello World!' return render(request, 'hello.html', context)
可以看到，我們這里使用render來替代之前使用的HttpResponse。render還使用了一個字典context作為參數。
context 字典中元素的鍵值 "hello" 對應了模板中的變量 "{{ hello }}"。
再訪問訪問http://192.168.45.3:8000/hello/，可以看到頁面：
這樣我們就完成了使用模板來輸出數據，從而實現數據與視圖分離。
接下來我們將具體介紹模板中常用的語法規則。
Django 模板標簽
if/else 標簽
基本語法格式如下：
{% if condition %} ... display {% endif %}
或者：
{% if condition1 %} ... display 1 {% elif condiiton2 %} ... display 2 {% else %} ... display 3 {% endif %}
根據條件判斷是否輸出。if/else 支持嵌套。
{% if %} 標簽接受 and ， or 或者 not 關鍵字來對多個變量做判斷 ，或者對變量取反（ not )，例如：
{% if athlete_list and coach_list %} athletes 和 coaches 變量都是可用的。 {% endif %}
for 標簽
{% for %} 允許我們在一個序列上迭代。
與Python的 for 語句的情形類似，循環語法是 for X in Y ，Y是要迭代的序列而X是在每一個特定的循環中使用的變量名稱。
每一次循環中，模板系統會渲染在 {% for %} 和 {% endfor %} 之間的所有內容。
例如，給定一個運動員列表 athlete_list 變量，我們可以使用下面的代碼來顯示這個列表：
<ul> {% for athlete in athlete_list %} <li>{{ athlete.name }}</li> {% endfor %} </ul>
給標簽增加一個 reversed 使得該列表被反向迭代：
{% for athlete in athlete_list reversed %} ... {% endfor %}
可以嵌套使用 {% for %} 標簽：
{% for athlete in athlete_list %} <h1>{{ athlete.name }}</h1> <ul> {% for sport in athlete.sports_played %} <li>{{ sport }}</li> {% endfor %} </ul> {% endfor %}
ifequal/ifnotequal 標簽
{% ifequal %} 標簽比較兩個值，當他們相等時，顯示在 {% ifequal %} 和 {% endifequal %} 之中所有的值。
下面的例子比較兩個模板變量 user 和 currentuser :
{% ifequal user currentuser %} <h1>Welcome!</h1> {% endifequal %}
和 {% if %} 類似， {% ifequal %} 支持可選的 {% else%} 標簽：8
{% ifequal section 'sitenews' %} <h1>Site News</h1> {% else %} <h1>No News Here</h1> {% endifequal %}
注釋標簽
Django 注釋使用 {# #}。
{# 這是一個注釋 #}
過濾器
模板過濾器可以在變量被顯示前修改它，過濾器使用管道字符，如下所示：
{{ name|lower }}
{{ name }} 變量被過濾器 lower 處理后，文檔大寫轉換文本為小寫。
過濾管道可以被* 套接* ，既是說，一個過濾器管道的輸出又可以作為下一個管道的輸入：
{{ my_list|first|upper }}
以上實例將第一個元素並將其轉化為大寫。
有些過濾器有參數。 過濾器的參數跟隨冒號之后並且總是以雙引號包含。 例如：
{{ bio|truncatewords:"30" }}
這個將顯示變量 bio 的前30個詞。
其他過濾器：
- addslashes : 添加反斜杠到任何反斜杠、單引號或者雙引號前面。
- date : 按指定的格式字符串參數格式化 date 或者 datetime 對象，實例：
{{ pub_date|date:"F j, Y" }} - length : 返回變量的長度。
include 標簽
{% include %} 標簽允許在模板中包含其它的模板的內容。
下面這兩個例子都包含了 nav.html 模板：
{% include "nav.html" %}
模板繼承
模板可以用繼承的方式來實現復用。
接下來我們先創建之前項目的 templates 目錄中添加 base.html 文件，代碼如下：
<html> <head> <title>Hello World!</title> </head> <body> <h1>Hello World!</h1> {% block mainbody %} <p>original</p> {% endblock %} </body> </html>
以上代碼中，名為mainbody的block標簽是可以被繼承者們替換掉的部分。
所有的 {% block %} 標簽告訴模板引擎，子模板可以重載這些部分。
hello.html中繼承base.html，並替換特定block，hello.html修改后的代碼如下：
{% extends "base.html" %} {% block mainbody %} <p>繼承了 base.html 文件</p> {% endblock %}
第一行代碼說明hello.html繼承了 base.html 文件。可以看到，這里相同名字的block標簽用以替換base.html的相應block。
重新訪問地址http://192.168.45.3:8000/hello/，輸出結果如下：
Django 模型
Django 對各種數據庫提供了很好的支持，包括：PostgreSQL、MySQL、SQLite、Oracle。
Django 為這些數據庫提供了統一的調用API。 我們可以根據自己業務需求選擇不同的數據庫。
MySQL 是 Web 應用中最常用的數據庫。本章節我們將以 Mysql 作為實例進行介紹。你可以通過本站的 MySQL 教程 了解更多Mysql的基礎知識。
數據庫配置
我們在項目的 settings.py 文件中找到 DATABASES 配置項，將其信息修改為：
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'test',
'USER': 'test',
'PASSWORD': 'test123',
'HOST':'localhost',
'PORT':'3306',
}
}
上面包含數據庫名稱和用戶的信息，它們與MySQL中對應數據庫和用戶的設置相同。Django根據這一設置，與MySQL中相應的數據庫和用戶連接起來。
定義模型
創建 APP
Django規定，如果要使用模型，必須要創建一個app。我們使用以下命令創建一個 TestModel 的 app:
python manage.py startapp TestModel
目錄結構如下：
HelloWorld |-- TestModel | |-- __init__.py | |-- admin.py | |-- models.py | |-- tests.py | `-- views.py
我們修改 TestModel/models.py文件，代碼如下：
# models.py
from django.db import models
class Test(models.Model):
name = models.CharField(max_length=20)
以上的類名代表了數據庫表名，且繼承了models.Model，類里面的字段代表數據表中的字段(name)，數據類型則由CharField（相當於varchar）、DateField（相當於datetime）， max_length 參數限定長度。
接下來在settings.py中找到INSTALLED_APPS這一項，如下：
INSTALLED_APPS = (
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'TestModel', # 添加此項
)
在命令行中運行python manage.py syncdb，看到幾行"Creating table…"的字樣，你的數據表就創建好了。
Creating tables ... …… Creating table TestModel_test #我們自定義的表 ……
表名組成結構為：app名_類名（如：TestModel_test）。
注意：盡管我們沒有在models給表設置主鍵，但是Django會自動添加一個id作為主鍵。
數據庫操作
接下來我們在 HelloWorld 目錄中添加 testdb.py 文件，並修改urls.py：
from django.conf.urls import *
from HelloWorld.view import hello
from HelloWorld.testdb import testdb
urlpatterns = patterns("",
('^hello/$', hello),
('^testdb/$', testdb),
)
添加數據
添加數據需要先創建對象，然后再執行 save 函數，相當於SQL中的INSERT：
# -*- coding: utf-8 -*-
from django.http import HttpResponse
from TestModel.models import Test
# 數據庫操作
def testdb(request):
test1 = Test(name='w3cschool.cc')
test1.save()
return HttpResponse("<p>數據添加成功！</p>")
訪問http://192.168.45.3:8000/testdb/ 就可以看到數據添加成功的提示。
獲取數據
Django提供了多種方式來獲取數據庫的內容，如下代碼所示：
# -*- coding: utf-8 -*-
from django.http import HttpResponse
from TestModel.models import Test
# 數據庫操作
def testdb(request):
# 初始化
response = ""
response1 = ""
# 通過objects這個模型管理器的all()獲得所有數據行，相當於SQL中的SELECT * FROM
list = Test.objects.all()
# filter相當於SQL中的WHERE，可設置條件過濾結果
response2 = Test.objects.filter(id=1)
# 獲取單個對象
response3 = Test.objects.get(id=1)
# 限制返回的數據 相當於 SQL 中的 OFFSET 0 LIMIT 2;
Test.objects.order_by('name')[0:2]
#數據排序
Test.objects.order_by("id")
# 上面的方法可以連鎖使用
Test.objects.filter(name="w3cschool.cc").order_by("id")
# 輸出所有數據
for var in list:
response1 += var.name + " "
response = response1
return HttpResponse("<p>" + response + "</p>")
輸出結果如下圖所示：
更新數據
修改數據可以使用 save() 或 update():
# -*- coding: utf-8 -*-
from django.http import HttpResponse
from TestModel.models import Test
# 數據庫操作
def testdb(request):
# 修改其中一個id=1的name字段，再save，相當於SQL中的UPDATE
test1 = Test.objects.get(id=1)
test1.name = 'w3cschool菜鳥教程'
test1.save()
# 另外一種方式
#Test.objects.filter(id=1).update(name='w3cschool菜鳥教程')
# 修改所有的列
# Test.objects.all().update(name='w3cschool菜鳥教程')
return HttpResponse("<p>修改成功</p>")
刪除數據
刪除數據庫中的對象只需調用該對象的delete()方法即可：
# -*- coding: utf-8 -*-
from django.http import HttpResponse
from TestModel.models import Test
# 數據庫操作
def testdb(request):
# 刪除id=1的數據
test1 = Test.objects.get(id=1)
test1.delete()
# 另外一種方式
# Test.objects.filter(id=1).delete()
# 刪除所有數據
# Test.objects.all().delete()
return HttpResponse("<p>刪除成功</p>")
Django 表單
HTML表單是網站交互性的經典方式。 本章將介紹如何用Django對用戶提交的表單數據進行處理。
HTTP 請求
HTTP協議以"請求－回復"的方式工作。客戶發送請求時，可以在請求中附加數據。服務器通過解析請求，就可以獲得客戶傳來的數據，並根據URL來提供特定的服務。
GET 方法
我們在之前的項目中創建一個 search.py 文件，用於接收用戶的請求：
# -*- coding: utf-8 -*-
from django.http import HttpResponse
from django.shortcuts import render_to_response
# 表單
def search_form(request):
return render_to_response('search_form.html')
# 接收請求數據
def search(request):
request.encoding='utf-8'
if 'q' in request.GET:
message = '你搜索的內容為: ' + request.GET['q'].encode('utf-8')
else:
message = '你提交了空表單'
return HttpResponse(message)
在模板目錄template中添加 search_form.html 表單：
<html>
<head>
<meta charset="utf-8" />
<title>Search - w3cschool.cc</title>
</head>
<body>
<form action="/search/" method="get">
<input type="text" name="q">
<input type="submit" value="Search">
</form>
</body>
</html>
urls.py 規則修改為如下形式：
from django.conf.urls import *
from HelloWorld.view import hello
from HelloWorld.testdb import testdb
from HelloWorld import search
urlpatterns = patterns("",
('^hello/$', hello),
('^testdb/$', testdb),
(r'^search-form/$', search.search_form),
(r'^search/$', search.search),
)
訪問地址：http://192.168.45.3:8000/search-form/並搜索，結果如下所示:
POST 方法
上面我們使用了GET方法。視圖顯示和請求處理分成兩個函數處理。
提交數據時更常用POST方法。我們下面使用該方法，並用一個URL和處理函數，同時顯示視圖和處理請求。
我們在tmplate 創建 post.html：
<html>
<head>
<meta charset="utf-8" />
<title>Search - w3cschool.cc</title>
</head>
<body>
<form action="/search-post/" method="post">
{% csrf_token %}
<input type="text" name="q">
<input type="submit" value="Submit">
</form>
<p>{{ rlt }}</p>
</body>
</html>
在模板的末尾，我們增加一個rlt記號，為表格處理結果預留位置。
表格后面還有一個{% csrf_token %}的標簽。csrf全稱是Cross Site Request Forgery。這是Django提供的防止偽裝提交請求的功能。POST方法提交的表格，必須有此標簽。
在HelloWorld目錄下新建 search2.py 文件並使用 search_post 函數來處理 POST 請求：
# -*- coding: utf-8 -*-
from django.shortcuts import render
from django.core.context_processors import csrf
# 接收POST請求數據
def search_post(request):
ctx ={}
ctx.update(csrf(request))
if request.POST:
ctx['rlt'] = request.POST['q']
return render(request, "post.html", ctx)
urls.py 規則修改為如下形式：
from django.conf.urls import *
from HelloWorld.view import hello
from HelloWorld.testdb import testdb
from HelloWorld import search
from HelloWorld import search2
urlpatterns = patterns("",
('^hello/$', hello),
('^testdb/$', testdb),
(r'^search-form/$', search.search_form),
(r'^search/$', search.search),
(r'^search-post/$', search2.search_post),
)
訪問 http://192.168.45.3:8000/search-post/ 顯示結果如下：
完成以上實例后，我們的目錄結構為：
HelloWorld
|-- HelloWorld
| |-- __init__.py
| |-- __init__.pyc
| |-- models.pyc
| |-- search.py
| |-- search.pyc
| |-- search2.py
| |-- search2.pyc
| |-- settings.py
| |-- settings.pyc
| |-- testdb.py
| |-- testdb.pyc
| |-- urls.py
| |-- urls.pyc
| |-- view.py
| |-- view.pyc
| |-- wsgi.py
| `-- wsgi.pyc
|-- TestModel
| |-- __init__.py
| |-- __init__.pyc
| |-- admin.py
| |-- models.py
| |-- models.pyc
| |-- tests.py
| `-- views.py
|-- manage.py
`-- templates
|-- base.html
|-- hello.html
|-- post.html
`-- search_form.html
3 directories, 29 files
Request 對象
每個view函數的第一個參數是一個HttpRequest對象，就像下面這個hello()函數:
from django.http import HttpResponse
def hello(request):
return HttpResponse("Hello world")
HttpRequest對象包含當前請求URL的一些信息：
| 屬性 |
描述 |
| path |
請求頁面的全路徑,不包括域名—例如, "/hello/"。 |
| method |
請求中使用的HTTP方法的字符串表示。全大寫表示。例如: if request.method == 'GET': |
| GET |
包含所有HTTP GET參數的類字典對象。參見QueryDict 文檔。 |
| POST |
包含所有HTTP POST參數的類字典對象。參見QueryDict 文檔。 服務器收到空的POST請求的情況也是有可能發生的。也就是說，表單form通過HTTP POST方法提交請求，但是表單中可以沒有數據。因此，不能使用語句if request.POST來判斷是否使用HTTP POST方法；應該使用if request.method == "POST" (參見本表的method屬性)。 注意: POST不包括file-upload信息。參見FILES屬性。 |
| REQUEST |
為了方便，該屬性是POST和GET屬性的集合體，但是有特殊性，先查找POST屬性，然后再查找GET屬性。借鑒PHP's $_REQUEST。 例如，如果GET = {"name": "john"} 和POST = {"age": '34'},則 REQUEST["name"] 的值是"john", REQUEST["age"]的值是"34". 強烈建議使用GET and POST,因為這兩個屬性更加顯式化，寫出的代碼也更易理解。 |
| COOKIES |
包含所有cookies的標准Python字典對象。Keys和values都是字符串。參見第12章，有關於cookies更詳細的講解。 |
| FILES |
包含所有上傳文件的類字典對象。FILES中的每個Key都是<input type="file" name="" />標簽中name屬性的值. FILES中的每個value 同時也是一個標准Python字典對象，包含下面三個Keys:
注意：只有在請求方法是POST，並且請求頁面中<form>有enctype="multipart/form-data"屬性時FILES才擁有數據。否則，FILES 是一個空字典。 |
| META |
包含所有可用HTTP頭部信息的字典。 例如:
META 中這些頭加上前綴HTTP_最為Key, 例如:
|
| user |
是一個django.contrib.auth.models.User 對象，代表當前登錄的用戶。 如果訪問用戶當前沒有登錄，user將被初始化為django.contrib.auth.models.AnonymousUser的實例。 你可以通過user的is_authenticated()方法來辨別用戶是否登錄：
if request.user.is_authenticated():
# Do something for logged-in users.
else:
# Do something for anonymous users.
只有激活Django中的AuthenticationMiddleware時該屬性才可用 |
| session |
唯一可讀寫的屬性，代表當前會話的字典對象。只有激活Django中的session支持時該屬性才可用。 參見第12章。 |
| raw_post_data |
原始HTTP POST數據，未解析過。 高級處理時會有用處。 |
Request對象也有一些有用的方法：
| 方法 | 描述 |
|---|---|
| __getitem__(key) | 返回GET/POST的鍵值,先取POST,后取GET。如果鍵不存在拋出 KeyError。 這是我們可以使用字典語法訪問HttpRequest對象。 例如,request["foo"]等同於先request.POST["foo"] 然后 request.GET["foo"]的操作。 |
| has_key() | 檢查request.GET or request.POST中是否包含參數指定的Key。 |
| get_full_path() | 返回包含查詢字符串的請求路徑。例如， "/music/bands/the_beatles/?print=true" |
| is_secure() | 如果請求是安全的，返回True，就是說，發出的是HTTPS請求。 |
QueryDict對象
在HttpRequest對象中, GET和POST屬性是django.http.QueryDict類的實例。
QueryDict類似字典的自定義類，用來處理單鍵對應多值的情況。
QueryDict實現所有標准的詞典方法。還包括一些特有的方法：
| 方法 | 描述 |
|---|---|
| __getitem__ |
和標准字典的處理有一點不同，就是，如果Key對應多個Value，__getitem__()返回最后一個value。 |
| __setitem__ |
設置參數指定key的value列表(一個Python list)。注意：它只能在一個mutable QueryDict 對象上被調用(就是通過copy()產生的一個QueryDict對象的拷貝). |
| get() |
如果key對應多個value，get()返回最后一個value。 |
| update() |
參數可以是QueryDict，也可以是標准字典。和標准字典的update方法不同，該方法添加字典 items，而不是替換它們: >>> q = QueryDict('a=1')
>>> q = q.copy() # to make it mutable
>>> q.update({'a': '2'})
>>> q.getlist('a')
['1', '2']
>>> q['a'] # returns the last
['2']
|
| items() |
和標准字典的items()方法有一點不同,該方法使用單值邏輯的__getitem__(): >>> q = QueryDict('a=1&a=2&a=3')
>>> q.items()
[('a', '3')]
|
| values() |
和標准字典的values()方法有一點不同,該方法使用單值邏輯的__getitem__(): |
此外, QueryDict也有一些方法，如下表：
| 方法 | 描述 |
|---|---|
| copy() |
返回對象的拷貝，內部實現是用Python標准庫的copy.deepcopy()。該拷貝是mutable(可更改的) — 就是說，可以更改該拷貝的值。 |
| getlist(key) |
返回和參數key對應的所有值，作為一個Python list返回。如果key不存在，則返回空list。 It's guaranteed to return a list of some sort.. |
| setlist(key,list_) |
設置key的值為list_ (unlike __setitem__()). |
| appendlist(key,item) |
添加item到和key關聯的內部list. |
| setlistdefault(key,list) |
和setdefault有一點不同，它接受list而不是單個value作為參數。 |
| lists() |
和items()有一點不同, 它會返回key的所有值，作為一個list, 例如: >>> q = QueryDict('a=1&a=2&a=3')
>>> q.lists()
[('a', ['1', '2', '3'])]
|
| urlencode() |
返回一個以查詢字符串格式進行格式化后的字符串(e.g., "a=2&b=3&b=5").
|
Django Admin 管理工具
Django 提供了基於 web 的管理工具。
Django自動管理工具是django.contrib的一部分。你可以在項目的 settings.py 中的INSTALLED_APPS看到它：
INSTALLED_APPS = (
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
)
django.contrib是一套龐大的功能集，它是Django基本代碼的組成部分。
激活管理工具
通常我們在生成項目時會在urls.py中自動設置好，我們只需去掉注釋即可。
配置項如下所示：
from django.contrib import admin
admin.autodiscover()
# And include this URLpattern...
urlpatterns = patterns('',
# ...
(r'^admin/', include(admin.site.urls)),
# ...
)
當這一切都配置好后，Django管理工具就可以運行了。
使用管理工具
啟動開發服務器，然后在瀏覽器中訪問：http://yoursite:8000/admin/，得到如下界面：
你可以通過命令 python manage.py createsuperuser 來創建超級用戶，如下所示：
# python manage.py createsuperuser Username (leave blank to use 'root'): admin Email address: admin@w3cschool.cc Password: Password (again): Superuser created successfully. [root@solar HelloWorld]#
之后輸入用戶名密碼登錄，界面如下：
為了讓admin界面管理某個數據模型，我們需要先注冊該數據模型到admin。比如，我們之前在 TestModel 中已經創建了模型 Test 。修改 TestModel/admin.py:
from django.contrib import admin from TestModel.models import Test # Register your models here. admin.site.register(Test)
刷新后即可看到 Testmodel 數據表:
復雜模型
管理頁面的功能強大，完全有能力處理更加復雜的數據模型。
先在 TestModel/models.py 中增加一個更復雜的數據模型：
from django.db import models
# Create your models here.
class Contact(models.Model):
name = models.CharField(max_length=200)
age = models.IntegerField(default=0)
email = models.EmailField()
def __unicode__(self):
return self.name
class Tag(models.Model):
contact = models.ForeignKey(Contact)
name = models.CharField(max_length=50)
def __unicode__(self):
return self.name
這里有兩個表。Tag以Contact為外部鍵。一個Contact可以對應多個Tag。
我們還可以看到許多在之前沒有見過的屬性類型，比如IntegerField用於存儲整數。
在 TestModel/admin.py 注冊多個模型並顯示：
from django.contrib import admin from TestModel.models import Test,Contact,Tag # Register your models here. admin.site.register([Test, Contact, Tag])
刷新管理頁面，顯示結果如下：
在以上管理工具我們就能進行復雜模型操作。
自定義表單
我們可以自定義管理頁面，來取代默認的頁面。比如上面的"add"頁面。我們想只顯示name和email部分。修改 TestModel/admin.py:
from django.contrib import admin
from TestModel.models import Test,Contact,Tag
# Register your models here.
class ContactAdmin(admin.ModelAdmin):
fields = ('name', 'email')
admin.site.register(Contact, ContactAdmin)
admin.site.register([Test, Tag])
以上代碼定義了一個ContactAdmin類，用以說明管理頁面的顯示格式。
里面的fields屬性定義了要顯示的字段。
由於該類對應的是Contact數據模型，我們在注冊的時候，需要將它們一起注冊。顯示效果如下：
我們還可以將輸入欄分塊，每個欄也可以定義自己的格式。修改TestModel/admin.py為：
from django.contrib import admin
from TestModel.models import Test,Contact,Tag
# Register your models here.
class ContactAdmin(admin.ModelAdmin):
fieldsets = (
['Main',{
'fields':('name','email'),
}],
['Advance',{
'classes': ('collapse',), # CSS
'fields': ('age',),
}]
)
admin.site.register(Contact, ContactAdmin)
admin.site.register([Test, Tag])
上面的欄目分為了Main和Advance兩部分。classes說明它所在的部分的CSS格式。這里讓Advance部分隱藏：
Advance部分旁邊有一個 Show 按鈕，用於展開，展開后可點擊 Hide 將其隱藏，如下圖所示：
內聯(Inline)顯示
上面的Contact是Tag的外部鍵，所以有外部參考的關系。
而在默認的頁面顯示中，將兩者分離開來，無法體現出兩者的從屬關系。我們可以使用內聯顯示，讓Tag附加在Contact的編輯頁面上顯示。
修改TestModel/admin.py：
from django.contrib import admin
from TestModel.models import Test,Contact,Tag
# Register your models here.
class TagInline(admin.TabularInline):
model = Tag
class ContactAdmin(admin.ModelAdmin):
inlines = [TagInline] # Inline
fieldsets = (
['Main',{
'fields':('name','email'),
}],
['Advance',{
'classes': ('collapse',),
'fields': ('age',),
}]
)
admin.site.register(Contact, ContactAdmin)
admin.site.register([Test])
顯示效果如下：
列表頁的顯示
在Contact輸入數條記錄后，Contact的列表頁看起來如下:
我們也可以自定義該頁面的顯示，比如在列表中顯示更多的欄目，只需要在ContactAdmin中增加list_display屬性:
from django.contrib import admin
from TestModel.models import Test,Contact,Tag
# Register your models here.
class ContactAdmin(admin.ModelAdmin):
list_display = ('name','age', 'email') # list
admin.site.register(Contact, ContactAdmin)
admin.site.register([Test, Tag])
刷新頁面顯示效果如下：
搜索功能在管理大量記錄時非常有，我們可以使用search_fields為該列表頁增加搜索欄：
from django.contrib import admin
from TestModel.models import Test,Contact,Tag
# Register your models here.
class ContactAdmin(admin.ModelAdmin):
list_display = ('name','age', 'email')
search_fields = ('name',)
admin.site.register(Contact, ContactAdmin)
admin.site.register([Test])
在本實例中我們搜索了 name 為 w3cschool.cc(本站域名) 的記錄，顯示結果如下：
Django Admin 管理工具還有非常多實用的功能，感興趣的同學可以深入研究下。
Django Nginx+uwsgi 安裝配置
在前面的章節中我們使用 python manage.py runserver 來運行服務器。這只適用測試環境中使用。
正式發布的服務，我們需要一個可以穩定而持續的服務器，比如apache, Nginx, lighttpd等，本文將以 Nginx 為例。
安裝基礎開發包
Centos 下安裝步驟如下：
yum groupinstall "Development tools" yum install zlib-devel bzip2-devel pcre-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel
CentOS 自帶 Python 2.4.3，但我們可以再安裝Python2.7.5：
cd ~ wget http://python.org/ftp/python/2.7.5/Python-2.7.5.tar.bz2 tar xvf Python-2.7.5.tar.bz2 cd Python-2.7.5 ./configure --prefix=/usr/local make && make altinstall
安裝Python包管理
easy_install包 https://pypi.python.org/pypi/distribute
安裝步驟:
cd ~ wget https://pypi.python.org/packages/source/d/distribute/distribute-0.6.49.tar.gz tar xf distribute-0.6.49.tar.gz cd distribute-0.6.49 python2.7 setup.py install easy_install --version
pip包: https://pypi.python.org/pypi/pip
安裝pip的好處是可以 pip list、pip uninstall 管理Python包， easy_install 沒有這個功能，只有uninstall
安裝uwsgi
uwsgi:https://pypi.python.org/pypi/uWSGI
uwsgi參數詳解：http://uwsgi-docs.readthedocs.org/en/latest/Options.html
pip install uwsgi uwsgi --version #查看 uwsgi 版本
測試uwsgi是否正常：
新建test.py文件，內容如下：
def application(env, start_response):
start_response('200 OK', [('Content-Type','text/html')])
return "Hello World"
然后在終端運行：
uwsgi --http :8001 --wsgi-file test.py
在瀏覽器內輸入：http://127.0.0.1:8001，查看是否有"Hello World"輸出，若沒有輸出，請檢查你的安裝過程。
安裝 Django
pip install django
測試django是否正常，運行：
django-admin.py startproject demosite cd demosite python2.7 manage.py runserver 0.0.0.0:8002
在瀏覽器內輸入：http://127.0.0.1:8002，檢查django是否運行正常。
安裝 Nginx
安裝命令如下：
cd ~ wget http://nginx.org/download/nginx-1.5.6.tar.gz tar xf nginx-1.5.6.tar.gz cd nginx-1.5.6 ./configure --prefix=/usr/local/nginx-1.5.6 \ --with-http_stub_status_module \ --with-http_gzip_static_module make && make install
你可以閱讀 Nginx 安裝配置 了解更多內容。
uwsgi 配置
uwsgi支持ini、xml等多種配置方式，本文以 ini 為例， 在/ect/目錄下新建uwsgi9090.ini，添加如下配置：
[uwsgi] socket = 127.0.0.1:9090 master = true //主進程 vhost = true //多站模式 no-site = true //多站模式時不設置入口模塊和文件 workers = 2 //子進程數 reload-mercy = 10 vacuum = true //退出、重啟時清理文件 max-requests = 1000 limit-as = 512 buffer-size = 30000 pidfile = /var/run/uwsgi9090.pid //pid文件，用於下面的腳本啟動、停止該進程 daemonize = /website/uwsgi9090.log
Nginx 配置
找到nginx的安裝目錄（如：/usr/local/nginx/），打開conf/nginx.conf文件，修改server配置：
server {
listen 80;
server_name localhost;
location / {
include uwsgi_params;
uwsgi_pass 127.0.0.1:9090; //必須和uwsgi中的設置一致
uwsgi_param UWSGI_SCRIPT demosite.wsgi; //入口文件，即wsgi.py相對於項目根目錄的位置，“.”相當於一層目錄
uwsgi_param UWSGI_CHDIR /demosite; //項目根目錄
index index.html index.htm;
client_max_body_size 35m;
}
}
你可以閱讀 Nginx 安裝配置 了解更多內容。
設置完成后，在終端運行：
uwsgi --ini /etc/uwsgi9090.ini & /usr/local/nginx/sbin/nginx
在瀏覽器輸入：http://127.0.0.1，你就可以看到django的"It work"了。