這篇文章主要介紹了在Django框架中運行Python應用全攻略,在這之前必須搭建好簡單的視圖和模版,接下來便是本文中所述的核心內容應用配置,需要的朋友可以參考下

我們來假定下面的這些概念、字段和關系：

一個作者有姓，有名及email地址。

出版商有名稱，地址，所在城市、省，國家，網站。

書籍有書名和出版日期。 它有一個或多個作者(和作者是多對多的關聯關系[many-to-many])， 只有一個出版商(和出版商是一對多的關聯關系[one-to-many]，也被稱作外鍵[foreign key])

第一步是用Python代碼來描述它們。 打開由`` startapp`` 命令創建的models.py 并輸入下面的內容：

1. from django.db import models 
2.  
3. class Publisher(models.Model): 
4. name = models.CharField(max_length=30) 
5. address = models.CharField(max_length=50) 
6. city = models.CharField(max_length=60) 
7. state_province = models.CharField(max_length=30) 
8. country = models.CharField(max_length=50) 
9. website = models.URLField() 
10.  
11. class Author(models.Model): 
12. first_name = models.CharField(max_length=30) 
13. last_name = models.CharField(max_length=40) 
14. email = models.EmailField() 
15.  
16. class Book(models.Model): 
17. title = models.CharField(max_length=100) 
18. authors = models.ManyToManyField(Author) 
19. publisher = models.ForeignKey(Publisher) 
20. publication_date = models.DateField() 

讓我們來快速講解一下這些代碼的含義。 首先要注意的事是每個數據模型都是 django.db.models.Model 的子類。它的父類 Model 包含了所有必要的和數據庫交互的方法，并提供了一個簡潔漂亮的定義數據庫字段的語法。 信不信由你，這些就是我們需要編寫的通過Django存取基本數據的所有代碼。

每個模型相當于單個數據庫表，每個屬性也是這個表中的一個字段。 屬性名就是字段名，它的類型(例如 CharField )相當于數據庫的字段類型 (例如 varchar )。例如， Publisher 模塊等同于下面這張表(用PostgreSQL的 CREATE TABLE 語法描述)：

1. CREATE TABLE "books_publisher" ( 
2. "id" serial NOT NULL PRIMARY KEY, 
3. "name" varchar(30) NOT NULL, 
4. "address" varchar(50) NOT NULL, 
5. "city" varchar(60) NOT NULL, 
6. "state_province" varchar(30) NOT NULL, 
7. "country" varchar(50) NOT NULL, 
8. "website" varchar(200) NOT NULL 
9. ); 

事實上，正如過一會兒我們所要展示的，Django 可以自動生成這些 CREATE TABLE 語句。

“每個數據庫表對應一個類”這條規則的例外情況是多對多關系。 在我們的范例模型中， Book 有一個 多對多字段 叫做 authors 。 該字段表明一本書籍有一個或多個作者，但 Book 數據庫表卻并沒有 authors 字段。 相反，Django創建了一個額外的表(多對多連接表)來處理書籍和作者之間的映射關系。

請查看附錄 B 了解所有的字段類型和模型語法選項。

最后需要注意的是，我們并沒有顯式地為這些模型定義任何主鍵。 除非你單獨指明，否則Django會自動為每個模型生成一個自增長的整數主鍵字段每個Django模型都要求有單獨的主鍵。

模型安裝

完成這些代碼之后，現在讓我們來在數據庫中創建這些表。 要完成該項工作，第一步是在 Django 項目中 激活 這些模型。 將 books app 添加到配置文件的已安裝應用列表中即可完成此步驟。

再次編輯 settings.py 文件， 找到 INSTALLED_APPS 設置。 INSTALLED_APPS 告訴 Django 項目哪些 app 處于激活狀態。 缺省情況下如下所示：

1. INSTALLED_APPS = ( 
2. 'django.contrib.auth', 
3. 'django.contrib.contenttypes', 
4. 'django.contrib.sessions', 
5. 'django.contrib.sites', 
6. ) 

把這四個設置前面加#臨時注釋起來。 (這四個app是經常使用到的，我們將在后續章節里討論如何使用它們)。同時，注釋掉MIDDLEWARE_CLASSES的默認設置條目，因為這些條目是依賴于剛才我們剛在INSTALLED_APPS注釋掉的apps。 然后，添加`` ‘mysite.books'`` 到`` INSTALLED_APPS`` 的末尾，此時設置的內容看起來應該是這樣的：

1. MIDDLEWARE_CLASSES = ( 
2. # 'django.middleware.common.CommonMiddleware', 
3. # 'django.contrib.sessions.middleware.SessionMiddleware', 
4. # 'django.contrib.auth.middleware.AuthenticationMiddleware', 
5. ) 
6.  
7. INSTALLED_APPS = ( 
8. # 'django.contrib.auth', 
9. # 'django.contrib.contenttypes', 
10. # 'django.contrib.sessions', 
11. # 'django.contrib.sites', 
12. 'mysite.books', 
13. ) 

(就像我們在上一章設置TEMPLATE_DIRS所提到的逗號，同樣在INSTALLED_APPS的末尾也需添加一個逗號，因為這是個單元素的元組。 另外，本書的作者喜歡在 每一個 tuple元素后面加一個逗號，不管它是不是 只有一個元素。 這是為了避免忘了加逗號，而且也沒什么壞處。)

'mysite.books'指示我們正在編寫的books app。 INSTALLED_APPS 中的每個app都使用 Python的路徑描述，包的路徑，用小數點“.”間隔。

現在我們可以創建數據庫表了。 首先，用下面的命令驗證模型的有效性：

1. python manage.py validate 

validate 命令檢查你的模型的語法和邏輯是否正確。 如果一切正常，你會看到 0 errors found 消息。如果出錯，請檢查你輸入的模型代碼。 錯誤輸出會給出非常有用的錯誤信息來幫助你修正你的模型。

一旦你覺得你的模型可能有問題，運行 python manage.py validate 。 它可以幫助你捕獲一些常見的模型定義錯誤。

模型確認沒問題了，運行下面的命令來生成 CREATE TABLE 語句(如果你使用的是Unix，那么可以啟用語法高亮)：

1. python manage.py sqlall books 

在這個命令行中， books 是app的名稱。 和你運行 manage.py startapp 中的一樣。執行之后，輸出如下：

1. BEGIN; 
2. CREATE TABLE "books_publisher" ( 
3. "id" serial NOT NULL PRIMARY KEY, 
4. "name" varchar(30) NOT NULL, 
5. "address" varchar(50) NOT NULL, 
6. "city" varchar(60) NOT NULL, 
7. "state_province" varchar(30) NOT NULL, 
8. "country" varchar(50) NOT NULL, 
9. "website" varchar(200) NOT NULL 
10. ) 
11. ; 
12. CREATE TABLE "books_author" ( 
13. "id" serial NOT NULL PRIMARY KEY, 
14. "first_name" varchar(30) NOT NULL, 
15. "last_name" varchar(40) NOT NULL, 
16. "email" varchar(75) NOT NULL 
17. ) 
18. ; 
19. CREATE TABLE "books_book" ( 
20. "id" serial NOT NULL PRIMARY KEY, 
21. "title" varchar(100) NOT NULL, 
22. "publisher_id" integer NOT NULL REFERENCES "books_publisher" ("id") DEFERRABLE INITIALLY DEFERRED, 
23. "publication_date" date NOT NULL 
24. ) 
25. ; 
26. CREATE TABLE "books_book_authors" ( 
27. "id" serial NOT NULL PRIMARY KEY, 
28. "book_id" integer NOT NULL REFERENCES "books_book" ("id") DEFERRABLE INITIALLY DEFERRED, 
29. "author_id" integer NOT NULL REFERENCES "books_author" ("id") DEFERRABLE INITIALLY DEFERRED, 
30. UNIQUE ("book_id", "author_id") 
31. ) 
32. ; 
33. CREATE INDEX "books_book_publisher_id" ON "books_book" ("publisher_id"); 
34. COMMIT; 

注意：

自動生成的表名是app名稱( books )和模型的小寫名稱 ( publisher , book , author )的組合。你可以參考附錄B重寫這個規則。

我們前面已經提到，Django為每個表格自動添加加了一個 id 主鍵， 你可以重新設置它。

按約定，Django添加 "_id" 后綴到外鍵字段名。 你猜對了，這個同樣是可以自定義的。

外鍵是用 REFERENCES 語句明確定義的。

這些 CREATE TABLE 語句會根據你的數據庫而作調整，這樣象數據庫特定的一些字段例如：(MySQL)，auto_increment(PostgreSQL),serial(SQLite)，都會自動生成。integer primary key 同樣的，字段名稱也是自動處理(例如單引號還好是雙引號)。 例子中的輸出是基于PostgreSQL語法的。

sqlall 命令并沒有在數據庫中真正創建數據表，只是把SQL語句段打印出來，這樣你可以看到Django究竟會做些什么。 如果你想這么做的話，你可以把那些SQL語句復制到你的數據庫客戶端執行，或者通過Unix管道直接進行操作(例如，`` python manager.py sqlall books | psql mydb`` )。不過，Django提供了一種更為簡易的提交SQL語句至數據庫的方法： `` syncdb`` 命令

1. python manage.py syncdb 

執行這個命令后，將看到類似以下的內容：

1. Creating table books_publisher 
2. Creating table books_author 
3. Creating table books_book 
4. Installing index for books.Book model 

syncdb 命令是同步你的模型到數據庫的一個簡單方法。 它會根據 INSTALLED_APPS 里設置的app來檢查數據庫， 如果表不存在，它就會創建它。 需要注意的是， syncdb 并 不能將模型的修改或刪除同步到數據庫;如果你修改或刪除了一個模型，并想把它提交到數據庫，syncdb并不會做出任何處理。 (更多內容請查看本章最后的“修改數據庫的架構”一段。)

如果你再次運行 python manage.py syncdb ，什么也沒發生，因為你沒有添加新的模型或者 添加新的app。因此，運行python manage.py syncdb總是安全的，因為它不會重復執行SQL語句。

如果你有興趣，花點時間用你的SQL客戶端登錄進數據庫服務器看看剛才Django創建的數據表。 你可以手動啟動命令行客戶端(例如，執行PostgreSQL的`` psql`` 命令)，也可以執行 `` python manage.py dbshell`` ，這個命令將依據`` DATABASE_SERVER`` 的里設置自動檢測使用哪種命令行客戶端。 常言說，后來者居上。

基本數據訪問

一旦你創建了模型，Django自動為這些模型提供了高級的Python API。 運行 python manage.py shell 并輸入下面的內容試試看：

1. >>> from books.models import Publisher 
2. >>> p1 = Publisher(name='Apress', address='2855 Telegraph Avenue', 
3. ... city='Berkeley', state_province='CA', country='U.S.A.', 
4. ... website='http://www.apress.com/') 
5. >>> p1.save() 
6. >>> p2 = Publisher(name="O'Reilly", address='10 Fawcett St.', 
7. ... city='Cambridge', state_province='MA', country='U.S.A.', 
8. ... website='http://www.oreilly.com/') 
9. >>> p2.save() 
10. >>> publisher_list = Publisher.objects.all() 
11. >>> publisher_list 
12. [<Publisher: Publisher object>, <Publisher: Publisher object>] 

這短短幾行代碼干了不少的事。 這里簡單的說一下：

首先，導入Publisher模型類， 通過這個類我們可以與包含 出版社 的數據表進行交互。

接著，創建一個`` Publisher`` 類的實例并設置了字段`` name, address`` 等的值。

調用該對象的 save() 方法，將對象保存到數據庫中。 Django 會在后臺執行一條 INSERT 語句。

最后，使用`` Publisher.objects`` 屬性從數據庫取出出版商的信息，這個屬性可以認為是包含出版商的記錄集。 這個屬性有許多方法， 這里先介紹調用`` Publisher.objects.all()`` 方法獲取數據庫中`` Publisher`` 類的所有對象。這個操作的幕后，Django執行了一條SQL `` SELECT`` 語句。

這里有一個值得注意的地方，在這個例子可能并未清晰地展示。 當你使用Django modle API創建對象時Django并未將對象保存至數據庫內，除非你調用`` save()`` 方法：

1. p1 = Publisher(...) 
2. # At this point, p1 is not saved to the database yet! 
3. p1.save() 
4. # Now it is. 

如果需要一步完成對象的創建與存儲至數據庫，就使用`` objects.create()`` 方法。 下面的例子與之前的例子等價：

1. >>> p1 = Publisher.objects.create(name='Apress', 
2. ... address='2855 Telegraph Avenue', 
3. ... city='Berkeley', state_province='CA', country='U.S.A.', 
4. ... website='http://www.apress.com/') 
5. >>> p2 = Publisher.objects.create(name="O'Reilly", 
6. ... address='10 Fawcett St.', city='Cambridge', 
7. ... state_province='MA', country='U.S.A.', 
8. ... website='http://www.oreilly.com/') 
9. >>> publisher_list = Publisher.objects.all() 
10. >>> publisher_list 

當然，你肯定想執行更多的Django數據庫API試試看，不過，還是讓我們先解決一點煩人的小問題。

添加模塊的字符串表現

當我們打印整個publisher列表時，我們沒有得到想要的有用信息，無法把````對象區分開來：

1. System Message: WARNING/2 (<string>, line 872); backlink 
2.  
3. Inline literal start-string without end-string. 
4.  
5. System Message: WARNING/2 (<string>, line 872); backlink 
6.  
7. Inline literal start-string without end-string. 
8.  
9. [<Publisher: Publisher object>, <Publisher: Publisher object>] 

我們可以簡單解決這個問題，只需要為Publisher 對象添加一個方法 __unicode__() 。 __unicode__() 方法告訴Python如何將對象以unicode的方式顯示出來。 為以上三個模型添加__unicode__()方法后，就可以看到效果了：

1. from django.db import models 
2.  
3. class Publisher(models.Model): 
4. name = models.CharField(max_length=30) 
5. address = models.CharField(max_length=50) 
6. city = models.CharField(max_length=60) 
7. state_province = models.CharField(max_length=30) 
8. country = models.CharField(max_length=50) 
9. website = models.URLField() 
10.  
11. **def __unicode__(self):** 
12. **return self.name** 
13.  
14. class Author(models.Model): 
15. first_name = models.CharField(max_length=30) 
16. last_name = models.CharField(max_length=40) 
17. email = models.EmailField() 
18.  
19. **def __unicode__(self):** 
20. **return u'%s %s' % (self.first_name, self.last_name)** 
21.  
22. class Book(models.Model): 
23. title = models.CharField(max_length=100) 
24. authors = models.ManyToManyField(Author) 
25. publisher = models.ForeignKey(Publisher) 
26. publication_date = models.DateField() 
27.  
28. **def __unicode__(self):** 
29. **return self.title** 

就象你看到的一樣， __unicode__() 方法可以進行任何處理來返回對一個對象的字符串表示。 Publisher和Book對象的__unicode__()方法簡單地返回各自的名稱和標題，Author對象的__unicode__()方法則稍微復雜一些，它將first_name和last_name字段值以空格連接后再返回。

對__unicode__()的唯一要求就是它要返回一個unicode對象 如果`` __unicode__()`` 方法未返回一個Unicode對象，而返回比如說一個整型數字，那么Python將拋出一個`` TypeError`` 錯誤，并提示：”coercing to Unicode: need string or buffer, int found” 。