Django框架之Model系統：ORM基本增刪改查操作（二）
1、創建模型
例：我們來假定下面這些概念，字段和關系
作者模型：一個作者有姓名和年齡。
作者詳細模型：把作者的詳情放到詳情表，包含生日，手機號，家庭住址等信息。作者詳情模型和作者模型之間是一對一（one-to-one）的關系。
出版社模型：出版社有名稱，所在城市以及email。
書籍模型： 書籍有書名和出版日期，一本書可能會有多個作者，一個作者也可以寫多本書，所以作者和書籍的關系就是多對多(many-to-many)的關聯關系; 一本書只應該由一個出版社出版，所以出版社和書籍是一對多(one-to-many)的關系。
模型建立如下代碼：
from django.db import models
# Create your models here.
class Author(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
age = models.IntegerField()
# 與AuthorDetail建立一對一的關系，author表自動加authorDetail_id字段
authorDetail = models.OneToOneField(to="AuthorDetail", on_delete=models.CASCADE)
class AuthorDetail(models.Model):
nid = models.AutoField(primary_key=True)
birthday = models.DateField()
telephone = models.CharField(max_length=32)
addr = models.CharField(max_length=64)
class Publish(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
city = models.CharField(max_length=32)
email = models.EmailField()
class Book(models.Model):
nid = models.AutoField(primary_key=True)
title = models.CharField(max_length=32)
publishDate = models.DateField()
price = models.DecimalField(max_digits=5, decimal_places=2)
# 與Publish建立一對多的關系,外鍵字段必須建立在多的一方，生成publish_id
publish = models.ForeignKey(to="Publish", to_field="nid", on_delete=models.CASCADE)
# 與Author表建立多對多的關系,ManyToManyField可以建在兩個模型中的任意一個，自動創建第三張表book_authors，且第三張表有book_id和author_id字段
authors = models.ManyToManyField(to=‘Author‘, )
註意事項：
1）表的名稱myapp_modelName，是根據模型中的元數據自動生成的，也可以覆寫為別的名稱；
2）id 字段是自動添加的；
3）對於外鍵字段，Django 會在字段名上添加"_id" 來創建數據庫中的列名；
4）這個例子中的CREATE TABLE SQL 語句使用PostgreSQL 語法格式，要註意的是Django 會根據settings 中指定的數據庫類型來使用相應的SQL 語句；
5）定義好模型之後，你需要告訴Django使用這些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中設置，在其中添加models.py所在應用的名稱；
6）外鍵字段 ForeignKey 有一個參數null=True的設置(它允許外鍵接受空值 NULL)，你可以賦給它空值 None；
2、添加表記錄
(1)、一對一
from book.models import Author,AuthorDetail
tel=‘110‘
addr=‘北京‘
name=‘felix‘
age=18
birthday=‘2018-10-10‘
# 先添加作者詳細信息
authorDetail_obj = AuthorDetail.objects.create(telephone=tel, addr=addr,birthday=birthday)
# 再添加作者，因為他依賴AuthorDetail表
Author.objects.create(
name=name,
age=age,
authorDetail=authorDetail_obj)
（2）、一對多（給關聯字段添加記錄）
from book.models import Publish, Book
publish_obj = Publish.objects.create(nid=1,name=‘felix‘,city=‘杭州‘)
book_obj = Book.objects.create(
title="python從入門到放棄",
publishDate="2012-12-12",
price=100,
publish_id=1, # 字段值賦給字段名
publish=publish_obj) # 對象賦值對象
（3）、多對多（核心是給第三張關系表添加記錄）
from book.models import Book, Author
# book_obj為當前生成的書籍對象
book_obj = Book.objects.create(
title="追風箏的人",
price=200,
publishDate="2012-11-12",
publish_id=1)
# 查詢出為書籍綁定的作者對象
felix = Author.objects.filter(name="felix").first() # 若felix在Author表主鍵是2
haha = Author.objects.filter(name="haha").first() # 若haha在Author表主鍵是1
# 因Book表與Author表綁定多對多關系,即向關系表book_authors中添加紀錄
book_obj.authors.add(felix, haha) # 將某些特定的 model 對象添加到被關聯對象集合
多對多關系的其他常用API
book_obj.authors.remove() # 將某個特定的對象從被關聯對象集合中去除
# book_obj.authors.remove(*[])
book_obj.authors.clear() # 清空被關聯對象集合
book_obj.authors.set() # 先清空再設置
例如：
from book.models import Author, Book
felix_obj = Author.objects.filter(name="felix").first()
book = Book.objects.filter(nid=2).first()
# 解除nid為2的書籍與作者felix的關系，
book.authors.remove(felix_obj) # 即刪除第三張表中書籍是2，作者是felix的記錄
# 假設已知felix的id為1 ，則可以直接根據id解除關系
book.authors.remove(1) # 即刪除第三張表中book_id是2，author_id是1的記錄
# 刪除nid=2的書籍的所有作者記錄
book.authors.clear() # 刪除book_id為2的所有記錄，不管author_id為多少
# 只為nid=2的作者綁定一個id為1的作者
book.authors.set(1) # 相當於先解除，即clear()，再綁定，即add(1)
3、查詢表記錄
（1）、查詢相關API
<1> all(): 查詢所有結果
<2> filter(**kwargs): 它包含了與所給篩選條件相匹配的對象
<3> get(**kwargs): 返回與所給篩選條件相匹配的對象，返回結果有且只有一個，
如果符合篩選條件的對象超過一個或者沒有都會拋出錯誤。
<5> exclude(**kwargs): 它包含了與所給篩選條件不匹配的對象
<4> values(*field): 返回一個ValueQuerySet——一個特殊的QuerySet，運行後得到的並不是一系列
model的實例化對象，而是一個可叠代的字典序列
<9> values_list(*field): 它與values()非常相似，它返回的是一個元組序列，values返回的是一個字典序列
<6> order_by(*field): 對查詢結果排序
<7> reverse(): 對查詢結果反向排序
<8> distinct(): 從返回結果中剔除重復紀錄
<10> count(): 返回數據庫中匹配查詢(QuerySet)的對象數量。
<11> first(): 返回第一條記錄
<12> last(): 返回最後一條記錄
<13> exists(): 如果QuerySet包含數據，就返回True，否則返回False
註意：一定區分object與querySet的區別 ！！！
（2）、正向查詢和反向查詢
由關聯字段所在的表去查詢非關聯字段所在的表，就是正向查詢，反之為反向查詢。例如：
① 一對多關系，“多”的一方創建關聯字段並通過ForeignKey方法建立關聯關系，即關聯字段所在的表（ForeignKey方法所在的表）去查詢另一個表時為正向查詢；反之為反向查詢。
② 多對多關系，任一方創建關聯字段並通過ManyToMany方法建立關聯關系，即關聯字段所在的表（ManyToMany方法所在的表）去查詢另一個表時為正向查詢；反之為反向查詢。
③ 一對一關系，任一方通過創建關聯字段並通過OneToOne方法建立關聯關系，即關聯字段所在的表（OneToOne方法所在的表）去查詢另一個表時為正向查詢；反之為反向查詢。
（3）、基於對象跨表查詢（會被翻譯成sql子查詢）
a、一對多查詢（Publish表和Book表，且Book表為關聯字段所在的表）
from book.models import Book,Publish
# 1、正向查詢（按字段：publish）（多查一）
# 查詢主鍵為1的書籍的出版社所在城市
book_obj = Book.objects.filter(pk=1).first()
publish_obj = book_obj.publish # 主鍵為1的書籍對象關聯的出版社對象
print(publish_obj.city)
# 2、反向查詢（按表名：book_set）（一查多）
# 查詢蘋果出版社出版的所有書籍名稱
publish = Publish.objects.get(name="哈哈出版社")
book_list = publish.book_set.all() # 與哈哈出版社關聯的所有書籍對象集合（QuerySet類型）
for book_obj in book_list:
print(book_obj.title)
b、多對多查詢（Author與Book）
from book.models import Book,Author
# 1、正向查詢（按字段：authors）
# 查詢金瓶眉這本書所有作者的名字以及手機號
book_obj = Book.objects.filter(title="python從入門到放棄")[0]
print(‘book_obj‘,book_obj.authors)
authors_list = book_obj.authors.all()
for author_obj in authors_list:
print(author_obj.name, author_obj.authorDetail.telephone)
# 2、反向查詢（按表名：book_set）
# 查詢felix寫的所有書籍的名字
author_obj = Author.objects.get(name="felix")
book_list = author_obj.book_set.all() # 與felix作者相關的所有書籍
for book_obj in book_list:
print(book_obj.title)
c、一對一查詢（Author與AuthorDetail）
from book.models import Author,AuthorDetail
# 1、正向查詢（按字段：authorDetail）
felix=Author.objects.filter(name=‘felix‘).first()
print(felix.authorDetail.telephone)
# 2、反向查詢（按表名：author）
authorDetail_list = AuthorDetail.objects.filter(addr="北京")
for obj in authorDetail_list:
print(obj.author.name)
註意：你可以通過在ForeignKey()和ManyToManyField()的定義中設置 related_name 的值來覆寫“表名_set”的名稱。例如，如果 Book表中做以下更改：
publish = models.ForeignKey(Publish, related_name=‘bookList‘, on_delete=models.CASCADE)
使用：
# 查詢人民出版社出版過的所有書籍
publish=Publish.objects.get(name="人民出版社")
book_list=publish.bookList.all() # 與人民出版社關聯的所有書籍對象集合
4、補充
（1）、ForeignKey(to="Publish", to_field="nid", on_delete=models.CASCADE)方法參數解釋
to="Publish"：表示跟Publish表建立一對多關系，也可以直接寫成"Publish"（需要帶引號，不帶引號則models.py中建立表時有順序要求，即關聯表Publish在前邊）； to_field="nid"：跟關聯表（這裏是Publish表）的哪個字段建立聯系，此參數不寫則默認跟主鍵字段建立聯系； on_delete=models.CASCADE：級聯刪除（即同步刪除，同步更新），Django1.11版本默認就是級聯刪除，可不寫，但2版本要求必須寫，否則報錯；
5、多表查詢
（1）、基於雙下劃線的跨表查詢
Django 還提供了一種直觀而高效的方式在查詢(lookups)中表示關聯關系，它能自動確認 SQL JOIN 聯系。要做跨關系查詢，就使用兩個下劃線來鏈接模型(model)間關聯字段的名稱，直到最終鏈接到你想要的model 為止。
語法：正向查詢按字段，反向查詢按表名小寫，用來告訴ORM引擎join哪張表。
a、一對多查詢
實例一：查詢哈哈出版社出版過的所有書籍的名字與價格
from book.models import Book, Publish
# 正向查詢 按字段：publish
result = Book.objects.filter(publish__name=‘哈哈出版社‘).values_list(‘title‘, ‘price‘)
print(‘result‘,result)
# 反向查詢 按表名小寫：book
result2 = Publish.objects.filter(‘哈哈出版社‘).values_list(‘book__title‘, ‘book__price‘)
print(‘result2‘,result2)
實例二：查詢python從入門到放棄這本書的出版社的名字和郵箱
# 正向查詢
Book.objects.filter(title="python").values("publish__name", "publish__email")
# 反向查詢
Publish.objects.filter(book__title="python").values("name", "email")
b、多對多查詢
實例一：查詢felix出過的所有書籍的名字
# 正向查詢 按字段：authors:
queryResult = Book.objects.filter(authors__name="felix").values_list("title")
# 反向查詢 按表名小寫：book
queryResult = Author.objects.filter(name="felix").values_list("book__title", "book__price")
實例二：查詢python從入門到放棄這本書的作者的年齡
# 正向查詢
Book.objects.filter(title="python").values("author__age")
# 反向查詢
Author.objects.filter(book__title="python").values("age")
c、一對一查詢
實例一：查詢felix的手機號
# 正向查詢 按字段：authorDetail
ret = Author.objects.filter(name="felix").values("authorDetail__telephone")
# 反向查詢 按表名小寫：author
ret = AuthorDetail.objects.filter(author__name="felix").values("telephone")
實例二：查詢手機號以110開頭的作者的名字
# 正向查詢
Author.objects.filter(authorDetail__telephone__startswith="110").values("name")
# 反向查詢
AuthorDetail.objects.filter(telephone__startswith="110").values("author__name")
d、連續跨表查詢
實例一：查詢哈哈出版社出版過的所有書籍的名字以及作者的姓名
# 正向查詢
queryResult=Book.objects.filter(publish__name="人民出版社").values_list("title","authors__name")
# 反向查詢
queryResult=Publish.objects.filter(name="人民出版社").values_list("book__title","book__authors__age","book__authors__name")
實例二：手機號以151開頭的作者出版過的所有書籍名稱以及出版社名稱
# 方式1： queryResult=Book.objects.filter(authors__authorDetail__telephone__startswith="151").values_list("title","publish__name")
# 方式2： ret=Author.objects.filter(authorDetail__telephone__startswith="151").values("book__title","book__publish__name")
e、related_name相關
反向查詢時，如果定義了related_name ，則用related_name的值替換表名，例如：
publish = ForeignKey(Blog, related_name=‘bookList‘)
實例一：查詢哈哈出版社出版過的所有書籍的名字與價格（一對多）
# 反向查詢 不再按表名：book，而是related_name的值bookList
queryResult=Publish.objects.filter(name="人民出版社").values_list("bookList__title","bookList__price")
6、聚合查詢
語法：aggregate(*args, **kwargs)
示例一：計算所有圖書的平均價格
from django.db.models import Avg # 首先導入聚合函數Avg
ret = Book.objects.all().aggregate(Avg(‘price‘))
print(ret) # 結果為：{‘price__avg‘: 34.35}
aggregate()是QuerySet 的一個終止子句，意思是說，它返回一個包含一些鍵值對的字典。鍵的名稱是聚合值的標識符，值是計算出來的聚合值。鍵的名稱是按照字段和聚合函數的名稱自動生成出來的。如果你想要為聚合值指定一個名稱，可以向聚合子句提供它。並且all()方法也可以不寫，默認查詢所有，如下示例：
ret = Book.objects.aggregate(average_price=Avg(‘price‘))
print(ret) # 結果為：{‘average_price‘: 34.35}
如果你希望生成不止一個聚合函數，你可以向aggregate()子句中添加另一個參數。所以，如果你也想知道所有圖書價格的最大值和最小值，可以這樣查詢：
from django.db.models import Avg, Max, Min # 導入聚合函數
ret = Book.objects.aggregate(Avg(‘price‘), Max(‘price‘), Min(‘price‘))
print(ret)
# 結果為：{‘price__avg‘: 34.35, ‘price__max‘: Decimal(‘81.20‘), ‘price__min‘: Decimal(‘12.99‘)}
7、分組查詢
a、單表分組查詢
實例一：查詢每一個部門名稱以及對應的員工數，員工表如下：
emp表：
id name age salary dep
1 felix 12 2000 銷售部
2 haha 22 3000 人事部
3 hehe 22 5000 人事部
SQL語句：select dep,Count(*) from emp group by dep;
ORM：emp.objects.values("dep").annotate(c=Count("id")
b、多表分組查詢
實例一：查詢每一個部門名稱以及對應的員工數，表如下：
emp表：
id name age salary dep_id
1 felix 12 2000 1
2 haha 22 3000 2
3 hehe 22 5000 2
dep表：
id name
1 銷售部
2 人事部
emp－dep：
id name age salary dep_id id name
1 felix 12 2000 1 1 銷售部
2 haha 22 3000 2 2 人事部
3 hehe 22 5000 2 2 人事部
SQL語句：select dep.name,Count(*) from emp left join dep on emp.dep_id=dep.id group by dep.id;
ORM：dep.objetcs.values("id").annotate(c=Count("emp")).values("name","c")
總結：
1）annotate()為調用的QuerySet中每一個對象都生成一個獨立的統計值（統計方法用聚合函數）。
2）跨表分組查詢本質就是將關聯表join成一張表，再按單表的思路進行分組查詢。
c、查詢實例
示例一：統計每一個出版社的最便宜的書
publishList = Publish.objects.annotate(MinPrice=Min("book__price"))
for publish_obj in publishList:
print(publish_obj.name,publish_obj.MinPrice)
annotate的返回值是querySet，如果不想遍歷對象，可以用上value_list()方法，如下：
queryResult = Publish.objects.annotate(MinPrice=Min("book__price")).values_list("name","MinPrice")
print(queryResult)
示例二：統計每一本書的作者個數
ret = Book.objects.annotate(authorsNum=Count(‘authors__name‘))
示例三：統計每一本以py開頭的書籍的作者個數
queryResult = Book.objects.filter(title__startswith="Py").annotate(num_authors=Count(‘authors‘))
示例四：統計不止一個作者的圖書
queryResult = Book.objects.annotate(num_authors=Count(‘authors‘)).filter(num_authors__gt=1)
示例五：根據一本圖書作者數量的多少對查詢集 QuerySet進行排序
queryResult = Book.objects.annotate(num_authors=Count(‘authors‘)).order_by(‘num_authors‘)
示例六：查詢各個作者出的書的總價格
# 按author表的所有字段 group by
queryResult = Author.objects.annotate(SumPrice=Sum("book__price")).values_list("name","SumPrice")
print(queryResult)
8、F查詢
在上面所有的例子中，我們構造的過濾器都只是將字段值與某個常量做比較。如果我們要對兩個字段的值做比較，那該怎麽做呢？
Django 提供 F() 來做這樣的比較。F()的實例可以在查詢中引用字段，來比較同一個 model 實例中兩個不同字段的值。
示例一：查詢評論數大於收藏數的書籍
from django.db.models import F # 導入F函數
Book.objects.filter(commnetNum__lt=F(‘keepNum‘))
Django 支持 F() 對象之間以及 F() 對象和常數之間的加減乘除和取模的操作，如下：
示例二：查詢評論數大於收藏數2倍的書籍
Book.objects.filter(commnetNum__lt=F(‘keepNum‘)*2)
示例三：修改操作也可以使用F函數，比如將每一本書的價格提高30元
Book.objects.all().update(price=F("price")+30)
9、Q查詢
filter()等方法中的關鍵字參數查詢都是一起進行“AND”的。如果你需要執行更復雜的查詢（例如OR 語句），你可以使用Q 對象。
from django.db.models import Q # 導入Q函數
Q(title__startswith=‘Py‘) # 將要關鍵字查詢條件放入Q方法中
Q 對象可以使用&和|操作符組合起來。當一個操作符在兩個Q對象上使用時，它產生一個新的Q 對象。
示例一：
bookList=Book.objects.filter(Q(authors__name="felix")|Q(authors__name="haha"))
# 上面等同於下面的SQL WHERE子句：
WHERE name ="felix" OR name ="haha"
示例二：你可以組合“&”和“|”操作符以及使用括號進行分組來編寫任意復雜的Q 對象。同時，Q 對象可以使用“~”操作符取反，這允許組合正常的查詢和取反(NOT) 查詢：
booklist = Book.objects.filter(Q(authors__name="felix") & ~Q(publishDate__year=2017)).values_list("title")
示例三：查詢函數可以混合使用Q 對象和關鍵字參數。所有提供給查詢函數的參數（關鍵字參數或Q 對象）都將"AND”在一起。但是，如果出現Q 對象，它必須位於所有關鍵字參數的前面。例如：
booklist = Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),title__icontains="python")
10、其他
靜態文件設置：
1）在項目目錄下創建static文件夾；
2）項目中用到的靜態資源如圖片，js文件，bootstrap文件等放到static中（static中再分別創建img、js、bootstrap、css文件夾用於存放這些文件）；
3）在項目的settings.py文件中，STATIC_URL = "/static/" 下邊加上如下代碼：
STATICFILES_URLS = [
os.join.path(BASE_DIR, "static")
]
五、修改表記錄
Publisher.objects.filter(id=2).update(name=‘American publisher‘)
註意：
<1> 第二種方式修改不能用get的原因是：update是QuerySet對象的方法，get返回的是一個model對象，它沒有update方法，而filter返回的是一個QuerySet對象(filter裏面的條件可能有多個條件符合，比如name＝‘alvin‘,可能有兩個name＝‘alvin‘的行數據)。
<2> 在“插入和更新數據”小節中，我們有提到模型的save()方法，這個方法會更新一行裏的所有列。 而某些情況下，我們只需要更新行裏的某幾列。
此外，update()方法對於任何結果集（QuerySet）均有效，這意味著你可以同時更新多條記錄update()方法會返回一個整型數值，表示受影響的記錄條數。
註意，這裏因為update返回的是一個整形，所以沒法用query屬性；對於每次創建一個對象，想顯示對應的raw sql，需要在settings加上日誌記錄部分
六、刪除表記錄
刪除方法就是 delete()。它運行時立即刪除對象而不返回任何值。例如：
Publisher.objects.filter(id=2).update(name=‘American publisher‘)
你也可以一次性刪除多個對象。每個 QuerySet 都有一個 delete() 方法，它一次性刪除 QuerySet 中所有的對象。
例如，下面的代碼將刪除 pub_date 是2005年的 Entry 對象：
Entry.objects.filter(pub_date__year=2005).delete()
要牢記這一點：無論在什麽情況下，QuerySet 中的 delete() 方法都只使用一條 SQL 語句一次性刪除所有對象，而並不是分別刪除每個對象。如果你想使用在 model 中自定義的 delete() 方法，就要自行調用每個對象的delete 方法。(例如，遍歷 QuerySet，在每個對象上調用 delete()方法)，而不是使用 QuerySet 中的 delete()方法。
在 Django 刪除對象時，會模仿 SQL 約束 ON DELETE CASCADE 的行為，換句話說，刪除一個對象時也會刪除與它相關聯的外鍵對象。例如：
b = Blog.objects.get(pk=1) # This will delete the Blog and all of its Entry objects. b.delete()
要註意的是： delete() 方法是 QuerySet 上的方法，但並不適用於 Manager 本身。這是一種保護機制，是為了避免意外地調用 Entry.objects.delete() 方法導致 所有的 記錄被誤刪除。如果你確認要刪除所有的對象，那麽你必須顯式地調用：
| 1 |
Entry.objects.all().delete()
|
如果不想級聯刪除，可以設置為：
| 1 |
pubHouse = models.ForeignKey(to=‘Publisher‘, on_delete=models.SET_NULL, blank=Tru
|
Django框架之Model系統：ORM基本增刪改查操作（二）