ORM(對象關系映射)
用於實現面向對象編程語言里不同類型系統的數據之間的轉換，換言之，就是用面向對象的方式去操作數據庫的創建表以及增刪改查等操作。
優點： 1 ORM使得我們的通用數據庫交互變得簡單易行，而且完全不用考慮該死的SQL語句。快速開發，由此而來。
2 可以避免一些新手程序猿寫sql語句帶來的性能問題。
比如 我們查詢User表中的所有字段:
新手可能會用select ＊ from auth_user,這樣會因為多了一個匹配動作而影響效率的。
缺點：1 性能有所犧牲，不過現在的各種ORM框架都在嘗試各種方法，比如緩存，延遲加載登來減輕這個問題。效果很顯著。
2 對於個別復雜查詢，ORM仍然力不從心，為了解決這個問題，ORM一般也支持寫raw sql。
3 通過QuerySet的query屬性查詢對應操作的sql語句
|
1
2
|
author_obj=models.Author.objects.filter(id=2)
print(author_obj.query)
|
下面要開始學習Django ORM語法了，為了更好的理解，我們來做一個基本的 書籍/作者/出版商 數據庫結構。 我們這樣做是因為 這是一個眾所周知的例子，很多SQL有關的書籍也常用這個舉例。
表(模型)的創建：
實例：我們來假定下面這些概念，字段和關系
作者模型：一個作者有姓名。
作者詳細模型：把作者的詳情放到詳情表，包含性別，email地址和出生日期，作者詳情模型和作者模型之間是一對一的關系（one－to－one）（類似於每個人和他的身份證之間的關系），在大多數情況下我們沒有必要將他們拆分成兩張表，這里只是引出一對一的概念。
出版商模型：出版商有名稱，地址，所在城市，省，國家和網站。
書籍模型：書籍有書名和出版日期，一本書可能會有多個作者，一個作者也可以寫多本書，所以作者和書籍的關系就是多對多的關聯關系（many－to－many），一本書只應該由一個出版商出版，所以出版商和書籍是一對多關聯關系（one－to－many），也被稱作外鍵。
from django.db import models<br> class Publisher(models.Model): name = models.CharField(max_length=30, verbose_name="名稱") address = models.CharField("地址", max_length=50) city = models.CharField('城市',max_length=60) state_province = models.CharField(max_length=30) country = models.CharField(max_length=50) website = models.URLField() class Meta: verbose_name = '出版商' verbose_name_plural = verbose_name def __str__(self): return self.name class Author(models.Model): name = models.CharField(max_length=30) def __str__(self): return self.name class AuthorDetail(models.Model): sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),)) email = models.EmailField() address = models.CharField(max_length=50) birthday = models.DateField() author = models.OneToOneField(Author) class Book(models.Model): title = models.CharField(max_length=100) authors = models.ManyToManyField(Author) publisher = models.ForeignKey(Publisher) publication_date = models.DateField() price=models.DecimalField(max_digits=5,decimal_places=2,default=10) def __str__(self): return self.title
注意1：記得在settings里的INSTALLED_APPS中加入'app01',然后再同步數據庫。
注意2: models.ForeignKey("Publish") & models.ForeignKey(Publish)
分析代碼：
<1> 每個數據模型都是django.db.models.Model的子類，它的父類Model包含了所有必要的和數據庫交互的方法。並提供了一個簡介漂亮的定義數據庫字段的語法。
<2> 每個模型相當於單個數據庫表（多對多關系例外，會多生成一張關系表），每個屬性也是這個表中的字段。屬性名就是字段名，它的類型（例如CharField）相當於數據庫的字段類型（例如varchar）。大家可以留意下其它的類型都和數據庫里的什么字段對應。
<3> 模型之間的三種關系：一對一，一對多，多對多。
一對一：實質就是在主外鍵（author_id就是foreign key）的關系基礎上，給外鍵加了一個UNIQUE＝True的屬性；
一對多：就是主外鍵關系；（foreign key）
多對多：(ManyToManyField) 自動創建第三張表(當然我們也可以自己創建第三張表：兩個foreign key)
<4> 模型常用的字段類型參數
<1> CharField #字符串字段, 用於較短的字符串. #CharField 要求必須有一個參數 maxlength, 用於從數據庫層和Django校驗層限制該字段所允許的最大字符數. <2> IntegerField #用於保存一個整數. <3> FloatField # 一個浮點數. 必須 提供兩個參數: # # 參數 描述 # max_digits 總位數(不包括小數點和符號) # decimal_places 小數位數 # 舉例來說, 要保存最大值為 999 (小數點后保存2位),你要這樣定義字段: # # models.FloatField(..., max_digits=5, decimal_places=2) # 要保存最大值一百萬(小數點后保存10位)的話,你要這樣定義: # # models.FloatField(..., max_digits=19, decimal_places=10) # admin 用一個文本框(<input type="text">)表示該字段保存的數據. <4> AutoField # 一個 IntegerField, 添加記錄時它會自動增長. 你通常不需要直接使用這個字段; # 自定義一個主鍵：my_id=models.AutoField(primary_key=True) # 如果你不指定主鍵的話,系統會自動添加一個主鍵字段到你的 model. <5> BooleanField # A true/false field. admin 用 checkbox 來表示此類字段. <6> TextField # 一個容量很大的文本字段. # admin 用一個 <textarea> (文本區域)表示該字段數據.(一個多行編輯框). <7> EmailField # 一個帶有檢查Email合法性的 CharField,不接受 maxlength 參數. <8> DateField # 一個日期字段. 共有下列額外的可選參數: # Argument 描述 # auto_now 當對象被保存時,自動將該字段的值設置為當前時間.通常用於表示 "last-modified" 時間戳. # auto_now_add 當對象首次被創建時,自動將該字段的值設置為當前時間.通常用於表示對象創建時間. #（僅僅在admin中有意義...) <9> DateTimeField # 一個日期時間字段. 類似 DateField 支持同樣的附加選項. <10> ImageField # 類似 FileField, 不過要校驗上傳對象是否是一個合法圖片.#它有兩個可選參數:height_field和width_field, # 如果提供這兩個參數,則圖片將按提供的高度和寬度規格保存. <11> FileField # 一個文件上傳字段. #要求一個必須有的參數: upload_to, 一個用於保存上載文件的本地文件系統路徑. 這個路徑必須包含 strftime #formatting, #該格式將被上載文件的 date/time #替換(so that uploaded files don't fill up the given directory). # admin 用一個<input type="file">部件表示該字段保存的數據(一個文件上傳部件) . #注意：在一個 model 中使用 FileField 或 ImageField 需要以下步驟: #（1）在你的 settings 文件中, 定義一個完整路徑給 MEDIA_ROOT 以便讓 Django在此處保存上傳文件. # (出於性能考慮,這些文件並不保存到數據庫.) 定義MEDIA_URL 作為該目錄的公共 URL. 要確保該目錄對 # WEB服務器用戶帳號是可寫的. #（2） 在你的 model 中添加 FileField 或 ImageField, 並確保定義了 upload_to 選項,以告訴 Django # 使用 MEDIA_ROOT 的哪個子目錄保存上傳文件.你的數據庫中要保存的只是文件的路徑(相對於 MEDIA_ROOT). # 出於習慣你一定很想使用 Django 提供的 get_<#fieldname>_url 函數.舉例來說,如果你的 ImageField # 叫作 mug_shot, 你就可以在模板中以 {{ object.#get_mug_shot_url }} 這樣的方式得到圖像的絕對路徑. <12> URLField # 用於保存 URL. 若 verify_exists 參數為 True (默認), 給定的 URL 會預先檢查是否存在( 即URL是否被有效裝入且 # 沒有返回404響應). # admin 用一個 <input type="text"> 文本框表示該字段保存的數據(一個單行編輯框) <13> NullBooleanField # 類似 BooleanField, 不過允許 NULL 作為其中一個選項. 推薦使用這個字段而不要用 BooleanField 加 null=True 選項 # admin 用一個選擇框 <select> (三個可選擇的值: "Unknown", "Yes" 和 "No" ) 來表示這種字段數據. <14> SlugField # "Slug" 是一個報紙術語. slug 是某個東西的小小標記(短簽), 只包含字母,數字,下划線和連字符.#它們通常用於URLs # 若你使用 Django 開發版本,你可以指定 maxlength. 若 maxlength 未指定, Django 會使用默認長度: 50. #在 # 以前的 Django 版本,沒有任何辦法改變50 這個長度. # 這暗示了 db_index=True. # 它接受一個額外的參數: prepopulate_from, which is a list of fields from which to auto-#populate # the slug, via JavaScript,in the object's admin form: models.SlugField # (prepopulate_from=("pre_name", "name"))prepopulate_from 不接受 DateTimeFields. <13> XMLField #一個校驗值是否為合法XML的 TextField,必須提供參數: schema_path, 它是一個用來校驗文本的 RelaxNG schema #的文件系統路徑. <14> FilePathField # 可選項目為某個特定目錄下的文件名. 支持三個特殊的參數, 其中第一個是必須提供的. # 參數 描述 # path 必需參數. 一個目錄的絕對文件系統路徑. FilePathField 據此得到可選項目. # Example: "/home/images". # match 可選參數. 一個正則表達式, 作為一個字符串, FilePathField 將使用它過濾文件名. # 注意這個正則表達式只會應用到 base filename 而不是 # 路徑全名. Example: "foo.*\.txt^", 將匹配文件 foo23.txt 卻不匹配 bar.txt 或 foo23.gif. # recursive可選參數.要么 True 要么 False. 默認值是 False. 是否包括 path 下面的全部子目錄. # 這三個參數可以同時使用. # match 僅應用於 base filename, 而不是路徑全名. 那么,這個例子: # FilePathField(path="/home/images", match="foo.*", recursive=True) # ...會匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif <15> IPAddressField # 一個字符串形式的 IP 地址, (i.e. "24.124.1.30"). <16># CommaSeparatedIntegerField # 用於存放逗號分隔的整數值. 類似 CharField, 必須要有maxlength參數.
<5> Field重要參數
<1> null ： 數據庫中字段是否可以為空 <2> blank： django的 Admin 中添加數據時是否可允許空值 <3> default：設定缺省值 <4> editable：如果為假，admin模式下將不能改寫。缺省為真 <5> primary_key：設置主鍵，如果沒有設置django創建表時會自動加上： id = meta.AutoField('ID', primary_key=True) primary_key=True implies blank=False, null=False and unique=True. Only one primary key is allowed on an object. <6> unique：數據唯一 <7> verbose_name Admin中字段的顯示名稱 <8> validator_list：有效性檢查。非有效產生 django.core.validators.ValidationError 錯誤 <9> db_column，db_index 如果為真將為此字段創建索引 <10>choices：一個用來選擇值的2維元組。第一個值是實際存儲的值，第二個用來方便進行選擇。 如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),) gender = models.CharField(max_length=2,choices = SEX_CHOICES)
表的操作(增刪改查)：
-------------------------------------增(create , save) -------------------------------
from app01.models import * #create方式一: Author.objects.create(name='Alvin') #create方式二: Author.objects.create(**{"name":"alex"}) #save方式一: author=Author(name="alvin") author.save() #save方式二: author=Author() author.name="alvin" author.save()
重點來了－－－－－－－>那么如何創建存在一對多或多對多關系的一本書的信息呢？(如何處理外鍵關系的字段如一對多的publisher和多對多的authors)
#一對多(ForeignKey): #方式一: 由於綁定一對多的字段,比如publish,存到數據庫中的字段名叫publish_id,所以我們可以直接給這個 # 字段設定對應值: Book.objects.create(title='php', publisher_id=2, #這里的2是指為該book對象綁定了Publisher表中id=2的行對象 publication_date='2017-7-7', price=99) #方式二: # <1> 先獲取要綁定的Publisher對象: pub_obj=Publisher(name='河大出版社',address='保定',city='保定', state_province='河北',country='China',website='http://www.hbu.com') OR pub_obj=Publisher.objects.get(id=1) # <2>將 publisher_id=2 改為 publisher=pub_obj #多對多(ManyToManyField()): author1=Author.objects.get(id=1) author2=Author.objects.filter(name='alvin')[0] book=Book.objects.get(id=1) book.authors.add(author1,author2) #等同於: book.authors.add(*[author1,author2]) book.authors.remove(*[author1,author2]) #------------------- book=models.Book.objects.filter(id__gt=1) authors=models.Author.objects.filter(id=1)[0] authors.book_set.add(*book) authors.book_set.remove(*book) #------------------- book.authors.add(1) book.authors.remove(1) authors.book_set.add(1) authors.book_set.remove(1) #注意: 如果第三張表是通過models.ManyToManyField()自動創建的,那么綁定關系只有上面一種方式 # 如果第三張表是自己創建的: class Book2Author(models.Model): author=models.ForeignKey("Author") Book= models.ForeignKey("Book") # 那么就還有一種方式: author_obj=models.Author.objects.filter(id=2)[0] book_obj =models.Book.objects.filter(id=3)[0] s=models.Book2Author.objects.create(author_id=1,Book_id=2) s.save() s=models.Book2Author(author=author_obj,Book_id=1) s.save()
-----------------------------------------刪（delete） ---------------------------------------------
>>> Book.objects.filter(id=1).delete()
(3, {'app01.Book_authors': 2, 'app01.Book': 1})
我們表面上刪除了一條信息，實際卻刪除了三條，因為我們刪除的這本書在Book_authors表中有兩條相關信息，這種刪除方式就是django默認的級聯刪除。
如果是多對多的關系： remove()和clear()方法：
#正向 book = models.Book.objects.filter(id=1) #刪除第三張表中和女孩1關聯的所有關聯信息 book.author.clear() #清空與book中id=1 關聯的所有數據 book.author.remove(2) #可以為id book.author.remove(*[1,2,3,4]) #可以為列表,前面加* #反向 author = models.Author.objects.filter(id=1) author.book_set.clear() #清空與boy中id=1 關聯的所有數據
-----------------------------------------改（update和save） ----------------------------------------
實例：
注意：
<1> 第二種方式修改不能用get的原因是：update是QuerySet對象的方法，get返回的是一個model對象，它沒有update方法，而filter返回的是一個QuerySet對象(filter里面的條件可能有多個條件符合，比如name＝'alvin',可能有兩個name＝'alvin'的行數據)。
<2>在“插入和更新數據”小節中，我們有提到模型的save()方法，這個方法會更新一行里的所有列。 而某些情況下，我們只需要更新行里的某幾列。
#---------------- update方法直接設定對應屬性---------------- models.Book.objects.filter(id=3).update(title="PHP") ##sql: ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3) #--------------- save方法會將所有屬性重新設定一遍,效率低----------- obj=models.Book.objects.filter(id=3)[0] obj.title="Python" obj.save() # SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", # "app01_book"."color", "app01_book"."page_num", # "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; # # UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556, # "publisher_id" = 1 WHERE "app01_book"."id" = 3;
在這個例子里我們可以看到Django的save()方法更新了不僅僅是title列的值，還有更新了所有的列。 若title以外的列有可能會被其他的進程所改動的情況下，只更改title列顯然是更加明智的。更改某一指定的列，我們可以調用結果集（QuerySet）對象的update()方法,與之等同的SQL語句變得更高效，並且不會引起競態條件。
此外，update()方法對於任何結果集（QuerySet）均有效，這意味着你可以同時更新多條記錄update()方法會返回一個整型數值，表示受影響的記錄條數。
注意，這里因為update返回的是一個整形，所以沒法用query屬性；對於每次創建一個對象，想顯示對應的raw sql，需要在settings加上日志記錄部分：
LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'console':{ 'level':'DEBUG', 'class':'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'propagate': True, 'level':'DEBUG', }, } } LOGGING
注意：如果是多對多的改：
obj=Book.objects.filter(id=1)[0]
author=Author.objects.filter(id__gt=2)
obj.author.clear()
obj.author.add(*author)
---------------------------------------查（filter，value等) -------------------------------------
---------->查詢API：
# 查詢相關API： # <1>filter(**kwargs): 它包含了與所給篩選條件相匹配的對象 # <2>all(): 查詢所有結果 # <3>get(**kwargs): 返回與所給篩選條件相匹配的對象，返回結果有且只有一個，如果符合篩選條件的對象超過一個或者沒有都會拋出錯誤。 #-----------下面的方法都是對查詢的結果再進行處理:比如 objects.filter.values()-------- # <4>values(*field): 返回一個ValueQuerySet——一個特殊的QuerySet，運行后得到的並不是一系列 model的實例化對象，而是一個可迭代的字典序列 # <5>exclude(**kwargs): 它包含了與所給篩選條件不匹配的對象 # <6>order_by(*field): 對查詢結果排序 # <7>reverse(): 對查詢結果反向排序 # <8>distinct(): 從返回結果中剔除重復紀錄 # <9>values_list(*field): 它與values()非常相似，它返回的是一個元組序列，values返回的是一個字典序列 # <10>count(): 返回數據庫中匹配查詢(QuerySet)的對象數量。 # <11>first(): 返回第一條記錄 # <12>last(): 返回最后一條記錄 # <13>exists(): 如果QuerySet包含數據，就返回True，否則返回False。
補充：
#擴展查詢,有時候DJANGO的查詢API不能方便的設置查詢條件，提供了另外的擴展查詢方法extra: #extra(select=None, where=None, params=None, tables=None,order_by=None, select_params=None (1) Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"}) (2) Blog.objects.extra( select=SortedDict([('a', '%s'), ('b', '%s')]), select_params=('one', 'two')) (3) q = Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"}) q = q.extra(order_by = ['-is_recent']) (4) Entry.objects.extra(where=['headline=%s'], params=['Lennon']) extra
---------->惰性機制：
所謂惰性機制：Publisher.objects.all()或者.filter()等都只是返回了一個QuerySet（查詢結果集對象），它並不會馬上執行sql，而是當調用QuerySet的時候才執行。
QuerySet特點：
<1> 可迭代的
<2> 可切片
#objs=models.Book.objects.all()#[obj1,obj2,ob3...] #QuerySet: 可迭代 # for obj in objs:#每一obj就是一個行對象 # print("obj:",obj) # QuerySet: 可切片 # print(objs[1]) # print(objs[1:4]) # print(objs[::-1])
QuerySet的高效使用：
<1>Django的queryset是惰性的 Django的queryset對應於數據庫的若干記錄（row），通過可選的查詢來過濾。例如，下面的代碼會得 到數據庫中名字為‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave") 上面的代碼並沒有運行任何的數據庫查詢。你可以使用person_set，給它加上一些過濾條件，或者將它傳給某個函數， 這些操作都不會發送給數據庫。這是對的，因為數據庫查詢是顯著影響web應用性能的因素之一。 <2>要真正從數據庫獲得數據，你可以遍歷queryset或者使用if queryset,總之你用到數據時就會執行sql. 為了驗證這些,需要在settings里加入 LOGGING(驗證方式) obj=models.Book.objects.filter(id=3) # for i in obj: # print(i) # if obj: # print("ok") <3>queryset是具有cache的 當你遍歷queryset時，所有匹配的記錄會從數據庫獲取，然后轉換成Django的model。這被稱為執行 （evaluation）.這些model會保存在queryset內置的cache中，這樣如果你再次遍歷這個queryset， 你不需要重復運行通用的查詢。 obj=models.Book.objects.filter(id=3) # for i in obj: # print(i) ## models.Book.objects.filter(id=3).update(title="GO") ## obj_new=models.Book.objects.filter(id=3) # for i in obj: # print(i) #LOGGING只會打印一次 <4> 簡單的使用if語句進行判斷也會完全執行整個queryset並且把數據放入cache，雖然你並不需要這些 數據！為了避免這個，可以用exists()方法來檢查是否有數據： obj = Book.objects.filter(id=4) # exists()的檢查可以避免數據放入queryset的cache。 if obj.exists(): print("hello world!") <5>當queryset非常巨大時，cache會成為問題 處理成千上萬的記錄時，將它們一次裝入內存是很浪費的。更糟糕的是，巨大的queryset可能會鎖住系統 進程，讓你的程序瀕臨崩潰。要避免在遍歷數據的同時產生queryset cache，可以使用iterator()方法 來獲取數據，處理完數據就將其丟棄。 objs = Book.objects.all().iterator() # iterator()可以一次只從數據庫獲取少量數據，這樣可以節省內存 for obj in objs: print(obj.name) #BUT,再次遍歷沒有打印,因為迭代器已經在上一次遍歷(next)到最后一次了,沒得遍歷了 for obj in objs: print(obj.name) #當然，使用iterator()方法來防止生成cache，意味着遍歷同一個queryset時會重復執行查詢。所以使 #用iterator()的時候要當心，確保你的代碼在操作一個大的queryset時沒有重復執行查詢 總結: queryset的cache是用於減少程序對數據庫的查詢，在通常的使用下會保證只有在需要的時候才會查詢數據庫。 使用exists()和iterator()方法可以優化程序對內存的使用。不過，由於它們並不會生成queryset cache，可能 會造成額外的數據庫查詢。
---------->對象查詢，單表條件查詢，多表條件關聯查詢
#--------------------對象形式的查找-------------------------- # 正向查找 ret1=models.Book.objects.first() print(ret1.title) print(ret1.price) print(ret1.publisher) print(ret1.publisher.name) #因為一對多的關系所以ret1.publisher是一個對象,而不是一個queryset集合 # 反向查找 ret2=models.Publish.objects.last() print(ret2.name) print(ret2.city) #如何拿到與它綁定的Book對象呢? print(ret2.book_set.all()) #ret2.book_set是一個queryset集合 #---------------了不起的雙下划線(__)之單表條件查詢---------------- # models.Tb1.objects.filter(id__lt=10, id__gt=1) # 獲取id大於1 且 小於10的值 # # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 獲取id等於11、22、33的數據 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # # models.Tb1.objects.filter(name__contains="ven") # models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感 # # models.Tb1.objects.filter(id__range=[1, 2]) # 范圍bettwen and # # startswith，istartswith, endswith, iendswith, #----------------了不起的雙下划線(__)之多表條件關聯查詢--------------- # 正向查找(條件) # ret3=models.Book.objects.filter(title='Python').values('id') # print(ret3)#[{'id': 1}] #正向查找(條件)之一對多 ret4=models.Book.objects.filter(title='Python').values('publisher__city') print(ret4) #[{'publisher__city': '北京'}] #正向查找(條件)之多對多 ret5=models.Book.objects.filter(title='Python').values('author__name') print(ret5) ret6=models.Book.objects.filter(author__name="alex").values('title') print(ret6) #注意 #正向查找的publisher__city或者author__name中的publisher,author是book表中綁定的字段 #一對多和多對多在這里用法沒區別 # 反向查找(條件) #反向查找之一對多: ret8=models.Publisher.objects.filter(book__title='Python').values('name') print(ret8)#[{'name': '人大出版社'}] 注意,book__title中的book就是Publisher的關聯表名 ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors') print(ret9)#[{'book__authors': 1}, {'book__authors': 2}] #反向查找之多對多: ret10=models.Author.objects.filter(book__title='Python').values('name') print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}] #注意 #正向查找的book__title中的book是表名Book #一對多和多對多在這里用法沒區別
注意：條件查詢即與對象查詢對應，是指在filter，values等方法中的通過__來明確查詢條件。
---------->聚合查詢和分組查詢
<1> aggregate(*args,**kwargs):
通過對QuerySet進行計算，返回一個聚合值的字典。aggregate()中每一個參數都指定一個包含在字典中的返回值。即在查詢集上生成聚合。
from django.db.models import Avg,Min,Sum,Max 從整個查詢集生成統計值。比如，你想要計算所有在售書的平均價錢。Django的查詢語法提供了一種方式描述所有 圖書的集合。 >>> Book.objects.all().aggregate(Avg('price')) {'price__avg': 34.35} aggregate()子句的參數描述了我們想要計算的聚合值，在這個例子中，是Book模型中price字段的平均值 aggregate()是QuerySet 的一個終止子句，意思是說，它返回一個包含一些鍵值對的字典。鍵的名稱是聚合值的 標識符，值是計算出來的聚合值。鍵的名稱是按照字段和聚合函數的名稱自動生成出來的。如果你想要為聚合值指定 一個名稱，可以向聚合子句提供它: >>> Book.objects.aggregate(average_price=Avg('price')) {'average_price': 34.35} 如果你也想知道所有圖書價格的最大值和最小值，可以這樣查詢： >>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price')) {'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
<2> annotate(*args,**kwargs):
可以通過計算查詢結果中每一個對象所關聯的對象集合，從而得出總計值(也可以是平均值或總和)，即為查詢集的每一項生成聚合。
查詢alex出的書總價格
查詢各個作者出的書的總價格,這里就涉及到分組了，分組條件是authors__name
查詢各個出版社最便宜的書價是多少
---------->F查詢和Q查詢
僅僅靠單一的關鍵字參數查詢已經很難滿足查詢要求。此時Django為我們提供了F和Q查詢：
# F 使用查詢條件的值,專門取對象中某列值的操作 # from django.db.models import F # models.Tb1.objects.update(num=F('num')+1) # Q 構建搜索條件 from django.db.models import Q #1 Q對象(django.db.models.Q)可以對關鍵字參數進行封裝，從而更好地應用多個查詢 q1=models.Book.objects.filter(Q(title__startswith='P')).all() print(q1)#[<Book: Python>, <Book: Perl>] # 2、可以組合使用&,|操作符，當一個操作符是用於兩個Q的對象,它產生一個新的Q對象。 Q(title__startswith='P') | Q(title__startswith='J') # 3、Q對象可以用~操作符放在前面表示否定，也可允許否定與不否定形式的組合 Q(title__startswith='P') | ~Q(pub_date__year=2005) # 4、應用范圍： # Each lookup function that takes keyword-arguments (e.g. filter(), # exclude(), get()) can also be passed one or more Q objects as # positional (not-named) arguments. If you provide multiple Q object # arguments to a lookup function, the arguments will be “AND”ed # together. For example: Book.objects.get( Q(title__startswith='P'), Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)) ) #sql: # SELECT * from polls WHERE question LIKE 'P%' # AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06') # import datetime # e=datetime.date(2005,5,6) #2005-05-06 # 5、Q對象可以與關鍵字參數查詢一起使用，不過一定要把Q對象放在關鍵字參數查詢的前面。 # 正確： Book.objects.get( Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)), title__startswith='P') # 錯誤： Book.objects.get( question__startswith='P', Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))
raw sql
django中models的操作,也是調用了ORM框架來實現的,pymysql 或者mysqldb,所以我們也可以使用原生的SQL語句來操作數據庫!
http://www.cnblogs.com/yuanchenqi/articles/6083427.html