模型

模型使用步驟：

1. 配置資料庫
2. models.py定義模型類
3. 啟用模型
4. 使用模型

Django預設使用的是sqlite，但在生產環境中⼀般會用mysql、postgrsql、oracle
等關係型資料庫。

1.資料庫配置

在虛擬開發環境中，安裝mysql的資料庫驅動mysqlclient

pip install mysqlclient

在專案的 settings.py 檔案中找到 DATABASES 配置項，將其資訊修改為：

DATABASES = {
 'default': {
 'ENGINE': 'django.db.backends.mysql', #mysql資料庫引擎
 'NAME': 'test', #資料庫名
 'HOST':'localhost', #資料庫伺服器地址
 'USER': 'test', #mysql資料庫使用者名稱
 'PASSWORD': 'test123', #密碼
 'PORT':3306, #端⼝號，可選
 }
}
 

2.ORM

物件關係對映（Oject Relational Mapping，簡稱ORM）模式是⼀種為了解決面向
物件與關係資料庫存在的互不匹配的現象的技術。簡單的說，ORM是通過使用描
述物件和資料庫之間對映的元資料，自動生成sql語句，將程式中的物件自動儲存
到關係資料庫中。

優點：

• 隱藏了資料庫訪問的細節，簡化了sql的使用，提高了開發效率
• 解耦業務邏輯層（view）和資料處理層（model)，簡化了開發流程，提高了
  系統的可移植性
• 提高了安全性

缺點：

• 執行效率低
• 對複雜sql⽆能為力
• 增加了學習成本

2.1 基本概念

• ⼀個模型類對應⼀個表
• 每個模型類都必須繼承django.db.models.Model

2.2 模型屬性

模型中的屬性和資料庫表的欄位對應，必須定義。模型的屬性需要定義成類屬性

#屬性定義語法為：
屬性 = models.欄位型別(選項)

• 屬性命名規則：
  • 不能是python的保留關鍵字
  • 不允許使用連續的下劃線，因為連續下劃線在查詢中會用到
  • 定義屬性時需要指定欄位型別
  • 主鍵⼀般不用自己定義，django會自動建立自增長主鍵列，如果你自己定
    義了主鍵，則django不會再自動生成主鍵

2.2.1欄位型別

• auto_now: 每次儲存物件時，自動設定該欄位為當前時間，用於"最後⼀次修
  改"的時間戳，它總是使用當前⽇期，預設為false
• auto_now_add: 當物件第⼀次被建立時自動設定當前時間，用於建立的時間
  戳，它總是使用當前⽇期，預設為false

2.2.2 欄位選項

適用於任何欄位，可以實現欄位的約束，在生成欄位時通過方法的關鍵字引數指
定。

3.定義模型

我們可以在應用的models.py中定義模型：

from django.db import models
class 模型名(models.Model):

    屬性名 = models.欄位名(欄位選項/引數)
     .....
     class Meta: #可選，任何⾮欄位的設定可以寫到Meta中
         db_table = 'user' #指定表名為uesr

• 資料庫的表名等於：應用名_模型名，如果想指定表名，可以在Meta中使用
  db_table指定

• 如果沒有指定主鍵，Django將自動給表建立⼀個自增⻓主鍵id

  id = models.AutoField(primary_key=True)
  

• Meta中常用設定：

下面我們定義幾個模型類

from django.db import models
from django.utils import timezone

#使用者類
class User(models.Model):
     uid = models.AutoField(primary_key=True) #自增主鍵
     uname = models.CharField(max_length=60)
     password = models.CharField(max_length=32)
     user_type = ((1,'超級管理員'),(2,'普通使用者'))
     type = models.IntegerField(default=2,choices=user_type)
     regtime = models.DateTimeField(default=timezone.now) #預設值是當
    前時間
    ip = models.IntegerField(null=True)
     login_type = ((1,'允許登入'),(2,'禁⽌登入')) #使用者自定義型別對應
    mysql的enum型別
     allowed = models.IntegerField(default=1,choices=login_type)
     email = models.CharField(max_length=100,null=True)
     memo = models.CharField(max_length=1000,null=True)
         class Meta:
         db_table = 'user' #表名

4.啟用模型

• 建立遷移檔案 （此刻表並沒有建立到庫中）

  $ python manage.py makemigrations
  

• 執行遷移 （將模型建立到庫中）

  $ python manage.py migrate
  

然後在應用的migrations目錄中應該生成了遷移檔案

├── app
│ ├── admin.py
│ ├── apps.py
│ ├── __init__.py
│ ├── migrations
│ │ ├── 0001_initial.py
│ │ ├── __init__.py

生成的表結構如下：

注意：任何對欄位或表的修改都需要重新遷移

• 反向遷移

  可以根據資料庫中表自動建立模型

python manage.py inspectdb > App/models.py

5.模型的使用

我們可以再互動式Python shel環境中，使用Django提供的免費API。要呼叫
Python shell，請使用以下命令：

$ python manage.py shell
Python 3.6.4 (default, Sep 13 2018, 02:27:17)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more
information.
(InteractiveConsole)
>>>

5.1 增刪改

>>> from app.models.User import User #匯入User模型
>>> from hashlib import md5

>>> user = User(uname='admin',password=md5(b'123').hexdigest()) #實
例化⼀個新物件
>>> user.save() #insert 插入資料庫
>>> user.uid #顯示uid的值
 4
#在mysql中查詢新插入的記錄
mysql> select uid,uname,password,type,allowed from user;
+-----+--------------+----------------------------------+------------
--+--------------+
| uid | uname | password | type | allowed |
+-----+--------------+----------------------------------+------------
--+--------------+
| 1 | dddddksdf | bc9858af5f37d3cf147a3923c8b9a3d9 | 普通使用者

| 允許登入 |
| 2 | tom123 | 59f2443a4317918ce29ad28a14e1bdb7 | 普通使用者

| 允許登入 |
| 3 | 隔壁⽼王 | 1e9ce4a8f8c6b2baa00b1783de4b0ef0 | 普通使用者

| 允許登入 |
| 4 | admin | 202cb962ac59075b964b07152d234b70 | 普通使用者

| 允許登入 |
+-----+--------------+----------------------------------+------------
--+--------------+
4 rows in set (0.00 sec)
#便捷插入
>>> User.objects.create(username='媽咪哄',password='111')
#批量插入記錄(不⽀持多對多)
>>> User.objects.bulk_create(User.objects.create(username='哈
哈',password='111'),User.objects.create(username='嘻
嘻',password='111'))
>>> u1 = User.objects.get(pk=1) #獲取uid=1的記錄
>>> u1.uid
1
>>> u1.delete() #刪除該記錄
(1, {'app.Comment': 0, 'app.User': 1})
#查詢mysql
mysql> select uid,uname,password,type,allowed from user;
+-----+--------------+----------------------------------+------------
--+--------------+
| uid | uname | password | type
 | allowed |
+-----+--------------+----------------------------------+------------
--+--------------+
| 2 | tom123 | 59f2443a4317918ce29ad28a14e1bdb7 | 普通使用者

| 允許登入 |
| 3 | 隔壁⽼王 | 1e9ce4a8f8c6b2baa00b1783de4b0ef0 | 普通使用者

| 允許登入 |
| 4 | admin | 202cb962ac59075b964b07152d234b70 | 普通使用者

| 允許登入 |
+-----+--------------+----------------------------------+------------
--+--------------+
3 rows in set (0.00 sec)
# 修改單條記錄
>>> u2 = User.objects.get(pk=2)
>>> u2.uname = '小甜甜' #update 更新
>>> u2.save()
# 修改多條記錄
>>> users = User.objects.all()
>>> users.update(password=md5(b'345').hexdigest())
#查詢mysql
mysql> select uid,uname,password,type,allowed from user;
+-----+--------------+----------------------------------+------------
--+--------------+
| uid | uname | password | type
 | allowed |
+-----+--------------+----------------------------------+------------
--+--------------+
| 2 | 小甜甜 | 59f2443a4317918ce29ad28a14e1bdb7 | 普通使用者

| 允許登入 |
| 3 | 隔壁⽼王 | 1e9ce4a8f8c6b2baa00b1783de4b0ef0 | 普通使用者

| 允許登入 |
| 4 | admin | 202cb962ac59075b964b07152d234b70 | 普通使用者

| 允許登入 |
+-----+--------------+----------------------------------+------------
--+--------------+
3 rows in set (0.00 sec)

• 資料的邏輯刪除

  對於重要資料，⼀般不會直接刪除，會在表中增加⼀個欄位比如：
  is_deleted，如果刪除的話，將這個欄位置為True，以後查詢的時候不在查
  詢，這種操作稱為邏輯刪除

5.2 資料查詢

要從資料庫檢索資料，⾸先要獲取⼀個查詢集(QuerySet)，查詢集表示從資料庫獲
取的物件集合，它可以有零個，⼀個或多個過濾器。返回查詢集的方法，稱為過濾
器，過濾器根據給定的引數縮小查詢結果範圍，相當於sql語句中where或limit。

• 在管理器上呼叫過濾器方法會返回查詢集
• 查詢集經過過濾器篩選後返回新的查詢集，因此可以寫成鏈式過濾
• 惰性執行：建立查詢集不會帶來任何資料庫的訪問，直到呼叫資料時，才會訪
  問資料庫
• 以下對查詢集求值：迭代、切片、序列化、與if合用、
  repr()/print()/len()/list()/bool()

5.2.1 返回查詢集

• all()

  # 獲取所有資料，對應SQL：select * from User
  User.objects.all()
  

• filter(**kwargs)返回QuerySet包含與給定查詢引數匹配的新查詢集。

  #等價sql：select * from User
  User.objects.filter()
  #等價sql：select * from User where uname = 'admin'
  User.objects.filter(uname='admin')
  #等級sql：select * from User where uid > 1 and type = 2
  User.objects.filter(uid__gt=1,type=2)
  #鏈式呼叫，等價於User.objects.filter(uid__gt=1,type=2)
  User.objects.filter(uid__gt=1).filter(type=2)
  

• exclude(**kwargs)

  # 不匹配，對應SQL：select * from User where name != 'admin'
  User.objects.exclude(name='admin')
  

• order_by(*fields)

  • 引數是欄位名，可以有多個欄位名，預設是升序。
  • 如果要按某個欄位降序，在欄位名前加'-'： "-uid"表示按uid降序排列

  #按uid升序排列
  
  等價於 order by uid
   User.objects().order_by('uid')
   #按uid降序排列
  
  等價於 order by uid desc
   User.objects.order_by('-uid')
   #多列排序 等價於 order by password,uid desc
   User.objects.order_by('password','-uid')
  

• values()

  #返回所有欄位
  User.objects.values()
  #返回資料：
  [{'uid': 2, 'uname': '小甜甜', 'password':
  '59f2443a4317918ce29ad28a14e1bdb7'type': '普通使用者', 'regtime':
  None, 'ip': None, 'allowed': '允許登入', 'email': None, None},...]
  #返回指定欄位
  User.objects.values('uname','password')
  [{'uname': '小甜甜', 'password':
  '59f2443a4317918ce29ad28a14e1bdb7'},...]
  

• reverse()

  User.objects.order_by('id').reverse() 降序
  User.objects.order_by('-id').reverse() 升序
  

• distinct() 去重

  User.objects.values('password').distinct()
  

5.2.2 返回單個值

下⾯這些方法後⾯不能再跟其他過濾方法，因為他們不返回查詢集

• get() 只匹配⼀條資料

  u = User.objects.get(pk=1) #正常
  u = User.objects.get(uid__gt=20) #MultipleObjectsReturned 匹配到了
  多條資料
  u = User.objects.get(uid__lt=-1) #DoesNotExist 匹配失敗
  

• first()和last()

  User.objects.all().first() #返回結果集中第⼀條資料
  User.objects.all().last() #返回結果集中最後⼀條資料
  

• count()

  • 返回結果集記錄數目，等價於select count(*)
  • 不會返回整個結果集，相比len方法更有效

  User.objects.count()
  

• exists()

  • 判斷查詢集中是否有記錄，有返回True，否則返回False

    User.objects.filter(uid=3).exists()
    

5.2.3查詢集限制

查詢集類似列表，可以使用下標進⾏限制，類似sql語句中的limit子句。但索引不
能是負數

• 索引
• 切片

User.objects.all()[0] #等同於：limit 0,1
User.objects.all()[2] #等同於：limit 2,1
User.objects.all()[0:2] #等同於limit 2
User.objects.all()[:2] #等同於limit 2
User.objects.all()[::2]

5.2.4 欄位查詢

相當於sql語句中where子句，它可以為filter、exclude和get方法提供引數。

屬性名稱__比較運算子=值 #是兩個下劃線

• in後⾯可以跟⼀個子查詢，但要求子查詢只能返回⼀個欄位

  User.objects.filter(uid__in = (2,3,4))
  User.objects.filter(uid__in = [2,3,4])
  res = User.objects.filter(uid__gt = 1).values('uid') #查詢集中只
  有⼀個欄位uid
  User.objects.filter(uid__in = res)
  

• 日期查詢

  • year、month、day、week_day、hour、minute、second

  #等價sql: select * from User where year(regtime) = 2018
   User.objects.filter(regtime__year = 2018)
  

5.2.5 統計查詢

需要先匯入模組：

from django.db.models import Max,Min,Sum,Avg,Count

• 聚合查詢：對多⾏查詢結果的⼀列進⾏操作

#統計記錄總數： select count(*) from user
User.objects.aggregate(Count('uid')) #{'uid__count': 4}
User.objects.aggregate(Max('uid')) #{'uid__max': 5}
User.objects.aggregate(Min('uid')) #{'uid__min': 2}
#統計記錄總數： select count(*) from user
User.objects.aggregate(Count('uid')) #{'uid__count': 4}
User.objects.aggregate(Max('uid')) #{'uid__max': 5}
User.objects.aggregate(Min('uid')) #{'uid__min': 2}

• 分組統計

#等價sql: select type,count(*) from user group by type
res = User.objects.values('type').annotate(Count('uid'))
#統計結果： [{'type': '普通使用者', 'uid__count': 3}, {'type': '超級管理
員', 'uid__count': 1}]
#檢視生成的sql語句
print(res.query)
#SELECT `user`.`type`, COUNT(`user`.`uid`) AS `uid__count` FROM
`user` GROUP BY `user`.`type` ORDER BY NULL

5.2.6 Q物件和F物件

需要先匯入模組：

from django.db.models import Q,F

• Q物件可以對關鍵字引數進⾏封裝，從⽽更好的應用多個查詢，可以組合&
  (and)、|(or)、~(not)操作符。

#原生sql:select * from user where uid = 2 or uid = 3
User.objects.filter(Q(uid=2)|Q(uid=3))
User.objects.filter(Q(uid__gte=2) & Q(uid__lte=3))
User.objects.filter(~Q(uid__gte=2))

• F物件：用於比較表中兩個欄位

#等價sql：select * from user where uid < type
User.objects.filter(uid__lte = F('type'))

5.3 原始sql

您可以使用它 Manager.raw()來執⾏原始查詢並返回模型例項，或者您可以完全避
免模型層並直接執⾏自定義SQL。

• raw

users = User.objects.raw("select * from user")
users = User.objects.raw("select * from user where
username='{}'".format('單強'))
print("select * from user where username='{}'".format('單強'))
users = User.objects.raw("select * from user where
username='{}'".format('單強'))
users = User.objects.raw("select * from user where username=%s",
["sddfsdf' or '1"])
print(list(users))
print(type(users))

• 自定義sql

from django.db import connection
# with語句相當與cursor= connection.cursor() 和 cursor.close(),簡化了語
with connection.cursor() as cursor:
 cursor.execute("UPDATE bar SET foo = 1 WHERE baz = %s",
[para])
 cursor.execute("SELECT foo FROM bar WHERE baz = %s", [para2])
 row = cursor.fetchone()
# 返回列表套字典
with connection.cursor() as cursor:
    cursor.execute("select * from publisher")
     columns = [col[0] for col in cursor.description]
     res = [dict(zip(columns, row)) for row in cursor.fetchall()]
     print(res)

6.模型成員

模型類和資料庫中表對應，模型類的物件和記錄物件，模型類本身沒有資料庫訪問
功能，但模型類中有⼀個Manager類的物件，通過管理器物件可以實現和資料庫的
訪問。

當我們沒有為模型類定義管理器時，Django會為模型類生成⼀個名為objects的管
理器，自定義管理器後，Django不再生成預設管理器objects。

管理器是Django的模型進⾏資料庫操作的接⼝，Django應用的每個模型都擁有⾄
少⼀個管理器。Django⽀持自定義管理器類，繼承自models.Manager。

自定義管理器類主要用於兩種情況：

• 修改原始查詢集
• 向管理器類中新增額外的方法，如向資料庫中插入資料。

6.1 重新命名管理器

在模型類中自定義⼀個新的管理器，則原有的objects管理器不會存在，以後對數
據庫的操作使用自⼰定義的管理器

#模型類
class Artical(models.Model):
     aid = models.AutoField(primary_key=True)
     title = models.CharField(max_length=100,null=False)
     content = models.TextField(max_length=10000,null=True)
     ....
     art_manager = models.Manager() #自定義了⼀個新的管理器，名字為
    art_manager
#views
def article_get(request):
     articles = Artical.art_manager.all() #使用art_manager進⾏查詢
     return render(request,"articlelist.html",context=
    {'articls':articles})

6.2 自定義管理器

• 修改原始查詢集（由all()獲取的查詢集）

  • 修改管理器的get_queryset方法，可以改變all方法返回的原始查詢集

  #⾸先自定義Manager的子類
  class ArticleManager(models.Manager):
       def get_queryset(self):
      return super().get_queryset().filter(ispublished=True) #獲取已發表的文章
  #模型類
  class Artical(models.Model):
       ....
       objects = models.Manager() #可以有多個管理器
       publishManager = ArticleManager()
  #views
  def article_publish(request):
       published = Artical.publishManager.all()
       return HttpResponse("已經發表{}".format(published[0].title))
  

• 給管理器類中新增額外的方法

  class ArticleManager(models.Manager):
       def get_queryset(self):
      return super().get_queryset().filter(ispublished=True)
  
  #新增⼀個建立物件的方法
   	def create(self,title,content,publishingdate,comments,likenum,ispublished):
   article = Artical()
   article.title = title
   article.content = content
   article.publishingdate = publishingdate
   article.comments = comments
   article.likenum = likenum
   article.ispublished = ispublished
   article.save()
   return article
  #views.py中
  def article_add(request):
   # art = Artical(title='小時代',content="混亂的邏輯")
   # art.save()
   Artical.publishManager.create('中美貿易戰','川樸⼀⾖比','2018-
  10-8',0,0,1)
   return HttpResponse("儲存成功")