Django基礎之：ORM系統 單表操作

一. ORM簡介

1. web開發的分工模式

1. DBA（數據庫管理員）+應用層開發。

   一般中大型公司（或者數據量巨大、讀取數據的需求頻繁並且追求極致效率的公司）會有專門的DBA管理數據庫，編寫sql語句，對於應用層開發來說，不用寫sql語句，直接調用他寫的接口就行。所以在這種公司一般來說，開發人員應該'供'着DBA，因為你想寫入或者取出的數據需要依賴於DBA去執行，或者是你寫的比較復雜的sql語句需要讓DBA幫你看一下，效率行不行、是不是需要優化等等，這就需要看你們的交情或者其心情了。哈哈（開個玩笑）。

2. 應用程序開發+sql語句編寫。

   這種情況多存在於小公司，沒有專門設置DBA崗位，要求開發人員什么都會一些，linux、數據庫、前端等等，這樣成本降低並且減少由於部門之間的溝通帶來的損失，提高工作流程效率。

3. 應用程序開發+ORM。

   這種模式sql不用你寫，你直接寫類、對象，應為你對這些更加游刃有余。然后通過你寫的類、對象，等等通過相應的轉換關系直接轉化成對應的原生sql語句，這種轉化關系就是ORM：對象-關系-映射。你直接寫一個類就是創建一張表，你實例化一個對象就是增加一條數據，這樣以來，既可以避開寫sql語句的麻煩，而且可以提升我們的開發效率。

2. ORM

• MTV或者MVC框架中包括一個重要的部分，就是ORM，它實現了數據模型與數據庫的解耦，即數據模型的設計不需要依賴於特定的數據庫，通過簡單的配置就可以輕松更換數據庫，這極大的減輕了開發人員的工作量，不需要面對因數據庫變更而導致的無效勞動.
• ORM是“對象-關系-映射”的簡稱。（Object Relational Mapping，簡稱ORM）(將來會學一個sqlalchemy，是和他很像的，但是django的orm沒有獨立出來讓別人去使用，雖然功能比sqlalchemy更強大，但是別人用不了)
• 類對象--->sql--->pymysql--->mysql服務端--->磁盤，orm其實就是將類對象的語法翻譯成sql語句的一個引擎，明白orm是什么了，剩下的就是怎么使用orm，怎么來寫類對象關系語句。

這樣開發效率肯定是提升了，但是也有一點點缺陷就是通過ORM轉化成的sql語句雖然是准確的，但是不一定是最優的。

　

　　原生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()

二、單表操作

1.創建表

1. 首先我們先創建一個ORM項目

在你的app01項目中models就是以后我們創建數據模型的地方。

2. 通過類創建數據表

從django.db 引入models模塊，創建表通過構建一個類去設定，數據庫中不區分大小寫，所以你的UserInfo在數據庫中直接編譯成了userinfo，此類必須繼承models.Model類，通過設定類的靜態屬性就會轉化成sql語句。

from django.db import models
# Create your models here.


class UserInfo(models.Model):
    """
    下面幾個類的屬性通過ORM映射就對應成了：
    create table userinfo(
        id int primary key auto_increment,
        name varchar(16),
        age int,
        current_date date)
    """
    id = models.AutoField(primary_key=True)

    name = models.CharField(max_length=16)

    age = models.IntegerField()

    current_date = models.DateField()

3. 在對應的數據庫中生成表結構

上面我們已經通過類構建了一個表，但是還沒有對應的生成真實的數據庫中的表結構，所以我們要將上面的類生成真生的數據庫中的表結構。對應只有行代碼。

在terminal輸入指令：

python manage.py makemigrations

我這里使用的是python3.6 是因為python版本較多，環境變量python3.6指向的是python3.6.8的解釋器。

然后你看你的app01下面的migrations出現一個0001_initial.py的文件，這個文件是你執行了上述指令之后產生的腳本文件，這個文件就是一個記錄。

接下來我們繼續輸入指令：

python manage.py migrate

這個指令其實就是執行第一個指令生成的記錄也就是那個腳本文件，然后就會在你對應的數據庫中生成一個真正的表，生成的表名字前面會自帶應用的名字，例如：你的userinfo表在數據表里面叫做：app01_userinfo。

在執行 python manager.py makemigrations時
Django 會在相應的 app 的migrations文件夾下面生成 一個python腳本文件 
    
在執行 python manager.py migrate 時 Django才會生成數據庫表，那么Django是如何生成數據庫表的呢?

Django是根據 migrations下面的腳本文件來生成數據表的
    每個migrations文件夾下面有多個腳本，那么django是如何知道該執行那個文件的呢，django有一張django-migrations表，表中記錄了已經執行的腳本，那么表中沒有的就是還沒執行的腳本，則 執行migrate的時候就只執行表中沒有記錄的那些腳本。
    有時在執行 migrate 的時候如果發現沒有生成相應的表，可以看看在 django-migrations表中看看 腳本是否已經執行了，
    可以刪除 django-migrations 表中的記錄 和 數據庫中相應的 表 ， 然后重新 執行

那么我們的數據表創建在那個數據庫中了呢？我們之前沒有給Django配置數據庫呀？ 其實Django給我們默認配置了一個小型的數據庫sqlit3，下面我們就會講到。

4. 小型數據庫sqlite3

我們先簡單提一下這個小型數據庫sqlite3，sqlite3數據庫是Django給我們提供的一個數據庫，一般工作中我們不會用這個數據庫，這個數據庫就是為了我們測試使用的。這個數據庫就在我們的目錄中：

我們的數據庫是分為客戶端和服務端的，現在只是將uerinfo表結構存儲記錄到我們的客戶端上了，我們連接上在本機的sqlit3的服務端，才算是真正的創建了表結構。想要使用sqlit3服務端並且啟動，先要在這個位置下載並安裝對應的引擎：

這樣，你的sqlit3服務端已經下載並安裝成功了，接下來交給大家一個騷操作，將目錄里面的sqlite3，拖拽到database中，這樣客戶端與服務端就連接成功了，就可以看到你剛才創建的那張表了。 

 我們看一下，這里有你的app01_userinfo這張表（app01是你在創建userinfo表時Django幫你自動拼接上的並且全部都是小寫了），還有一些藍色區域框起來的表，我們只是創建了一張表，為什么多出這么多張表結構了呢？

因為我們當初注冊app01時，其實DJango已經注冊了很多其他的內置應用，當我們執行migrations指令時，這些內置應用下面的models表也就一並注冊了。我們現在知道我們創建的表成功了即可，其他的以后我們會講到。

我們點擊app01_userinfo這張表看一下：

 這個已經有了我們之前創建的字段了，這個與我們之前講的Navicat可視化工具比較類似，也可以手動添加更新數據。

但是我們工作中是要與類似於MySQL這樣的數據庫連接的，我們不用sqlits操作，剛才只是測試一下，接下來我們把這個連接刪除，配置MySQL。

 5. 配置MySAL數據庫

若想將模型轉為mysql數據庫中的表，需要在settings中配置：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME':'ormtest',     　　 　  # 要連接的數據庫，連接前需要創建好
        'USER':'root',　　　　　　  # 連接數據庫的用戶名
        'PASSWORD':'',　　　　　　  # 連接數據庫的密碼
        'HOST':'127.0.0.1',       # 連接主機，默認本級
        'PORT'：3306    　　　     #  端口 默認3306
    }
}

上面是給項目中的所有的應用都配置成MySQL數據庫，當然我們也可以給單個應用配置數據庫：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME':'ormtest',     　　 　  # 要連接的數據庫，連接前需要創建好
        'USER':'root',　　　　　　  # 連接數據庫的用戶名
        'PASSWORD':'',　　　　　　  # 連接數據庫的密碼
        'HOST':'127.0.0.1',       # 連接主機，默認本級
        'PORT'：3306    　　　     #  端口 默認3306
    }，
    'app01': { #可以為每個app都配置自己的數據，並且數據庫還可以指定別的，也就是不一定就是mysql，也可以指定sqlite等其他的數據庫
        'ENGINE': 'django.db.backends.mysql',
        'NAME':'ormtest',     　　 　  # 要連接的數據庫，連接前需要創建好
        'USER':'root',　　　　　　  # 連接數據庫的用戶名
        'PASSWORD':'',　　　　　　  # 連接數據庫的密碼
        'HOST':'127.0.0.1',       # 連接主機，默認本級
        'PORT'：3306    　　　     #  端口 默認3306
    }
}

app配置單獨的數據庫

注意：NAME即數據庫的名字，在mysql連接前該數據庫必須已經創建，而上面的sqlite數據庫下的db.sqlite3則是項目自動創建 USER和PASSWORD分別是數據庫的用戶名和密碼。設置完后，再啟動我們的Django項目前，我們需要激活我們的mysql。接下來，我們要提前先給mysql創建ormtest的數據庫。

從終端進入mysql，創建ormtest數據庫：

create database ormtest;

以后工作中，一般有一個項目設置一個庫，或者一個應用設置一個庫，這得看自己公司具體情況。

從settings文件配置數據庫：

pass

Django項目連接數據庫：

　　現在必要的參數我們都配置好了，但是我們如何讓你的項目連接數據庫？怎么連接呢？django默認你導入的驅動是MySQLdb，可是MySQLdb 對於py3.4+版本有很大問題，所以我們需要的驅動是PyMySQL。所以，我們只需要找到項目名文件下的__init__,在里面寫入：

 

 

再次生成表記錄，創建數據表

可以通過pycharm給你們提供的功能，進行構建記錄以及創建數據表：

 

 

 或者是通過指令的形式：

python manage.py makemigrations

python manage.py migrate

這樣，我們在打開我們的MySQL的ormtest數據庫，看看是否創建成功了：

 OK，這樣你的你的數據庫表就匹配成功啦！

6.更多的字段和參數

　　每個字段有一些特有的參數，例如，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(),
        )

關於auto_now和auto_now_add

ORM字段與實際的mysql字段對應關系

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

 2. 增：添加表記錄

首先我們先要做一個簡單的流程，方便我們測試：

#url:

urlpatterns = [

    url(r'^index/', views.index),
]

# views:

def index(request):

    return render(request,'index.html')

# html:
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" rel="stylesheet">


</head>
<body>
<h1>歡迎訪問index頁面</h1>


</body>
</html>

然后我們通過在index函數中構建一些邏輯，展示我們對單表的增刪改查。在研究增刪改查之前我們一定要明確ORM的對應關系：

在python中orm的對應關系有三種：

　　　　類          ---------->    表

　　　　類的對象 ---------->    行(記錄)

　　　　類的屬性 ---------->    表的字段（重點）

我們要想操作一行的數據，就應該將相應的類引入，然后通過實例化對象增加數據。接下來，我們重新創建一個數據庫為orm01，創建一個student表結構，從這個表中去研究單表的操作。

這里需要注意：

1. 更改settings里面的數據庫配置：orm01.

2. 在models文件中創建student類：

class Student(models.Model):

    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    age = models.IntegerField()

3. 生成記錄並且創建表結構

python manage.py makemigrations

python manage.py migrate

接下來我們就開始研究如何增加表記錄。

方式1

從index函數中操作：

def index(request):
    # 實例化一個對象這就是一條記錄
    student_obj = models.Student(
        name='王闊',
        age=18
    )
    # 將此記錄增加到數據表中
    student_obj.save()
    return render(request,'index.html')

查看數據表：我們添加成功了。

方式2

我們通過方式1給student表中添加了一條表記錄，但是上面那種方法不靈活，接下來我們介紹一種更加靈活的方法。

models.Student.objects

objects比較特殊，我們稱它為類對應的控制器，這個控制器對象可以調用數據表相應的增刪改查等方法，非常靈活。

models.Student.objects.create(
        name='傻強',
        age=20
    )

這樣以來我們就添加成功了：

 

而且我們通過查詢create方法的源碼可以得知：

Creates a new object with the given kwargs, saving it to the database and returning the created object.

他可以創建一個新的對象保存到相應的數據表中，並且返回這個新創建的對象。那么接下來我們查看一下他的返回值並輸入一下：

這樣它既向我們的數據表中添加了值，又將創建的對象返回了：

new_obj = models.Student.objects.create(
        name='志遠',
        age=19
    )
print(new_obj)  # Student object
print(new_obj.name)  # 志遠

 

 那么，以后我們就將這中（models類的對象）稱之為model對象。（很重要一定要記住）

方式3：批量創建

我們以后工作中肯定會讓你批量插入很多數據，怎么解決？有同學肯定會說循環create，但是每次create都需要操作數據庫，這是一個IO操作，如果這樣的話數據量越大，你的效率越低。所以針對這種情況我們可以通過批量創建。

假如我們依次插入20條數據：

obj_list = [models.Student(name=f'喬妹兒{i}', age=20) for i in range(1, 21)]
models.Student.objects.bulk_create(obj_list)

 

 方式4:更新或增加

orm還有一種方法是對一條表記錄進行更新或者增加的操作：有則更新無則增加，類似於字典的這個操作dic['name'] = 'barry'。

models.Student.objects.update_or_create(
        name='喬妹兒1',  # 篩選條件
        defaults={  # 需要更新或者增加的值
            'age': 1000,
        }

    )

 3. 簡單的查詢

本來我們應該研究刪除表記錄，但是我們這里先要研究幾個簡單的查詢，因為這些查詢返回兩種特殊的對象，對於不同的對象他們的刪、改的的方法不同。

1.all()全部取出 

 通過all從orm取出來的是一個QuerySet類型，這里面有很多個Student類的對象也就是model對象，這個QuerySet類似於列表，但是不同與列表，后面我們會詳細對比討論，在這里我們知道可以循環遍歷取值即可。

index函數： 
all_objs = models.Student.objects.all()
    print(all_objs)  # QuerySet類型 這里面有很多個Student類的對象也就是model對象。
    '''
    < QuerySet[ < Student: Student
    object >, < Student: Student
    object >, < Student: Student
    object >,...'...(remaining elements truncated)...']>
    '''
    # 通過遍歷可以獲取每個對象的name屬性
    for i in all_objs:
        print(i.name)

 

model對象與queryset集合是我們經常用的兩個對象，一定要分清楚。

上面我們for循環遍歷時，每次都需要.name獲取name屬性，比較麻煩，我們可以不可以直接打印對象獲取對應的姓名呢？這就要想到特殊的雙下方法__str__.我們可以在Student類中定一個__str__方法，這樣以后我們就可以用於調試了。

class Student(models.Model):

    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    age = models.IntegerField()

    def __str__(self):
        return self.name

2.filter(條件) 條件查詢

通過條件查詢獲取結果，返回的也是QuerySet類型，如果查詢不到內容不會報錯，返回一個空的QuerySet集合。

objs = models.Student.objects.filter(age=20)
print(objs)
'''
<QuerySet [<Student: 傻強>, <Student: 喬妹兒2>, <Student: 喬妹兒3>, <Student: 喬妹兒4>, <Student: 喬妹兒5>, <Student: 喬妹兒6>, <Student: 喬妹兒7>, <Student: 喬妹兒8>, <Student: 喬妹兒9>, <Student: 喬妹兒10>, <Student: 喬妹兒11>, <Student: 喬妹兒12>, <Student: 喬妹兒13>, <Student: 喬妹兒14>, <Student: 喬妹兒15>, <Student: 喬妹兒16>, <Student: 喬妹兒17>, <Student: 喬妹兒18>, <Student: 喬妹兒19>, <Student: 喬妹兒20>]>
'''
objs = models.Student.objects.filter(id=2)
print(objs)  # <QuerySet [<Student: 傻強>]>
print(objs[0].id)  # 2 可以通過索引取值

objs = models.Student.objects.filter(name='太白')
print(objs) # <QuerySet []>

3.get(條件) 條件查詢

這個get比較特殊，它返回的是model對象，通過get條件查詢，查詢的結果有且只有1個。

　　如果超過一個則報錯為：get() returned more than one Student -- it returned 2(有幾個顯示幾個)!

　　如果沒有則報錯為：Student matching query does not exist.

# obj = models.Student.objects.get(name='太白')  # 報錯：Student matching query does not exist.
# obj = models.Student.objects.get(age=20)  # get() returned more than one Student -- it returned 20!
obj = models.Student.objects.get(id=1)
print(obj)  # model對象

所以一般如果我們使用get條件查詢，前提一定要確定你的條件鎖定的就是一條行記錄。

4. 刪：刪除行記錄

刪除就要從你的對象性質來討論了。

1. 調用model對象刪除

這樣就是刪除單條記錄

models.Student.objects.get(id=20).delete()

 2.調用QuerySet集合刪除

這樣就是批量刪除記錄，滿足條件的記錄都會被刪除。

models.Student.objects.filter(age=20).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)

5.改：更新行記錄

更新記錄的方法只有一個就是update，此方法只能用於QuerySet集合，model對象是不可以使用的。也就是說update可以進行批量更新的操作，並且他會返回一個更新的行記錄數量的返回值。

# 我先增加了一條name一樣的行記錄 
'''
# models.Student.objects.create(
       name='喬妹兒1',
       age=100    )

'''

count = models.Student.objects.filter(name='喬妹兒1').update(age=20)
print(count)  # 2 更新了2條

6.查：查看(獲取)行記錄

查詢是數據庫增刪改查的重中之重，方法非常多，大家一定要好好練習。前三個我們都練習過了可以在練習一遍。

1.all()全部取出 

 通過object控制器調用，返回QuerySet類型。

通過all從orm取出來的是一個QuerySet類型，這里面有很多個Student類的對象也就是model對象，這個QuerySet類似於列表，但是不同與列表，后面我們會詳細對比討論，在這里我們知道可以循環遍歷取值即可。

index函數： 
all_objs = models.Student.objects.all() print(all_objs) # QuerySet類型 這里面有很多個Student類的對象也就是model對象。 ''' < QuerySet[ < Student: Student object >, < Student: Student object >, < Student: Student object >,...'...(remaining elements truncated)...']> ''' # 通過遍歷可以獲取每個對象的name屬性 for i in all_objs: print(i.name)

 

model對象與queryset集合是我們經常用的兩個對象，一定要分清楚。

2.filter(條件) 條件查詢

 通過object控制器調用，返回QuerySet類型。

通過條件查詢獲取結果，返回的也是QuerySet類型，如果查詢不到內容不會報錯，返回一個空的QuerySet集合。

objs = models.Student.objects.filter(age=20)
print(objs) ''' <QuerySet [<Student: 傻強>, <Student: 喬妹兒2>, <Student: 喬妹兒3>, <Student: 喬妹兒4>, <Student: 喬妹兒5>, <Student: 喬妹兒6>, <Student: 喬妹兒7>, <Student: 喬妹兒8>, <Student: 喬妹兒9>, <Student: 喬妹兒10>, <Student: 喬妹兒11>, <Student: 喬妹兒12>, <Student: 喬妹兒13>, <Student: 喬妹兒14>, <Student: 喬妹兒15>, <Student: 喬妹兒16>, <Student: 喬妹兒17>, <Student: 喬妹兒18>, <Student: 喬妹兒19>, <Student: 喬妹兒20>]> ''' objs = models.Student.objects.filter(id=2) print(objs) # <QuerySet [<Student: 傻強>]> print(objs[0].id) # 2 可以通過索引取值  objs = models.Student.objects.filter(name='太白') print(objs) # <QuerySet []>

還可以進行多條件查詢：

# 先插入一些數據：
'''
    models.Student.objects.create(
        name='董偉華',
        age=19
    )
    models.Student.objects.create(
        name='周澤波',
        age=21
    )
    models.Student.objects.create(
        name='健身哥',
        age=18
    )
    models.Student.objects.create(
        name='張雨薇',
        age=20
    )
    models.Student.objects.create(
        name='王天琪',
        age=21
    )
    models.Student.objects.create(
        name='梁晨',
        age=18
    )
    models.Student.objects.create(
        name='扛把子',
        age=22
    )
    models.Student.objects.create(
        name='齊佳樂',
        age=20
    )
    '''
    objs = models.Student.objects.filter(name='健身哥', age=18)
    print(objs)  # <QuerySet [<Student: 健身哥>]>

還可以通過打散字典的形式進行篩選

models.Student.objects.filter(**{'id':27,'name':'健身哥','age':18}).update(age=20)

 

 

 注意：

　　1. 一定要記住每個方法是通過哪種類型調用，以及返回哪種類型。這樣我們方便可以通過鏈式點的操作進行復雜查詢。

　　2. filter一種是關鍵字形式，一個是字符串形式，很重要，這兩個就可以解決不同的需求了。

3.get(條件) 條件查詢

通過object控制器調用，返回model對象

這個get比較特殊，它返回的是model對象，通過get條件查詢，查詢的結果有且只有1個。

　　如果超過一個則報錯為：get() returned more than one Student -- it returned 2(有幾個顯示幾個)!

　　如果沒有則報錯為：Student matching query does not exist.

# obj = models.Student.objects.get(name='太白')  # 報錯：Student matching query does not exist.
# obj = models.Student.objects.get(age=20)  # get() returned more than one Student -- it returned 20!
obj = models.Student.objects.get(id=1)
print(obj)  # model對象

所以一般如果我們使用get條件查詢，前提一定要確定你的條件鎖定的就是一條行記錄。

4.exclude排除

通過object對象或者QuerySet集合調用，返回QuserySet集合。

下面我們演示了上面說到的鏈式點操作，可以一直進行點的操作，因為此方法可以QuerySet集合調用，並且返回的還是QuerySet集合。

objs = models.Student.objects.exclude(id=1)
print(objs)

# 排除id為1的行記錄，將剩下所有的返回

objs = models.Student.objects.filter(age=20).exclude(name='齊佳樂')
print(objs)  # <QuerySet [<Student: 喬妹兒1>, <Student: 喬妹兒1>, <Student: 健身哥>, <Student: 張雨薇>]>
objs = models.Student.objects.filter(age=20).exclude(name='齊佳樂').exclude(name='健身哥')
print(objs)  # <QuerySet [<Student: 喬妹兒1>, <Student: 喬妹兒1>,  <Student: 張雨薇>]>

5.order_by排序

通過object對象或者QuerySet集合調用，返回QuserySet集合。

# object對象調用
objs = models.Student.objects.order_by('age')  # 通過姓名升序排列
print(objs)

# queryset集合調用
objs = models.Student.objects.all().order_by('age')  # 通過姓名升序排列
print(objs)

通過年齡升序排列,相同年齡的按照id降序排列：

objs = models.Student.objects.all().order_by('age', '-id')
print(objs)

打印結果：
<QuerySet [<Student: id:30 name:梁晨 age:18>, <Student: id:1 name:王闊 age:18>, <Student: id:25 name:董偉華 age:19>, <Student: id:3 name:志遠 age:19>, <Student: id:32 name:齊佳樂 age:20>, <Student: id:28 name:張雨薇 age:20>, <Student: id:27 name:健身哥 age:20>, <Student: id:24 name:喬妹兒1 age:20>, <Student: id:4 name:喬妹兒1 age:20>, <Student: id:29 name:王天琪 age:21>, <Student: id:26 name:周澤波 age:21>, <Student: id:31 name:扛把子 age:22>]>

6.reverse反轉

通過order_by返回的QuerySet集合調用，返回一個QuerySet集合。

objs = models.Student.objects.reverse()
print(objs)  # 這樣沒有作用，all filter等都沒有作用
objs = models.Student.objects.order_by('id').reverse()  # 只能通過order_by返回的QuerySet集合調用
print(objs)

7.count計數

通過QuerySet集合調用，返回一個元素個數。

num = models.Student.objects.all().count()
print(num)  # 12
num = models.Student.objects.filter(age=20).count()
print(num)  # 5

8.first返回第一個model對象

通過QuerySet集合調用，返回第一個model對象

obj = models.Student.objects.filter(age=20).first()
print(obj)

9.last返回最后一個model對象

通過QuerySet集合調用，返回最后一個model對象

obj = models.Student.objects.filter(age=20).last()
print(obj)

10.exists判斷是否存在

通過QuerySet集合調用，返回bool值

flag = models.Student.objects.filter(age=25).exists()
print(flag)  # False

這里我們要說一句，他的效率是高的，尤其是作為if判斷的條件。

# 雖然說你可以通過下面的方式判斷，但是如果這個集合一下取出上百萬條數據，那么你的效率就很低的，而exists翻譯成sql語句是limit=1，也就是說它只看第一個對象存不存在就返回bool值了。
if Queryset集合：
    pass

我們也可以通過配置settings，每次執行orm語句時都將相應的sql語句展示出來，這樣可以查看一下exists().

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

再次執行一次：

 11.values_list

通過QuerySet集合調用，返回一個QuerySet集合

但是這個QuerySet集合比較特殊，這個里面的元素不是model對象，而是元組的形式。

query_tuple = models.Student.objects.filter(age=20).values_list()
print(query_tuple)
# <QuerySet [(4, '喬妹兒1', 20), (24, '喬妹兒1', 20), (27, '健身哥', 20), (28, '張雨薇', 20), (32, '齊佳樂', 20)]>
query_tuple = models.Student.objects.filter(age=20).values_list().exclude(name='齊佳樂')
print(query_tuple)
# < QuerySet[(4, '喬妹兒1', 20), (24, '喬妹兒1', 20), (27, '健身哥', 20), (28, '張雨薇', 20)] >

還可以指定想獲取的字段：

query_tuple = models.Student.objects.filter(age=20).values_list('name','age')
print(query_tuple)
# <QuerySet [('喬妹兒1', 20), ('喬妹兒1', 20), ('健身哥', 20), ('張雨薇', 20), ('齊佳樂', 20)]>

12.values

通過QuerySet集合調用，返回一個QuerySet集合

但是這個QuerySet集合比較特殊，這個里面的元素不是model對象，而是字典的形式。

query_dict = models.Student.objects.filter(age=19).values()
print(query_dict)  # <QuerySet [{'id': 3, 'name': '志遠', 'age': 19}, {'id': 25, 'name': '董偉華', 'age': 19}]>
query_dict = models.Student.objects.filter(age=19).values('name', 'age')
print(query_dict)  # <QuerySet [{'name': '志遠', 'age': 19}, {'name': '董偉華', 'age': 19}]>

13.distinct去重

通過QuerySet集合調用，返回一個QuerySet集合

這里要注意一點：無論是all還是filter 你對整個對象去重是沒有意義的，只要有一個字段不同，都不是重復的。

query_objs = models.Student.objects.filter(age=20).distinct()
print(query_objs)
# <QuerySet [<Student: id:4 name:喬妹兒1 age:20>, <Student: id:24 name:喬妹兒1 age:20>, <Student: id:27 name:健身哥 age:20>, <Student: id:28 name:張雨薇 age:20>, <Student: id:32 name:齊佳樂 age:20>]>

所以這個去重一般都用於values或者values_list。

query_objs = models.Student.objects.filter(age=20).values('age').distinct()
print(query_objs) # <QuerySet [{'age': 20}]>

14.基於雙下划線的模糊查詢

我們在使用filter方法時，一直在使用 = 條件，但是沒有使用過> < >=等條件，這是因為ORM不支持這種寫法，不用着急，我們可以根據另一種寫法去實現。

query_objs = models.Student.objects.filter(age__gt=19)  # 大於
query_objs = models.Student.objects.filter(age__gte=19)  # 大於等於
query_objs = models.Student.objects.filter(age__lt=20)  # 小於
query_objs = models.Student.objects.filter(age__lte=20)  # 小於等於
query_objs = models.Student.objects.filter(age__range=[18, 20])  # 范圍 左右都包含
query_objs = models.Student.objects.filter(name__contains='xiao')  # 針對字符串類型，內容含有
query_objs = models.Student.objects.filter(name__icontains='xiao')  # 針對字符串類型，內容含有 不區分大小寫
query_objs = models.Student.objects.filter(name__startswith='x')  # 匹配以x開頭
query_objs = models.Student.objects.filter(name__istartswith='x')  # 匹配以x開頭，不區分大小寫
query_objs = models.Student.objects.filter(name__endswith='o')  # 匹配以x結尾
query_objs = models.Student.objects.filter(name__iendswith='o')  # 匹配以x結尾，不區分大小寫
    

15.日期

日期這個字段查詢起來比較特殊，我們單獨拿出來講解，現在我們要重新創建一個表。

class Birthday(models.Model):

    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    date = models.DateField()

    def __str__(self):
        return self.name

別忘了生成記錄以及創建到數據庫中。

查看一下表結構：

注意date字段，這個字段要求的是date類型，我們如果存放的是datetime類型也是可以的，只不過只是顯示年月日。 

接下來我們給表中插入一些數據：

import datetime

    models.Birthday.objects.create(name='太白1', date=datetime.datetime.now())
    models.Birthday.objects.create(name='太白2', date='2000-04-25')
    models.Birthday.objects.create(name='太白3', date='2000-06-25')
    models.Birthday.objects.create(name='太白4', date='2000-08-26')
    models.Birthday.objects.create(name='太白5', date='2000-12-28')
    models.Birthday.objects.create(name='太白6', date='2001-03-26')
    models.Birthday.objects.create(name='太白7', date='2001-08-30')
    models.Birthday.objects.create(name='太白8', date='2003-01-13')
    models.Birthday.objects.create(name='太白9', date='2005-10-01')

對應的數據庫的數據為：

 

查詢2000年出生的人，這樣寫就會報錯了：

 query_objs = models.Birthday.objects.filter(date='2000')
 print(query_objs)  
 # "'2000' value has an invalid date format. It must be in YYYY-MM-DD format."]

查詢2000年出生的人：

query_objs = models.Birthday.objects.filter(date__year='2000')
print(query_objs)  # <QuerySet [<Birthday: 太白2>, <Birthday: 太白3>, <Birthday: 太白4>, <Birthday: 太白5>]>
 

查詢2000年4月出生的人：

query_objs = models.Birthday.objects.filter(date__year='2000',date__month='04')
print(query_objs)  # <QuerySet [<Birthday: 太白2>]>

查詢2000年大於4月小於12月出生的人：

query_objs = models.Birthday.objects.filter(date__year='2000', date__month__gt='04',date__month__lt='12')
print(query_objs)  # <QuerySet [<Birthday: 太白3>, <Birthday: 太白4>]>