Django（四）数据库
一、數據庫框架
數據庫框架是數據庫的抽象層，也稱為對象關系映射（Object-Relational Mapper, ORM），它將高層的面向對象操作轉換成低層的數據庫指令，比起直接操作數據庫引擎，ORM極大的提高了易用性。這種轉換會帶來一定的性能損耗，但ORM對生產效率的提升遠遠超過這一丁點兒性能降低。
Django中內置的SQLAlchemy ORM就是一個很好的數據庫框架，它為多種關系型數據庫引擎提供抽象層，比如MySQL, Postgres，SQLite，并且使用相同的面向對象接口。因此，使用SQLAlchemy ORM，不僅能極大的提高生產力，而且可以方便的在多種數據庫之間遷移。
二、配置數據庫
我們可以在項目文件夾的settins.py中配置數據庫引擎。
Django默認使用sqlite：
如果要要使用mysql, 需要進行如下配置：
1 編輯項目文件夾下的settings.py :
2 編輯項目文件夾下的__init__.py :
由于mysql在Django中默認驅動是MySQLdb, 而該驅動不適用于python3， 因此，我們需要更改驅動為PyMySQL
3 顯示SQL語句
前面我們說了ORM將高層的面向對象的操作，轉換為低層的SQL語句，如果想在終端打印對應的SQL語句，可以在setting.py中加上日志記錄：
三、模型
在ORM中，用模型(Model)表示數據庫中一張表。模型的具體實現是一個Python類，類中的屬性對應數據庫表中的字段，這個類的實例化對象，對應表中的一條記錄。
總結：類 –> 表； 類屬性 –> 表字段； 類實例 –> 表記錄
定義模型
定義模型就是定義一個python類，以創建一個圖書管理系統為例，基本形式如下：
from django.db import modelsclass Publish(models.Model):name = models.CharField(max_length=60)addr = models.CharField(max_length=60)def __str__(self):return self.nameclass Author(models.Model):name = models.CharField(max_length=30)def __str__(self):return self.nameclass Book(models.Model):name = models.CharField(max_length=60)price = models.DecimalField(max_digits=6, decimal_places=2)publish = models.ForeignKey(Publish)# 定義書與出版社的多對一關系# 默認綁定到Publish表中的主鍵字段authors = models.ManyToManyField(Author)# 定義書與作者的多對多關系，ORM將自動創建多對多關系的第三張表說明：
1. 定義完模型后，或者修改了模型后，要執行數據庫遷移操作：
python manage.py makemigrations
python manage.py migrate
執行完命令后，查看數據庫的表目錄，可以看到上述表格成功創建：
2. 上述模型中都沒有設置主鍵，在完成上遷移操作后，orm會自動創建主鍵。
3. orm會自動將Book表中的關聯字段publish, 在數據庫中存為publish_id, 所以不要畫蛇添足自己命名為publish_id，否則你在數據庫中看到的是publish_id_id
4. 外鍵引用的主表要么在子表前創建，要么使用字符串形式指定，否則子表找不到主表。
5. 如果我們實例化一個Book對象，book_obj, 那么通過book_obj.publish得到的是publish_id對應的那個Publish對象。這是ORM作的設定，原因很簡單，如果通過book_obj.publish得到只是一個publish_id，對我們并沒有多大用。
6. 雖然不是強制的，但是建議在每個類中定義__str__方法（或__repr__方法），這樣當我們打印對象時，可以顯示具有可讀性的字符串信息，方便調試。
7. 只要在一張表中定義了多對多關系，orm會自動創建實現多對多關系的第三張表。當然，你也可以手動創建，如下：
還是不建議手動創建，一是麻煩，而是后面我在執行刪除記錄的操作時，提示找不到第三關聯表，可能是我表名命名問題，猜測應該將第三張表命名為Book_authors的格式，這樣才能和orm自動創建的第三張表同名，未驗證。。。
字段類型
| IntegerField | int | 普通整數,通常是32位,-2147483648 to 2147483647 |
| SmallIntegerField | int | 小整數，一般是16位，-32768 to 32767 |
| BigIntegerField | int/long | 64位的整數，-9223372036854775808 to 9223372036854775807 |
| FloatField | float | 浮點數 |
| DecimalField(max_digits=None, decimal_places=None | decimal.Decimal | 定點數,精度更高；要求指定位數和小數點精度。 |
| CharField(max_length=None) | str | 字符串；要求指定最大長度 |
| TextField | str | 變長字符串 |
| BooleanField | bool | 布爾值 |
| DateField | datetime.date | 日期，比如：2017-08-25 |
| DateTimeField | datetime.datetime | 日期和時間 |
| BinaryField | str | 二進制 |
更多類型請參考官網 field types
關系字段
| ForeignKey(othermodel) | 多對一關系,需要指定關系表 |
| ManyToManyField(othermodel) | 多對多關系，需要指定關系表 |
| OneToOneField(othermodel) | 一對一關系，需要指定關系表 |
字段選項
| primary_key | 如果設置primary_key=True, 這列就是表的主鍵；如果不指定，Django會自動添加一個AutoField字段來盛放主鍵，所以我們一般無需設定主鍵。 |
| unique | 如果設置unique=True, 這列不允許出現重復的值 |
| db_index | 如果設置db_index=True, 為這列創建索引，提升查詢效率 |
| null | 如果設置null=True, 這列允許使用空值；如果新增了字段，建議設置該選項，因為新增字段之前的記錄沒有該字段 |
| default | 為這列定義默認值；如果新增了字段，建議設置該選項，因為新增字段之前的記錄沒有該字段 |
| related_name | 在一對多關系多所在的表中定義反向引用；這樣在一所在的表中反向查詢多所在的表時，直接用這個字段就行了，可以替代下面要講到的_set反向查詢 |
更多選項請參考官網 filed options
四、數據庫的操作
下面通過python shell來演示數據庫的操作。在終端切換到項目根目錄下，輸入命令python manage.py shell進入shell操作環境：
增刪改查
1 創建記錄
方式一：實例化
>>> from app.models import Author #導入模型 >>> a = Author(name="張三") # 實例化 >>> a.save() # 插入記錄 >>> print(a) 張三方式二：create()工廠函數
>>> Author.objects.create(name='李四') <Author: 李四>通過get_or_create()創建記錄，這種方法可以防止重復（速度稍慢，因為會先查詢數據庫），它返回一個元組，第一個是實例對象（記錄），創建成功返回True，已存在則返回False，不執行創建。
>>> Author.objects.get_or_create(name='李四') (<Author: 李四>, False)2 查詢記錄
1 Author.objects.all()查詢所有
>>> Author.objects.all() <QuerySet [<Author: 張三>, <Author: 李四>]>我們也可以對查詢結果進行切片索引操作：Author.objects.all()[start:end:step]，注意，不支持負索引：
>>> Author.objects.all()[-1] AssertionError: Negative indexing is not supported.2 Author.objects.filter(name='李四') 過濾查詢
3 萬能的雙下劃線查詢__，對應SQL的where語句
__contains, __regex, __gt, __th， 多個條件之間以逗號分隔
__in判斷字段在列表內。另外通常用pk指主鍵，不限于id，適用性更好。
models.Server.objects.filter(pk__in=id_list).delete()其它還有: __startswith(), __istartswith(), __endswith(), __iendswith()
4 Author.objects.get() 只能得到一個對象，多了少了都報錯
5 first(), last()獲取查詢結果中的單個對象
>>> Author.objects.filter(id__gt=2).first() # 獲取第一個 <Author: 李四> >>> Author.objects.filter(id__gt=2).last() # 獲取最后一個 <Author: Martin>6 values(*field) 用字典形式，返回指定字段的查詢結果；多個字段間以逗號分隔
>>> Author.objects.values('name') <QuerySet [{'name': '李白'}, {'name': '光緒'}]> # values()方法前可以加過濾條件，如果不加，相當于Author.objects.all().values()7 values_list(*field)，同上，用元組形式
<QuerySet [('李白',), ('光緒',)]>8 exclude(**kwargs)反向過濾
>>> Author.objects.exclude(name__contains='魯迅') # 過濾所有姓名不包含‘魯迅的’ <QuerySet [<Author: 李白>, <Author: 光緒>, <Author: Martin>]>9 order_by(*field) 根據字段排序
10 reverse() 反向排序，用在·order_by后面
11 distinct() 剔除重復
12 count() 統計數量
13 exists() QuerySet包含數據返回True, 否則返回False
3 修改記錄
方式一：QuerySet.update(field=var)
修改的前提是先查找，然后調用update(field=val)方法，只有QuerySet集合對象才能調用該方法，也就是說通過get(), first(), last()獲取的對象沒有該方法。
方式二：對象賦值，不推薦，效率低
>>> obj = Author.objects.filter(name='李小白').first() >>> obj.name='李白' >>> obj.save() # SQL語句： UPDATE `app_author` SET `name` = '李白' WHERE `app_author`.`id` = 3; args=('李白', 3) 從SQL語句可以看出，通過對象賦值的方式，會將該對象的所有字段重新賦值，故而效率低。4 刪除記錄
刪除的前提是先查找，然后調用delete()方法；不同于update()方法，delete()支持QuerySet集合對象的刪除，也支持單個對象的刪除。
delete()默認就是級聯刪除：刪除一條記錄后，在多對多關系的關聯表中與該記錄有關的記錄也會刪除。
QuerySet
從數據庫從數據庫查詢出來的結果一般是一個集合，哪怕只有一個對象，這個集合叫QuerySet。
QuerySet特性：
1 支持切片操作
2 可迭代：for循環
3 惰性機制：只有使用QuerySet時，才會走數據庫，比如執行res = Author.objects.all()時，并不會真正執行數據庫查詢，只是翻譯為SQL語句。而當我們執行if res, print res, for obj in res這些操作時，才會執行SQL語句，進行數據庫查詢。這一點可以通過在setting.py中加上日志記錄顯示SQL語句得到證實。
4 緩存機制：每次執行了數據庫查詢后，會將結果放在QuerySet的緩存中，下次再使用QuerySet時，不走數據庫，直接從緩存中拿數據。緩存機制減少了對數據庫的訪問，有利于提高性能。但是一旦數據庫數據更新，除非重新訪問數據庫，否則緩存也不會更新，下面我們來證實這一點：
提高數據庫性能
iterator()迭代器
如果我們查詢出的數據很大，QeurySet的緩存肯定會崩。解決方案：對QeurySet應用.iterator()方法，將查詢結果轉化為迭代器。
>>> g = Author.objects.all().iterator() >>> for item in g: ... print(item.name) ... 李白 光緒 魯迅 Martin Susan >>> for item in g: ... print(item.name) ... >>> # 第一次for循環迭代器迭代完了，所以第二次不會打印出來盡管轉化為迭代器會節省內存，但是這也意味著，會造成額外的數據庫查詢。
exists()
比如我們拿到一個QuerySet對象，res = Book.objects.all()，想確定記錄是否存在，如果用if res，將會查詢數據庫中的所有記錄，這會極大的影響性能，解決方案：if res.exists() 這樣會限定只查詢一條記錄（低層轉化為SQL語句中的limit 1)
select_related主動連表查詢
提高數據庫性能的關鍵一點是減少對數據庫的查詢，我們來看一個栗子：
1. 創建一張Role角色表，和UserInfo表，建立一對多關系：
2.往UserInfo表中插入3個用戶，并指定角色：略
3.在視圖中通過如下方式查詢用戶名和用戶的角色名：
4.在settings.py中配置打印SQL命令；通過瀏覽器訪問http://127.0.0.1:8000/index.html/執行index視圖函數，查看SQL命令的執行結果：
(0.000) SELECT "app01_userinfo"."id", "app01_userinfo"."name", "app01_userinfo"."pwd", "app01_userinfo"."role_id" FROM "app01_userinfo"; args=() (0.000) SELECT "app01_role"."id", "app01_role"."title" FROM "app01_role" WHERE "app01_role"."id" = 1; args=(1,) (0.000) SELECT "app01_role"."id", "app01_role"."title" FROM "app01_role" WHERE "app01_role"."id" = 2; args=(2,) (0.000) SELECT "app01_role"."id", "app01_role"."title" FROM "app01_role" WHERE "app01_role"."id" = 3; args=(3,)SQL語句顯示一共執行了4次數據庫查詢，第一次對應user_list = UserInfo.objects.all()，剩余三次是for user in user_list: print(user.name, user.role.title) 循環時，針對三個用戶，查詢了三次角色表。如果用戶數量很多，這樣一次次的查詢數據庫，將極大影響數據庫性能。
下面我們通過select_related執行查詢：
查看這次的SQL語句：只執行了一次數據庫查詢
select_related('FK')取當前表數據和表外鍵關聯字段，因此，在一次查詢中獲得了所有需要的信息。
如果要連多個表，通過雙下劃線連接更多外鍵字段即可：
select_related('FK1__FK2')
prefetch_related
我們將上面的栗子中的select_related改為prefetch_related
def index(request):user_list = UserInfo.objects.all().prefetch_related("role")for user in user_list:print(user.name, user.role.title)return HttpResponse('ok')查看SQL語句：
(0.000) SELECT "app01_userinfo"."id", "app01_userinfo"."name", "app01_userinfo"."role_id" FROM "app01_userinfo"; args=() (0.001) SELECT "app01_role"."id", "app01_role"."title" FROM "app01_role" WHERE "app01_role"."id" IN (1, 2, 3); args=(1, 2, 3)執行了兩次查詢，第二次查詢是通過判斷用戶角色是否在角色表，并將關聯的角色取出來。因為通常用戶數量很多，但是角色相對會少很多，因此，這種方式也減少了對數據庫的訪問。
only
UserInfo.objects.all().only("name")only()方法只取某個字段，因此，如果需要只是需要用到指定的字段，通過這種方式可以提供性能。區別于values()，only()的查詢結果還是對象，而values()的查詢結果是字典。
defer
與only()相反，排除某個字段。
關聯關系的處理
在視圖函數中操作數據庫的語法與在python shell中是一樣的
添加一對多關系
from django.shortcuts import render, HttpResponse from .models import *def add(request):# 方式一,通過真實字段賦值Book.objects.get_or_create(title = 'chinese',price = 10.00,publish_id = 1, # Book的publish字段在數據庫中真實表示是publish_id)# 方式二， 通過對象賦值publish_obj = Publish.objects.get(id=2)Book.objects.create(title ='English',price = 18.88,publish = publish_obj, #通過對象賦值)return HttpResponse('OK')添加/解除多對多關系
from django.shortcuts import render, HttpResponse from .models import *def add(request):# 添加多對多關系的前提是記錄已經創建好，無法在創建記錄的同時添加多對多關系# 逐個添加 add(obj)author_obj1 = Author.objects.get(id=1)author_obj2 = Author.objects.get(id=2)book_obj = Book.objects.get(id='8')book_obj.authors.add(author_obj2, author_obj1)# 批量添加 add(queryset)author_list = Author.objects.all()book_obj = Book.objects.get(id='1')book_obj.authors.add(*author_list)# * + 列表，將列表傳給函數# * + 字典，將字典傳給函數# 打印authors --> 對象集合book_obj = Book.objects.get(id='8')print(book_obj.authors.all())# 打印結果：<QuerySet [<Author: Egon>, <Author: Alex>, <Author: 魯迅>, <Author: 光緒>]># 解除部分綁定 remove(obj)book_obj = Book.objects.get(id='8')author = Author.objects.get(id=2)book_obj.authors.remove(author)# 如果要解除多個：# * + 列表，將列表傳給函數# * + 字典，將字典傳給函數# 解除所有綁定 clear()book_obj = Book.objects.get(id='8')book_obj.authors.clear()return HttpResponse('OK')多表查詢
正向查詢：通過當前表中存在的字段查詢
例1：一對多：查詢一本書出版社的名字
>>> b = Book.objects.filter(name__contains='現代').first() >>> b.publish.name # b.publish 是一個對象，對應主表Publish中的一條記錄 '復旦出版' # 通過publish拿到對應主表中的對象，訪問其屬性例2：多對多：查詢一本書的作者
>>> b = Book.objects.get(name='linux') >>> author_list = b.authors.all() # 拿到某本書的所有author對象 >>> print(author_list) <QuerySet [<Author: 李白>, <Author: 光緒>]>以上兩例是基于對象屬性的正向查詢。
例3：查詢某出版社出版了哪些書：
反向查詢
Publish表中沒有book相關的字段，但是可以通過反向查詢來做：book_set(用關聯的表名小寫，下劃線加set)來找到與出版社關聯的書籍的對象的集合
還是例3，如果用反向查詢：
book_set : 關聯表名，set集合；all()取出所有數據。
注意，如果是一對一關聯，那么就不用加_set。
基于反向查詢的語法，我們也可以執行反向綁定關系：
偽代碼形式：
基于values(), filter(), 雙下劃線的多表查詢
以上幾種多表查詢方式都略顯麻煩，現在我們通過values(), filter(), 雙下劃線，來簡化一下：
例1：查詢一本書出版社的名字（正向思路）：
例2： 查詢出版了某本書的的出版社名字（反向思路）：
>>> Publish.objects.filter(book__name='linux').values('name') <QuerySet [{'name': '人民郵電'}]> # book（子表名） + __（雙下劃線） + name（子表中的字段） # 對應的低層SQL語句：filter(book__title="linux")應用了表聯結 SELECT `app_publish`.`name` FROM `app_publish` INNER JOIN `app_book` ON (`app_publish`.`id ` = `app_book`.`publish_id`) WHERE `app_book`.`name` = 'linux' LIMIT 21; args=('linux',)例3：查詢價格大于10的書籍的作者姓名：
正向： Book.objects.filter(price__gt=10).values("authors__name") # authors（子表與主表關聯字段） + __（雙下劃線） + name（主表目標字段） 反向： Author.objects.filter(book__price__gt=10).values("name") # book（子表名） + __（雙下劃線） + price__gt=10（子表字段，條件）聚合&分組查詢
SQL語言中有聚合函數：Avg, Min, Max, Sum, Count，可以方便進行數據統計；在ORM中，QuerySet的aggregate()方法對此提供了支持，它返回一個統計結果的鍵值對。下面我們看看如何使用，
基本格式：QuerySet.aggregate(func(field))
例1 查詢某作家出版書籍的價格總和
如果要統計多個作者，那就要用到分組查詢，QuerySet的anotate()方法對此提供了支持。
例2 每個作者出版過的書的平均價格
F&Q查詢
很多時候單一的關鍵字查詢無法滿足查詢要求，可以使用F&和Q查詢，使用前請先導入：
from django.db.models import F, Q
F對字段取值
F用于取字段取值，我們來看一個例子：
對數據庫中每本書的價格加10元：
Book.objects.all.update(price=price+10)
直接報錯 NameError: name ‘price’ is not defined，提示price+10中的price未定義，取不到值。下面我們通過F對price字段取值：
Q組合多個查詢條件
假設我們要查詢某個作家，價格大于10元的書，那么filter()函數中通過逗號，放兩個過濾條件可以實現：
>>> Book.objects.filter(authors__name='光緒', price__gt=10) <QuerySet [<Book: linux>, <Book: 現代編程方法>]>上面這個情況，逗號就是處理邏輯與。那如果要處理邏輯非，邏輯或，這些過濾條件呢？這時Q查詢就可以很靈活處理：
1 將查詢條件用Q包起來
2 通過：, & | ~ 且，或，非，運算符來連接多個過濾條件
下面我們看栗子：
例1 查詢某個作家的，或者價格大于10的書
例2 查詢非莫個作家寫的，并且是某個出版社的書
>>> Book.objects.filter(~Q(authors__name='李白') & Q(publish__name='機械工業')) <QuerySet [<Book: 蘇菲的世界>, <Book: 水滸傳>]> # 不是李白寫的，并且是由機械工業出版社出版的書Q查詢的面向對象方式
如果查詢條件是一個如下的字典形式：
search_condictions = {'ID': [1, 2], 'hostname': ['c1.com', 'c2.com']}分析查詢邏輯：
字典中每一個元素下鍵對應的列表中的元素：OR
Q('ID'=1) | Q('ID'=2) Q('hostname'='c1.com') | Q('hostname'='c2.com')字典中ID與hostname – AND, 最終組合查詢條件如下：
Q((Q('ID'=1) | Q('ID'=2)) & (Q('hostname'='c1.com') | Q('hostname'='c2.com')))下面我們用Q查詢的面向對象方式：
from django.db.models import Qquery = Q()temp1 = Q() temp1.connector = 'OR' temp1.children.append(('ID', 1)) temp1.children.append(('ID', 2)) # 相當于： # Q('ID'=1) | Q('ID'=2)temp2 = Q() temp2.connector = 'OR' temp2.children.append(('hostname', 'c1.com')) temp2.children.append(('hostname', 'c2.com')) # 相當于： # Q('hostname'='c1.com') | Q('hostname'='c2.com')query.add(temp1, 'AND') query.add(temp2, 'ADN') # 相當于： # Q((Q('ID'=1) | Q('ID'=2)) & (Q('hostname'='c1.com') | Q('hostname'='c2.com')))當查詢條件長度不確定時，顯然我們無法通過簡單的對Q進行組合來查詢，那么Q查詢的面向對象方式就可以發揮用處：
from django.db.models import Qquery = Q()for k, v in search_condictions.items():# k: AND; for i in v: ORtemp = Q()temp.connector = 'OR'for i in v:temp.children.append((k, i))query.add(temp, 'AND')res = models.Server.objects.filter(query).all()多表查詢和表創建總結
多表查詢：正向查詢用字段，反向查詢用表名（小寫）
一對一關系：
# 正向：b_obj = a_obj.field# 反向：因為是一對一，所有查詢出來只有一個，不需要_seta_obj = b_obj.model一對多關系：
# 正向：b_obj = a_obj.field# 反向：_set取到集合QuerySet_obj = b_obj.model_set.all()多對多關系：
# 正向：QuerySet_obj = a_obj.field.all()# 反向：QuerySet_obj = b_obj.model_set.all()創建表：
多表關系的創建
class Article(models.Model):# 自定義主鍵；一般不需要定義，默認會自己創建。nid = models.BigAutoField(primary_key=True)title = models.CharField(max_length=50, verbose_name='文章標題')# 一對一關系；to_field屬性一般不用定義，orm會自動找到關聯表的主鍵字段body = models.OneToOneField(verbose_name='文章內容', to='ArticleDetail', to_field='nid')# 一對多關系blog = models.ForeignKey(verbose_name='所屬博客', to='Blog', to_field='nid')# 多對多關系；默認自動創建第三張表，通過定義through和through_fields屬性，來手動定義多對多關系。如果需要操作第三張表，選擇手動定義。tags = models.ManyToManyField(to="Tag",through='Article2Tag',through_fields=('article', 'tag'),)# 靜態字段type_choices = [(1, "Python"),(2, "Linux"),(3, "OpenStack"),(4, "GoLang"),]article_type_id = models.IntegerField(choices=type_choices, default=None)# 手動創建多對多關聯表 class Article2Tag(models.Model):nid = models.AutoField(primary_key=True)article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')tag = models.ForeignKey(verbose_name='標簽', to="Tag", to_field='nid')class Meta:unique_together = [('article', 'tag'),]說明：表中出現靜態字段作為choices源的字段，存的值是Integer，如果想獲取對應的文本，使用:
obj.get_field_display()即可顯示，省去自己寫循環判斷的麻煩。對于這里來說，field是article_type_id
本表和本表的關系
自引用一對多
class Menu(models.Model):"""菜單"""title = models.CharField(verbose_name='菜單名稱', max_length=32, unique=True)parent = models.ForeignKey(verbose_name='父級菜單', to="Menu", null=True, blank=True)# 定義本表的自引用一對多關系# blank=True 意味著在后臺管理中填寫可以為空，根菜單沒有父級菜單 class Customer(models.Model):"""客戶表"""name = models.CharField(verbose_name='姓名', max_length=16)gender_choices = ((1, '男'), (2, '女'))gender = models.SmallIntegerField(verbose_name='性別', choices=gender_choices)referral_from = models.ForeignKey('self', # 與本表的自引用一對多blank=True,null=True,verbose_name="轉介紹自客戶",help_text="若此客戶是轉介紹自內部會員,請在此處選擇會員姓名",related_name="internal_referral")# related_name定義反向引用關系，通過該字段直接查找，而不用反向查找。自引用多對多，比如用戶互相關注
class UserInfo(AbstractUser):"""用戶信息"""nid = models.BigAutoField(primary_key=True)nickname = models.CharField(verbose_name='昵稱', max_length=32)fans = models.ManyToManyField(verbose_name='粉絲們',to='UserInfo',through='UserFans',through_fields=('user', 'follower'))class UserFans(models.Model):"""互粉關系表"""nid = models.AutoField(primary_key=True)user = models.ForeignKey(verbose_name='用戶', to='UserInfo', to_field='nid', related_name='users')follower = models.ForeignKey(verbose_name='粉絲', to='UserInfo', to_field='nid', related_name='followers')class Meta:unique_together = [('user', 'follower'),]繼承自帶用戶表
Django自帶一張用戶表，其中提供了很多字段，包括密文密碼。而用戶自定義的用戶表密碼是明文的，如果需要使用Django自帶用戶表的特性?？梢岳^承自帶的用戶表。
配置settings.py
AUTH_USER_MODEL='app.UserInfo' # app名 加 表名繼承AbstractUser表后，自帶用戶表中的所有字段可用，并且可以定義其它字段。
from django.contrib.auth.models import AbstractUserclass UserInfo(AbstractUser):"""用戶信息"""pass總結
以上是生活随笔為你收集整理的Django（四）数据库的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Netiler annotation 用
- 下一篇： 为什么单线程的Redis却能支撑高并发？