本節目錄
- MVC或者MVC框架中包括一個重要的部分，就是ORM，它實現了數據模型與數據庫的解耦，即數據模型的設計不需要依賴於特定的數據庫，通過簡單的配置就可以輕松更換數據庫，這極大的減輕了開發人員的工作量，不需要面對因數據庫變更而導致的無效勞動
- ORM是“對象-關系-映射”的簡稱。（Object Relational Mapping，簡稱ORM）(將來會學一個sqlalchemy，是和他很像的，但是django的orm沒有獨立出來讓別人去使用，雖然功能比sqlalchemy更強大，但是別人用不了)
- 類對象--->sql--->pymysql--->mysql服務端--->磁盤，orm其實就是將類對象的語法翻譯成sql語句的一個引擎，明白orm是什么了，剩下的就是怎么使用orm，怎么來寫類對象關系語句。
原生sql和python的orm代碼對比
#sql中的表 #創建表: CREATE TABLE employee( id INT PRIMARY KEY auto_increment , name VARCHAR (20), gender BIT default 1, birthday DATA , department VARCHAR (20), salary DECIMAL (8,2) unsigned, ); #sql中的表紀錄 #添加一條表紀錄: INSERT employee (name,gender,birthday,salary,department) VALUES ("alex",1,"1985-12-12",8000,"保潔部"); #查詢一條表紀錄: SELECT * FROM employee WHERE age=24; #更新一條表紀錄: UPDATE employee SET birthday="1989-10-24" WHERE id=1; #刪除一條表紀錄: DELETE FROM employee WHERE name="alex" #python的類 class Employee(models.Model): id=models.AutoField(primary_key=True) name=models.CharField(max_length=32) gender=models.BooleanField() birthday=models.DateField() department=models.CharField(max_length=32) salary=models.DecimalField(max_digits=8,decimal_places=2) #python的類對象 #添加一條表紀錄: emp=Employee(name="alex",gender=True,birthday="1985-12-12",epartment="保潔部") emp.save() #查詢一條表紀錄: Employee.objects.filter(age=24) #更新一條表紀錄: Employee.objects.filter(id=1).update(birthday="1989-10-24") #刪除一條表紀錄: Employee.objects.filter(name="alex").delete()
一、創建表
創建模型
創建名為book的app，在book下的models.py中創建模型：
from django.db import models # Create your models here. class Book(models.Model): id=models.AutoField(primary_key=True) #如果表里面沒有寫主鍵，表里面會自動生成一個自增主鍵字段，叫做id字段，orm要求每個表里面必須要寫一個主鍵 title=models.CharField(max_length=32) #和varchar(32)是一樣的，32個字符 state=models.BooleanField() pub_date=models.DateField() #必須存這種格式"2018-12-12" price=models.DecimalField(max_digits=8,decimal_places=2) #max_digits最大位數，decimal_places小數部分占多少位 publish=models.CharField(max_length=32)
接下來要創建對應的數據，連接上對應的數據庫，然后執行創建表的命令，翻譯成相應的sql，然后到數據庫里面執行，從而創建對應的表。多了一步orm翻譯成sql的過程，效率低了，但是沒有太大的損傷，還能忍受，當你不能忍的時候，你可以自己寫原生sql語句，一般的場景orm都夠用了，開發起來速度更快，寫法更貼近應用程序開發，還有一點就是數據庫升級或者變更，那么你之前用sql語句寫的數據庫操作，那么就需要將sql語句全部修改，但是如果你用orm，就不需要擔心這個問題，不管是你從mysql變更到oracle還是從oracle更換到mysql，你如果用的是orm來搞的，你只需要修改一下orm的引擎（配置文件里面改一些配置就搞定）就可以了，你之前寫的那些orm語句還是會自動翻譯成對應數據庫的sql語句。
簡單提一下sqlite數據庫：（先忽略）
2 更多字段和參數
每個字段有一些特有的參數，例如，CharField需要max_length參數來指定VARCHAR數據庫字段的大小。還有一些適用於所有字段的通用參數。 這些參數在文檔中有詳細定義，這里我們只簡單介紹一些最常用的：
更多字段：
''' <1> CharField 字符串字段, 用於較短的字符串. CharField 要求必須有一個參數 maxlength, 用於從數據庫層和Django校驗層限制該字段所允許的最大字符數. <2> IntegerField #用於保存一個整數. <3> DecimalField 一個浮點數. 必須 提供兩個參數: 參數 描述 max_digits 總位數(不包括小數點和符號) decimal_places 小數位數 舉例來說, 要保存最大值為 999 (小數點后保存2位),你要這樣定義字段: models.DecimalField(..., max_digits=5, decimal_places=2) 要保存最大值一百萬(小數點后保存10位)的話,你要這樣定義: models.DecimalField(..., max_digits=17, decimal_places=10) #max_digits大於等於17就能存儲百萬以上的數了 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參數. '''
更多參數：
(1)null 如果為True，Django 將用NULL 來在數據庫中存儲空值。 默認值是 False. (1)blank 如果為True，該字段允許不填。默認為False。 要注意，這與 null 不同。null純粹是數據庫范疇的，而 blank 是數據驗證范疇的。 如果一個字段的blank=True，表單的驗證將允許該字段是空值。如果字段的blank=False，該字段就是必填的。 (2)default 字段的默認值。可以是一個值或者可調用對象。如果可調用 ，每有新對象被創建它都會被調用，如果你的字段沒有設置可以為空，那么將來如果我們后添加一個字段，這個字段就要給一個default值 (3)primary_key 如果為True，那么這個字段就是模型的主鍵。如果你沒有指定任何一個字段的primary_key=True， Django 就會自動添加一個IntegerField字段做為主鍵，所以除非你想覆蓋默認的主鍵行為， 否則沒必要設置任何一個字段的primary_key=True。 (4)unique 如果該值設置為 True, 這個數據字段的值在整張表中必須是唯一的 (5)choices 由二元組組成的一個可迭代對象（例如，列表或元組），用來給字段提供選擇項。 如果設置了choices ，默認的表單將是一個選擇框而不是標准的文本框，<br>而且這個選擇框的選項就是choices 中的選項。 (6)db_index 如果db_index=True 則代表着為此字段設置數據庫索引。
DatetimeField、DateField、TimeField這個三個時間字段，都可以設置如下屬性。 (7)auto_now_add 配置auto_now_add=True，創建數據記錄的時候會把當前時間添加到數據庫。 (8)auto_now 配置上auto_now=True，每次更新數據記錄的時候會更新該字段，標識這條記錄最后一次的修改時間。
關於auto_now，你需要知道的事情
當需要更新時間的時候，我們盡量通過datetime模塊來創建當前時間，並保存或者更新到數據庫里面，看下面的分析： 假如我們的表結構是這樣的 class User(models.Model): username = models.CharField(max_length=255, unique=True, verbose_name='用戶名') is_active = models.BooleanField(default=False, verbose_name='激活狀態') 那么我們修改用戶名和狀態可以使用如下兩種方法： 方法一： User.objects.filter(id=1).update(username='nick',is_active=True) 方法二： _t = User.objects.get(id=1) _t.username='nick' _t.is_active=True _t.save() 方法一適合更新一批數據，類似於mysql語句update user set username='nick' where id = 1 方法二適合更新一條數據，也只能更新一條數據，當只有一條數據更新時推薦使用此方法，另外此方法還有一個好處，我們接着往下看 具有auto_now屬性字段的更新 我們通常會給表添加三個默認字段 - 自增ID，這個django已經默認加了，就像上邊的建表語句，雖然只寫了username和is_active兩個字段，但表建好后也會有一個默認的自增id字段 - 創建時間，用來標識這條記錄的創建時間，具有auto_now_add屬性，創建記錄時會自動填充當前時間到此字段 - 修改時間，用來標識這條記錄最后一次的修改時間，具有auto_now屬性，當記錄發生變化時填充當前時間到此字段 就像下邊這樣的表結構 class User(models.Model): create_time = models.DateTimeField(auto_now_add=True, verbose_name='創建時間') update_time = models.DateTimeField(auto_now=True, verbose_name='更新時間') username = models.CharField(max_length=255, unique=True, verbose_name='用戶名') is_active = models.BooleanField(default=False, verbose_name='激活狀態') 當表有字段具有auto_now屬性且你希望他能自動更新時，必須使用上邊方法二的更新，不然auto_now字段不會更新，也就是： _t = User.objects.get(id=1) _t.username='nick' _t.is_active=True _t.save() json/dict類型數據更新字段 目前主流的web開放方式都講究前后端分離，分離之后前后端交互的數據格式大都用通用的jason型，那么如何用最少的代碼方便的更新json格式數據到數據庫呢？同樣可以使用如下兩種方法： 方法一： data = {'username':'nick','is_active':'0'} User.objects.filter(id=1).update(**data) 同樣這種方法不能自動更新具有auto_now屬性字段的值 通常我們再變量前加一個星號(*)表示這個變量是元組/列表，加兩個星號表示這個參數是字典 方法二： data = {'username':'nick','is_active':'0'} _t = User.objects.get(id=1) _t.__dict__.update(**data) _t.save() 方法二和方法一同樣無法自動更新auto_now字段的值 注意這里使用到了一個__dict__方法 方法三： _t = User.objects.get(id=1) _t.role=Role.objects.get(id=3) _t.save() #想讓auto_now更新數據時自動更新時間，必須使用save方法來更新數據，所以很不方便，所以這個創建時自動添加時間或者更新時間的auto_now方法我們最好就別用了，比較惡心，並且支持我們自己來給這個字段更新時間： models.py: class Book(models.Model): name = models.CharField(max_length=32) date1 = models.DateTimeField(auto_now=True,null=True) date2 = models.DateTimeField(auto_now_add=True,null=True) views.py: import datetime models.Book.objects.filter(id=1).update( name='chao', date1=datetime.datetime.now(), date2=datetime.datetime.now(), )
3 settings配置
若想將模型轉為mysql數據庫中的表，需要在settings中配置：
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME':'bms', # 要連接的數據庫，連接前需要創建好 'USER':'root', # 連接數據庫的用戶名 'PASSWORD':'', # 連接數據庫的密碼 'HOST':'127.0.0.1', # 連接主機，默認本級 'PORT'：3306 # 端口 默認3306 } }
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME':'bms', # 要連接的數據庫，連接前需要創建好 'USER':'root', # 連接數據庫的用戶名 'PASSWORD':'', # 連接數據庫的密碼 'HOST':'127.0.0.1', # 連接主機，默認本級 'PORT'：3306 # 端口 默認3306 }， 'app01': { #可以為每個app都配置自己的數據，並且數據庫還可以指定別的，也就是不一定就是mysql，也可以指定sqlite等其他的數據庫 'ENGINE': 'django.db.backends.mysql', 'NAME':'bms', # 要連接的數據庫，連接前需要創建好 'USER':'root', # 連接數據庫的用戶名 'PASSWORD':'', # 連接數據庫的密碼 'HOST':'127.0.0.1', # 連接主機，默認本級 'PORT'：3306 # 端口 默認3306 } }
注意1：NAME即數據庫的名字，在mysql連接前該數據庫必須已經創建，而上面的sqlite數據庫下的db.sqlite3則是項目自動創建 USER和PASSWORD分別是數據庫的用戶名和密碼。設置完后，再啟動我們的Django項目前，我們需要激活我們的mysql。然后，啟動項目，會報錯：no module named MySQLdb 。這是因為django默認你導入的驅動是MySQLdb，可是MySQLdb 對於py3有很大問題，所以我們需要的驅動是PyMySQL 所以，我們只需要找到項目名文件下的__init__,在里面寫入：
import pymysql pymysql.install_as_MySQLdb()
最后通過兩條數據庫遷移命令即可在指定的數據庫中創建表 ：
python manage.py makemigrations #生成記錄，每次修改了models里面的內容或者添加了新的app，新的app里面寫了models里面的內容，都要執行這兩條
python manage.py migrate #執行上面這個語句的記錄來創建表，生成的表名字前面會自帶應用的名字，例如：你的book表在mysql里面叫做app01_book表
關於同步指令的執行簡單原理：
在執行 python manager.py magrations 時django 會在相應的 app 的migration文件夾下面生成 一個python腳本文件 在執行 python manager.py migrte 時 django才會生成數據庫表，那么django是如何生成數據庫表的呢， django是根據 migration下面的腳本文件來生成數據表的 每個migration文件夾下面有多個腳本，那么django是如何知道該執行那個文件的呢，django有一張django-migrations表，表中記錄了已經執行的腳本，那么表中沒有的就是還沒執行的腳本，則 執行migrate的時候就只執行表中沒有記錄的那些腳本。 有時在執行 migrate 的時候如果發現沒有生成相應的表，可以看看在 django-migrations表中看看 腳本是否已經執行了， 可以刪除 django-migrations 表中的記錄 和 數據庫中相應的 表 ， 然后重新 執行
通過pycharm提供的功能來執行manage.py相關的指令：
給之前的字段添加一些數據，然后再添加一個字段，然后執行上面兩個指令，看看效果。
注意2:確保配置文件中的INSTALLED_APPS中寫入我們創建的app名稱
INSTALLED_APPS = [ 'django.contrib.admin', #這是django給你提供的一些特殊功能的配置（應用，只是咱們看不到），也在應用這里給配置的，這些功能如果你注銷了，那么我們執行同步數據庫指令之后，就不會生成那些django自帶的表了。因為執行數據庫同步語句的時候，django會找這里面所有的應用，找到他們的models來創建表 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', "book" #直接寫app的名字也行，寫'app01.apps.App01Config'也行 ]
注意3:如果報錯如下：
django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.3 or newer is required; you have 0.7.11.None
MySQLclient目前只支持到python3.4，因此如果使用的更高版本的python，需要修改如下：
通過查找路徑C:\Programs\Python\Python36-32\Lib\site-packages\Django-2.0-py3.6.egg\django\db\backends\mysql
這個路徑里的文件把
if version < (1, 3, 3): raise ImproperlyConfigured("mysqlclient 1.3.3 or newer is required; you have %s" % Database.__version__)
注釋掉 就OK了。
注意4: 如果想打印orm轉換過程中的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', }, } }
還有一種查看sql語句的方式
from app01 import models def add_book(request): ''' 添加表記錄 :param request: http請求信息 :return: ''' book_obj = models.Book(title='python',price=123,pub_date='2012-12-12',publish='人民出版社') book_obj.save() from django.db import connection #通過這種方式也能查看執行的sql語句 print(connection.queries) return HttpResponse('ok')
4、自定義字段（了解）
class UnsignedIntegerField(models.IntegerField):
def db_type(self, connection):
return 'integer UNSIGNED'
自定義char類型字段：
class FixedCharField(models.Field): """ 自定義的char類型的字段類 """ def __init__(self, max_length, *args, **kwargs): super().__init__(max_length=max_length, *args, **kwargs) self.length = max_length def db_type(self, connection): """ 限定生成數據庫表的字段類型為char，長度為length指定的值 """ return 'char(%s)' % self.length class Class(models.Model): id = models.AutoField(primary_key=True) title = models.CharField(max_length=25) # 使用上面自定義的char類型的字段 cname = FixedCharField(max_length=25)
創建的表結構：
附ORM字段與數據庫實際字段的對應關系:
'AutoField': 'integer AUTO_INCREMENT', 'BigAutoField': 'bigint AUTO_INCREMENT', 'BinaryField': 'longblob', 'BooleanField': 'bool', 'CharField': 'varchar(%(max_length)s)', 'CommaSeparatedIntegerField': 'varchar(%(max_length)s)', 'DateField': 'date', 'DateTimeField': 'datetime', 'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)', 'DurationField': 'bigint', 'FileField': 'varchar(%(max_length)s)', 'FilePathField': 'varchar(%(max_length)s)', 'FloatField': 'double precision', 'IntegerField': 'integer', 'BigIntegerField': 'bigint', 'IPAddressField': 'char(15)', 'GenericIPAddressField': 'char(39)', 'NullBooleanField': 'bool', 'OneToOneField': 'integer', 'PositiveIntegerField': 'integer UNSIGNED', 'PositiveSmallIntegerField': 'smallint UNSIGNED', 'SlugField': 'varchar(%(max_length)s)', 'SmallIntegerField': 'smallint', 'TextField': 'longtext', 'TimeField': 'time', 'UUIDField': 'char(32)',
二、添加表紀錄
在python中orm的對應關系有三種：
類 ---------->表
類對象 ---------->行(記錄)
類屬性 ---------->表的字段（重點）
首先想操作表的增刪改查，你需要導入這個表
#在邏輯代碼中導入你要操作的表 from app01 import models def add_book(request): ''' 添加表記錄 :param request: http請求信息 :return: ''' models.Book(title='python',price=123,pub_date='2012-12-12',publish='人民出版社') #pub_date=datetime.datetime.now()，這個字段直接給日期時間類型的數據也是可以的
方式1
book_obj=Book(title="python葵花寶典",state=True,price=100,publish="蘋果出版社",pub_date="2012-12-12") #實例化一個對象表示一行記錄，時間日期如果只寫日期的話，時間默認是00.00.00，注意日期寫法必須是2012-12-12這種格式
book_obj.save() #就是pymysql的那個commit提交
方式2（用的多）
# create方法的返回值book_obj就是插入book表中的python葵花寶典這本書籍紀錄對象 book_obj=Book.objects.create(title="python葵花寶典",state=True,price=100,publish="蘋果出版社",pub_date="2012-12-12") #這個返回值就像是mysql里面咱們講的那個new對象，還記得嗎，他跟上面那種創建方式創建的那個對象是一樣的
#這個Book.objects就像是一個Book表的管理器一樣，提供了增刪改查所有的方法
print(book_obj.title) #可以基於這個對象來取這個新添加的記錄對象的屬性值
dic1 = {'title':'linux','state'=True,'price':100,'publish'='2018-12-12'} #這樣寫的時候，注意如果你用post提交過來的請求，有個csrf_token的鍵值對要刪除，並且request.POST是不能直接在request.POST里面進行修改和刪除的，data = request.POST.dict()轉換成普通的字典-->Book.objects.create(**data)
book.objects.create(**dic1)
方式3：批量插入
book_list = [] for i in range(10): bk_obj = models.Book( name='chao%s'%i, addr='北京%s'%i ) book_list.append(bk_obj) models.Book.objects.bulk_create(book_list) #批量插入，速度快
update_or_create:有就更新，沒有就創建 ，還有個get_or_create，有就查詢出來，沒有就創建
obj,created = models.UserToken.objects.update_or_create( user=user, # 查找篩選條件 defaults={ # 添加或者更新的數據 "token":random_str, } )
三、查詢表紀錄
還記得表類.objects像是一個管理器，提供了增刪改查的方法，Book.objects.all()獲取所有的書籍，查詢這里大家就掌握誰調用的下面的方法
查詢API（都是重點）
<1> all(): 查詢所有結果，結果是queryset類型 <2> filter(**kwargs): 它包含了與所給篩選條件相匹配的對象，結果也是queryset類型 Book.objects.filter(title='linux',price=100) #里面的多個條件用逗號分開，並且這幾個條件必須都成立，是and的關系，or關系的我們后面再學，直接在這里寫是搞不定or的 <3> get(**kwargs): 返回與所給篩選條件相匹配的對象，不是queryset類型，是行記錄對象，返回結果有且只有一個， 如果符合篩選條件的對象超過一個或者沒有都會拋出錯誤。捕獲異常try。 Book.objects.get(id=1) <4> exclude(**kwargs): 排除的意思，它包含了與所給篩選條件不匹配的對象，沒有不等於的操作昂，用這個exclude，返回值是queryset類型 Book.objects.exclude(id=6)，返回id不等於6的所有的對象，或者在queryset基礎上調用，Book.objects.all().exclude(id=6) <5> order_by(*field): queryset類型的數據來調用，對查詢結果排序,默認是按照id來升序排列的，返回值還是queryset類型 models.Book.objects.all().order_by('price','id') #直接寫price，默認是按照price升序排列，按照字段降序排列，就寫個負號就行了order_by('-price'),order_by('price','id')是多條件排序，按照price進行升序，price相同的數據，按照id進行升序 <6> reverse(): queryset類型的數據來調用，對查詢結果反向排序，返回值還是queryset類型 <7> count(): queryset類型的數據來調用，返回數據庫中匹配查詢(QuerySet)的對象數量。 <8> first(): queryset類型的數據來調用，返回第一條記錄 Book.objects.all()[0] = Book.objects.all().first()，得到的都是model對象，不是queryset <9> last(): queryset類型的數據來調用，返回最后一條記錄 <10> exists(): queryset類型的數據來調用，如果QuerySet包含數據，就返回True，否則返回False 空的queryset類型數據也有布爾值True和False，但是一般不用它來判斷數據庫里面是不是有數據，如果有大量的數據，你用它來判斷，那么就需要查詢出所有的數據，效率太差了，用count或者exits 例：all_books = models.Book.objects.all().exists() #翻譯成的sql是SELECT (1) AS `a` FROM `app01_book` LIMIT 1，就是通過limit 1，取一條來看看是不是有數據 <11> values(*field): 用的比較多，queryset類型的數據來調用，返回一個ValueQuerySet——一個特殊的QuerySet，運行后得到的並不是一系列 model的實例化對象，而是一個可迭代的字典序列,只要是返回的queryset類型，就可以繼續鏈式調用queryset類型的其他的查找方法，其他方法也是一樣的。 <12> values_list(*field): 它與values()非常相似，它返回的是一個元組序列，values返回的是一個字典序列 <13> distinct(): values和values_list得到的queryset類型的數據來調用，從返回結果中剔除重復紀錄
queryset方法大全：
################################################################## # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET # ################################################################## def all(self) # 獲取所有的數據對象 def filter(self, *args, **kwargs) # 條件查詢 # 條件可以是：參數，字典，Q def exclude(self, *args, **kwargs) # 條件查詢 # 條件可以是：參數，字典，Q def select_related(self, *fields) 性能相關：表之間進行join連表操作，一次性獲取關聯的數據。 總結： 1. select_related主要針一對一和多對一關系進行優化。 2. select_related使用SQL的JOIN語句進行優化，通過減少SQL查詢的次數來進行優化、提高性能。 def prefetch_related(self, *lookups) 性能相關：多表連表操作時速度會慢，使用其執行多次SQL查詢在Python代碼中實現連表操作。 總結： 1. 對於多對多字段（ManyToManyField）和一對多字段，可以使用prefetch_related()來進行優化。 2. prefetch_related()的優化方式是分別查詢每個表，然后用Python處理他們之間的關系。 def annotate(self, *args, **kwargs) # 用於實現聚合group by查詢 from django.db.models import Count, Avg, Max, Min, Sum v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')) # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1) # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1 v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1) # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1 def distinct(self, *field_names) # 用於distinct去重 models.UserInfo.objects.values('nid').distinct() # select distinct nid from userinfo 注：只有在PostgreSQL中才能使用distinct進行去重 def order_by(self, *field_names) # 用於排序 models.UserInfo.objects.all().order_by('-id','age') def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) # 構造額外的查詢條件或者映射，如：子查詢 Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,)) Entry.objects.extra(where=['headline=%s'], params=['Lennon']) Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) def reverse(self): # 倒序 models.UserInfo.objects.all().order_by('-nid').reverse() # 注：如果存在order_by，reverse則是倒序，如果多個排序則一一倒序 def defer(self, *fields): models.UserInfo.objects.defer('username','id') 或 models.UserInfo.objects.filter(...).defer('username','id') #映射中排除某列數據 def only(self, *fields): #僅取某個表中的數據 models.UserInfo.objects.only('username','id') 或 models.UserInfo.objects.filter(...).only('username','id') def using(self, alias): 指定使用的數據庫，參數為別名（setting中的設置） ################################################## # PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS # ################################################## def raw(self, raw_query, params=None, translations=None, using=None): # 執行原生SQL models.UserInfo.objects.raw('select * from userinfo') # 如果SQL是其他表時，必須將名字設置為當前UserInfo對象的主鍵列名 models.UserInfo.objects.raw('select id as nid from 其他表') # 為原生SQL設置參數 models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,]) # 將獲取的到列名轉換為指定列名 name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'} Person.objects.raw('SELECT * FROM some_other_table', translations=name_map) # 指定數據庫 models.UserInfo.objects.raw('select * from userinfo', using="default") ################### 原生SQL ################### from django.db import connection, connections cursor = connection.cursor() # cursor = connections['default'].cursor() cursor.execute("""SELECT * from auth_user where id = %s""", [1]) row = cursor.fetchone() # fetchall()/fetchmany(..) def values(self, *fields): # 獲取每行數據為字典格式 def values_list(self, *fields, **kwargs): # 獲取每行數據為元祖 def dates(self, field_name, kind, order='ASC'): # 根據時間進行某一部分進行去重查找並截取指定內容 # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日） # order只能是："ASC" "DESC" # 並獲取轉換后的時間 - year : 年-01-01 - month: 年-月-01 - day : 年-月-日 models.DatePlus.objects.dates('ctime','day','DESC') def datetimes(self, field_name, kind, order='ASC', tzinfo=None): # 根據時間進行某一部分進行去重查找並截取指定內容，將時間轉換為指定時區時間 # kind只能是 "year", "month", "day", "hour", "minute", "second" # order只能是："ASC" "DESC" # tzinfo時區對象 models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC) models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai')) """ pip3 install pytz import pytz pytz.all_timezones pytz.timezone(‘Asia/Shanghai’) """ def none(self): # 空QuerySet對象 #################################### # METHODS THAT DO DATABASE QUERIES # #################################### def aggregate(self, *args, **kwargs): # 聚合函數，獲取字典類型聚合結果 from django.db.models import Count, Avg, Max, Min, Sum result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid')) ===> {'k': 3, 'n': 4} def count(self): # 獲取個數 def get(self, *args, **kwargs): # 獲取單個對象 def create(self, **kwargs): # 創建對象 def bulk_create(self, objs, batch_size=None): # 批量插入 # batch_size表示一次插入的個數 objs = [ models.DDD(name='r11'), models.DDD(name='r22') ] models.DDD.objects.bulk_create(objs, 10) def get_or_create(self, defaults=None, **kwargs): # 如果存在，則獲取，否則，創建 # defaults 指定創建時，其他字段的值 obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2}) def update_or_create(self, defaults=None, **kwargs): # 如果存在，則更新，否則，創建 # defaults 指定創建時或更新時的其他字段 obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1}) def first(self): # 獲取第一個 def last(self): # 獲取最后一個 def in_bulk(self, id_list=None): # 根據主鍵ID進行查找 id_list = [11,21,31] models.DDD.objects.in_bulk(id_list) def delete(self): # 刪除 def update(self, **kwargs): # 更新 def exists(self): # 是否有結果
關於values的用法和返回結果舉例：
all_books = models.Book.objects.all().values('id','title') print(all_books) #<QuerySet [{'title': 'linux', 'id': 6}, {'title': '你好', 'id': 7}, {'title': 'linux', 'id': 8}, {'title': 'xxx', 'id': 9}, {'title': 'gogogo', 'id': 10}]> ''' values做的事情： ret = [] #queryset類型 for obj in Book.objects.all(): temp = { #元素是字典類型 'id':obj.id, 'title':obj.title } ret.append(temp) '''
關於values_list的用法和返回結果舉例：
all_books = models.Book.objects.all().values_list('id','title') print(all_books) #<QuerySet [(6, 'linux'), (7, '你好'), (8, 'linux'), (9, 'xxx'), (10, 'gogogo')]> ''' values做的事情： ret = [] #queryset類型 for obj in Book.objects.all(): temp = ( #元素是元祖類型 obj.id,obj.title ) ret.append(temp) '''
關於distinct的用法和返回結果舉例：
# all_books = models.Book.objects.all().distinct() #這樣寫是表示記錄中所有的字段重復才叫重復，但是我們知道有主鍵的存在，所以不可能所有字段數據都重復 # all_books = models.Book.objects.all().distinct('price') #報錯，不能在distinct里面加字段名稱 # all_books = models.Book.objects.all().values('price').distinct()#<QuerySet [(Decimal('11.00'),), (Decimal('111.00'),), (Decimal('120.00'),), (Decimal('11111.00'),)]> all_books = models.Book.objects.all().values_list('price').distinct()#<QuerySet [{'price': Decimal('11.00')}, {'price': Decimal('111.00')}, {'price': Decimal('120.00')}, {'price': Decimal('11111.00')}]> 只能用於valuse和values_list進行去重
all_books = models.Book.objects.all().values_list('title','price').distinct() #title和price兩個同時重復才算一條重復的記錄
打印一個對象，讓他顯示一個能夠看懂的值，__str__，models.py的數據表類里面定義一個__str__方法就可以了
#__str__方法的使用 class MyClass: def __init__(self,name,age): self.name = name self.age = age def __str__(self): return self.name + '>>>' + str(self.age) a = MyClass('chao',18) b = MyClass('wc',20) print(a) print(b)
models.py的__str__的寫法：
from django.db import models # Create your models here. class Book(models.Model): id = models.AutoField(primary_key=True) title = models.CharField(max_length=32) price = models.DecimalField(max_digits=8,decimal_places=2,) pub_date = models.DateTimeField() #必須存這種格式"2012-12-12" publish = models.CharField(max_length=32) def __str__(self): #后添加這個str方法，也不需要重新執行同步數據庫的指令 return self.title #當我們打印這個類的對象的時候，顯示title值
基於雙下划線的模糊查詢
Book.objects.filter(price__in=[100,200,300]) #price值等於這三個里面的任意一個的對象 Book.objects.filter(price__gt=100) #大於，大於等於是price__gte=100，別寫price>100，這種參數不支持 Book.objects.filter(price__lt=100) Book.objects.filter(price__range=[100,200]) #sql的between and，大於等於100，小於等於200 Book.objects.filter(title__contains="python") #title值中包含python的 Book.objects.filter(title__icontains="python") #不區分大小寫 Book.objects.filter(title__startswith="py") #以什么開頭，istartswith 不區分大小寫 Book.objects.filter(pub_date__year=2012)
日期查詢示例：
# all_books = models.Book.objects.filter(pub_date__year=2012) #找2012年的所有書籍 # all_books = models.Book.objects.filter(pub_date__year__gt=2012)#找大於2012年的所有書籍 all_books = models.Book.objects.filter(pub_date__year=2019,pub_date__month=2)#找2019年月份的所有書籍，如果明明有結果，你卻查不出結果，是因為mysql數據庫的時區和咱們django的時區不同導致的，了解一下就行了，你需要做的就是將django中的settings配置文件里面的USE_TZ = True改為False，就可以查到結果了，以后這個值就改為False，而且就是因為咱們用的mysql數據庫才會有這個問題，其他數據庫沒有這個問題。
四、刪除表紀錄
delete()方法的調用者可以是一個model對象，也可以是一個queryset集合。
刪除方法就是 delete()。它運行時立即刪除對象而不返回任何值。例如：
model_obj.delete()
你也可以一次性刪除多個對象。每個 QuerySet 都有一個 delete() 方法，它一次性刪除 QuerySet 中所有的對象。
例如，下面的代碼將刪除 pub_date 是2005年的 Entry 對象：
Entry.objects.filter(pub_date__year=2005).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() 方法導致 所有的 記錄被誤刪除。如果你確認要刪除所有的對象，那么你必須顯式地調用：
Entry.objects.all().delete()
如果不想級聯刪除，可以設置為:
pubHouse = models.ForeignKey(to='Publisher', on_delete=models.SET_NULL, blank=True, null=True)
五、修改表紀錄
#方式1
Book.objects.filter(title__startswith="py").update(price=120), update只能是querset類型才能調用，model對象不能直接調用更新方法，所以使用get方法獲取對象的時候是不能update的。
#方式2
book_obj = Book.objects.filter(title__startswith="py")
book_obj.price=100
book_obj.save() 這也是修改記錄的一種方式，但是這種方式會將所有字段的數據都重新的賦值一遍（不是是不是需要更新的字段值），效率偏低，但是也是一種方式
此外，update()方法對於任何結果集（QuerySet）均有效，這意味着你可以同時更新多條記錄update()方法會返回一個整型數值，表示受影響的記錄條數。
注意：<input type="date" class="form-control" id="book_pub_date" placeholder="出版日期" name="book_pub_date" value="{{ edit_obj.pub_date|date:'Y-m-d' }}">，type='date'的input標簽，value的值必須是'Y-m-d'的格式，這個標簽才能認識並被賦值，所以，要通過date過濾給它改變格式。
1 圖書管理系統
實現功能：book單表的增刪改查
增：
2 查詢操作練習
1 查詢某某出版社出版過的價格大於200的書籍 2 查詢2017年8月出版的所有以py開頭的書籍名稱 3 查詢價格為50,100或者150的所有書籍名稱及其出版社名稱 4 查詢價格在100到200之間的所有書籍名稱及其價格 5 查詢所有人民出版社出版的書籍的價格（從高到低排序，去重）
關於django連接mysql的時指定嚴格模式的配置
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'mxshop', 'HOST': '127.0.0.1', 'PORT': '3306', 'USER': 'root', 'PASSWORD': '123', 'OPTIONS': { "init_command": "SET default_storage_engine='INNODB'",
#'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
} } } DATABASES['default']['OPTIONS']['init_command'] = "SET sql_mode='STRICT_TRANS_TABLES'"
配置：（自行忽略此處）
LANGUAGE_CODE = 'zh-hans' TIME_ZONE = 'Asia/Shanghai' USE_I18N = True USE_L10N = True USE_TZ = False
#USE_TZ = False #不是跨時區的應用，不需要考慮時區問題，就將這個值改為False，mysql是對時區不敏感，django往mysql里面出數據的時候，如果這里的值為True，那么將讓mysql強制使用UTC時間，那么我們存儲進入的時間，當你查詢的時候，你就會發現，時間晚了8小時，也就是說你存時間的時候被改為了UTC時間，本地是東八區，比UTC時間多8小時