django ORM操作(models模塊)

參考  http://www.cnblogs.com/yuanchenqi/articles/6083427.html

在settings修改默認數據庫（默認sqlite)

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',  #驅動
        'NAME': 't-1',  #數據庫名稱
        'USER':'root',
        'PASSWORD':'123456',
        'HOST':'192.168.10.129',
        'PORT':'3306'
    }
}

由於mysqldb對python3兼容性差，選用pymysql

pip install pymysql

在__init__

import pymysql
pymysql.install_as_MySQLdb()

setting設置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',  #驅動
        'NAME': 't1',  #數據庫名稱
        'USER':'root',
        'PASSWORD':'123456',
        'HOST':'192.168.10.128',
        'PORT':'3306',
        'OPTIONS': {
        'autocommit': True,     #自動提交
        'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
        }
    }
}
INSTALLED_APPS = [
    'blog',     #需將app名字加入這
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles'
] 

models.py

from django.db import models
# Create your models here.
class User_info(models.Model):
    username=models.CharField(max_length=64)
    password=models.CharField(max_length=64)
    age=models.CharField(max_length=64)
    # sex=models.CharField(max_length=64)
    # insert_time=models.DateTimeField(max_length=64)
class Userinfo(models.Model):
    username=models.CharField(max_length=64)
    password=models.CharField(max_length=64)
    age=models.CharField(max_length=64,null=True)
    sex=models.CharField(max_length=64,null=True)   #設置為True可以為空
    insert_time=models.DateTimeField(max_length=64,null=True)   

python manage.py makemigrations

python manage.py migrate

常見問題

Django連接mysql django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.3 or newer is required;
原因：pymysql沒有這么高版本
解決方法
C:\Programs\Python\Python36-32\Lib\site-packages\Django-2.0-py3.6.egg\django\db\backends\mysql
這個路徑里的文件把
if version < (1, 3, 3)將這判斷條件注釋掉

(urls.W005) URL namespace 'admin' isn't unique. You may not be able to reverse all URLs in this namespace
原因：總urls路由與app上的urls路由中有2個admin路徑
解決方法：
注釋掉一個

(mysql.W002) MySQL Strict Mode is not set for database connection 'default'
原因：django策略
解決方法：在setting中DATABASES 加入
        'OPTIONS': {
        'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
        }

報錯：django.db.utils.InternalError: (1665, 'Cannot execute statement: impossible to write to binary log since BINLOG_FORMAT = STATEMENT and at least one tabl
e uses a storage engine limited to row-based logging. InnoDB is limited to row-logging when transaction isolation level is READ COMMITTED or READ UNCOMM
ITTED.')
解決：配置my.cnf,開啟binlog_format=mixed，重啟mysql
創建數據庫沒有app.models中的表
解決方法：1在setting INSTALLED_APPS加入app名字
2 python manage.py makemigrations blog   #blog為你的app名字
    python manage.py migrate

<module> 
    from test_django.blog import views
ImportError: No module named 'test_django.blog'
 django運行報此錯,django項目根目錄是test_django,所以他識別的是test_django下的test_django.blog，所以無此模塊，改成 from blog import views 可正常執行但pycharm顯示飄紅
飄紅是由於此項目放到了其他項目下，根目錄沖突，Content Root目錄變成了上一級另外個項目根目錄。

 

 

 

 模型常用的字段類型參數

常見 DateTimeField CharField IntegerField   

報錯expected string or bytes-like object 原因是datefield類型需'2017-10-11',需是string

復制代碼
<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參數.

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)

表操作（建議不用save）

單表操作  

#models.py 創建表
class Userinfo(models.Model):
    username=models.CharField(max_length=64)
    password=models.CharField(max_length=64)
    age=models.CharField(max_length=64,null=True)
    sex=models.CharField(max_length=64,null=True)
    insert_time=models.DateTimeField(max_length=64,null=True)

增（操作需放在views.py函數里。通過前端調用)  （參數字典前面**，列表*）

def index(req):
    models.Userinfo.objects.create(   #方法一
        username='xiaoming',
        password='123',
        age=13,
        sex='man',
        insert_time='2018-04-16'
    )
    models.Userinfo.objects.create(   #方法二建議這種，直接將前端字典插入
        **{"username":'xiaohuang'},
        **{"password":'1234'},
        **{"age":18},
        **{"sex":'woman'},
        **{"insert_time":'2018-04-16'}
    )
    return render(req,"index.html",{"num":100})

刪

    models.Userinfo.objects.filter(username='xiaohuang').delete()
    models.Userinfo.objects.get(username='xiaomin').delete()

改 （saved會把數據更改一次）

models.Userinfo.objects.filter(username='liu').update(sex='woman')

查

# 查詢相關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'])  

 

    r=models.Userinfo.objects.filter(sex='woman')[0:3]   #filter獲取的是一個有序的集合，[]第幾行數據 結果Userinfo object (1)
    i=models.Userinfo.objects.filter(sex='admin').values('password')#QuerySet，形式 [{'password': 'lxs@6630'}，{'password':'6630'}]
    s=models.Userinfo.objects.filter(sex='woman')[0]
    name=s.password  #獲取密碼 結果密碼12345 等於i[0]['password']
    print(i)
    r = models.Userinfo.objects.filter(sex='woman').order_by('id')
    ret=models.Userinfo.objects.raw("select * from blog_userinfo WHERE age<14")[0].password    #原生sql raw
        print(ret)

#---------------了不起的雙下划線(__)之單表條件查詢----------------

#    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

 

 日志分析，將下面代碼貼到setting,會記錄每條對應的SQL

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

 

QuerySet特點：格式【{}，{}】

       <1>  可迭代的

       <2>  可切片

queryset使用注意事項(判斷是否存在用exists,這樣不會把數據全部拉到緩存，或者用iterator)

<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，可能
會造成額外的數據庫查詢。

queryset緩存機制測試

    obj=models.Book.objects.filter(id=1)
    for item in obj:
        print (item.title)
    for item in obj:       #開啟logging第二次執行沒有調用SQL,是從緩存中拿的數據
        print (item.title)
    obj.update(title='python3實戰') #建議這樣更新
    #models.Book.objects.filter(id=1).update(title='python3實戰')這樣執行，數據庫數據變了，但下面數據還是緩存中拿
    for item in obj:     #obj.update執行 數據更新后，重新從數據庫取一次。
        print (item.title)

 

一對多，多對多是基於外鍵模擬創建出來的

一對多創建關系表（foreignKey，1.8on_delete默認是連級刪除，2.0需要這個參數需要自己加）

django2.0需要設定。
CASCADE:這就是默認的選項，級聯刪除，你無需顯性指定它。
PROTECT: 保護模式，如果采用該選項，刪除的時候，會拋出ProtectedError錯誤。
SET_NULL: 置空模式，刪除的時候，外鍵字段被設置為空，前提就是blank=True, null=True,定義該字段的時候，允許為空。
SET_DEFAULT: 置默認值，刪除的時候，外鍵字段設置為默認值，所以定義外鍵的時候注意加上一個默認值。
SET(): 自定義一個值，該值當然只能是對應的實體了

from django.db import models
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):           #目的當print對象時不顯示內存地址。
        return self.name
class Book(models.Model):
    title = models.CharField(max_length=100)
    # authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher,on_delete=models.CASCADE)  
    # 一對多，外鍵放多的表，Publisher必須是存在類，字段名由publisher變成pulisher_id字段
    publication_date = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2, default=10)
    def __str__(self):
        return self.title

增數據

publisher_id=4  #方法一
publisher=models.Publisher.objects.get(id=1)  #方法二，必須是個對象

或

    models.Book.objects.create(
        title='redis運維',
        publication_date='2009-9-1',
        price=40,
        publisher=models.Publisher.objects.filter(id=11)[0]
    )

 刪除，改與單表一樣。

查（基於對象）

    #正向查找根據書名找出版社
    obj=models.Book.objects.filter(title='python自動化運維')[0] #第一步獲取book對象
    publisher_name=obj.publisher.name  #第二步關聯publisher表獲取name屬性
    print(publisher_name)
    #反向查找出版社出版的所有書
    publisher_obj=models.Publisher.objects.filter(name='上海出版社')[0]#第一步獲取出版社對象
    book=publisher_obj.book_set.values("title").distinct() #用book_set關聯book
    print (book )

 （條件查詢）雙下划線（一對多和多對多在這里用法沒區別）

     #正向查找(條件)之一對多
ret4=models.Book.objects.filter(title='Python').values('publisher__city')
print(ret4)  #[{'publisher__city': '北京'}]
    #反向查找之一對多:
    ret8=models.Publisher.objects.filter(book__title='Python').values('name')
    print(ret8)#[{'name': '人大出版社'}]  注意,book__title中的book就是Publisher的關聯表名

 

多對多

創建表

class Author(models.Model):
    name = models.CharField(max_length=30)
    def __str__(self):
        return self.name
class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    #多對多放在哪個類都行改下括號的類就行，會自動創建一張新表blog_book_authors 里面存放book_id,author_id兩個字段,book表中無authors字段
    publisher = models.ForeignKey(Publisher,on_delete=models.CASCADE)  # 一對多，外鍵放多的表，Publisher必須有的類，字段名由publisher變成pulisher_id字段
    publication_date = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2, default=10)
    def __str__(self):
        return self.title

 增（自動創建只有這一種方法）

    #正向查詢
    author1 = models.Author.objects.get(name="xiaoming")
    author2 = models.Author.objects.get(name="xiaowang")
    book=models.Book.objects.filter(id=11)[0]
    book.authors.add(*[author1,author2])  #等於book.authors.add(author1,author2)  刪除方法一樣book.authors.remove(author1,author2) 
    #book.authors.add(author1）
    #book.authors.add(author1) 
    #同樣可以通過反向查詢實現
    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)

class Book2Author(models.Model):
    author=models.ForeignKey("Author")
    book=  models.ForeignKey("Book")
    class Meta:
        unique_together=["author","book"]  #對應唯一

 

多對多刪除clear與 remove

#正向
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 關聯的所有數據

 條件查詢（一對多和多對多在這里用法沒區別）

      #正向查找(條件)之多對多
      ret5=models.Book.objects.filter(title='Python').values('author__name')
print(ret5)
 ret6=models.Book.objects.filter(author__name="al").values('title')
print(ret6)
    #反向查找之多對多:
    ret10=models.Author.objects.filter(book__title='Python').values('name')
print(ret10)#[{'name': 'al'}, {'name': 'vin'}]

 

 

聚合查詢和分組查詢

aggregate(*args,**kwargs)

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')}

分組查詢

 annotate(*args,**kwargs):

 

 

F查詢和Q查詢

# F 使用查詢條件的值,專門取對象中某列值的操作
# 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)))