前言

object relation mapping(ORM)關系對象映射表，一個類實例映射為一條表記錄

目錄

數據庫配置

1.django?默認使用sqlite的數據庫，如果需要使用mysql數據庫，就需要在settings中修改配置信息

DATABASES ={'default': {'ENGINE': 'django.db.backends.mysql','NAME' : '', #你的數據庫的名字

'USER' : '', #你的數據庫用戶

'PASSWORD' : '', #你的數據庫密碼

'HOST' : '', #你的數據庫主機，默認localhost

'PORT' : '3306', #你的數據庫端口

}

}

mysql數據庫配置信息

2.需要手動導入PyMySQL，在_init_.py中導入

import MySQLdb

#注：如果想要顯示表執行的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',

},

}

}

創建類

1. 在models.py中創建類映射表

from django.db importmodels#Create your models here.

classBook(models.Model):

name=models.CharField(max_length=20)

price=models.FloatField()

pub_date=models.DateField()

publish= models.ForeignKey("Publish", on_delete=models.CASCADE) #一對多

authors = models.ManyToManyField("Author") #多對多

def __str__(self):returnself.nameclassPublish(models.Model):

name=models.CharField(max_length=32)

city=models.CharField(max_length=32)def __str__(self):returnself.nameclassAuthor(models.Model):

name= models.CharField(max_length=32)

age= models.IntegerField(default=20)def __str__(self):return self.name

2.在終端中輸入?python manage.py makemigrations?，?python manage.py migrate?兩條命令

類屬性進階操作

classUserInfo(models.Model):

age=CharFiled(是否為空，類型，長度，列名，索引，錯誤提示，自定義驗證規則)

...

...

字段參數

null 數據庫中字段是否可以為空

db_column 數據庫中字段的列名

default 數據庫中字段的默認值

primary_key 數據庫中字段是否為主鍵

db_index 數據庫中字段是否可以建立索引

unique 數據庫中字段是否可以建立唯一索引(用于一對一)

unique_for_date 數據庫中字段【日期】部分是否可以建立唯一索引

unique_for_month 數據庫中字段【月】部分是否可以建立唯一索引

unique_for_year 數據庫中字段【年】部分是否可以建立唯一索引

verbose_name Admin中顯示的字段名稱

blank Admin中是否允許用戶輸入為空

editable Admin中是否可以編輯

help_text Admin中該字段的提示信息

choices Admin中顯示選擇框的內容，用不變動的數據放在內存中從而避免跨表操作

如：gf= models.IntegerField(choices=[(0, 'chen'),(1, 'xiaoyi'),],default=1)

error_messages 自定義錯誤信息

字典健：null, blank, invalid, invalid_choice, unique,andunique_for_date

如：{'null': "不能為空.", 'invalid': '格式錯誤'}

單表操作

-----------增#單表

#添加方法一

b = Book(name="python基礎",price=99,author="chen",pub_date="2017-12-12")

b.save()#添加方法二

Book.objects.create(name="PHP基礎",price=70,author="chen",pub_date="2016-12-12")-----------刪#單表

Book.objects.filter(author="liu").delete()-----------改#單表

Book.objects.filter(author="chen").update(price=100)-----------查#單表

book_list =Book.objects.all()print(book_list[0])

book_list= Book.objects.all()[::-2]

book_list= Book.objects.all()[::2]

book_list=Book.objects.first()

book_list=Book.objects.last()

book_list= Book.objects.get(id=4) #只能取出一條記錄的時候不報錯

ret = Book.objects.filter(author="chen").values("name","price") #以字典的形式顯示

ret = Book.objects.filter(author="chen").values_list("name","price") #以元組的形式顯示

book_list = Book.objects.exclude(author="chen").values("name","price") #除了chen以外的人的數據

book_list = Book.objects.all().values("name").distinct() #根據一個字段去重

ret = Book.objects.all().values("name").distinct().count() #根據一個字段去重

Book.objects.filter(authors__id__in=[1,2]) #獲取id等于1或2的數據

Book.objects.filter(authors__id__range=[1,2]) #范圍

#萬能的__

#價格大于50的數/85.41

book_list = Book.objects.filter(price__gt=50).values("name","price")#模糊查詢

book_list = Book.objects.filter(name__icontains="P").values("name","price")

一對多(外鍵)

外鍵關系及參數

ForeignKey(ForeignObject)

to, 要進行關聯的表名

to_field=None, 要關聯的表中的字段名稱

on_delete=None, 當刪除關聯表中的數據時，當前表與其關聯的行的行為-models.CASCADE，刪除關聯數據，與之關聯也刪除(常用)-models.DO_NOTHING，刪除關聯數據，引發錯誤IntegrityError-models.PROTECT，刪除關聯數據，引發錯誤ProtectedError-models.SET_NULL，刪除關聯數據，與之關聯的值設置為null(前提FK字段需要設置為可空)-models.SET_DEFAULT，刪除關聯數據，與之關聯的值設置為默認值(前提FK字段需要設置默認值)

related_name=None, 反向操作時，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()

related_query_name=None, 反向操作時，使用的連接前綴，用于替換【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')

limit_choices_to=None, 在Admin或ModelForm中顯示關聯數據時，提供的條件：

如：- limit_choices_to={'nid__gt': 5}- limit_choices_to=lambda : {'nid__gt': 5}

db_constraint=True 是否在數據庫中創建外鍵約束

parent_link=False 在Admin中是否顯示關聯數據

書籍和出版社是一對多的關系

classBook(models.Model):

name=models.CharField(max_length=20)

price=models.FloatField()

pub_date=models.DateField()

publish= models.ForeignKey("Publish", on_delete=models.CASCADE) #一對多

def __str__(self):returnself.nameclassPublish(models.Model):

name=models.CharField(max_length=32)

city=models.CharField(max_length=32)def __str__(self):return self.name

添加數據的方法

#多表添加

Book.objects.create(name="linux運維",price=77,pub_date="2017-12-12",publish_id=2)

Book.objects.create(name="GO",price=23,pub_date="2017-05-12",publish=publish_obj)

多表查詢的方法

#含外鍵:一對多查詢

#查詢人民出版社出過的所有書籍名字和價格

#方式一：

pub_obj=Publish.objects.filter(name="人民出版社")[0]

ret=Book.objects.filter(publish=pub_obj).values("name","price")#方式二

pub_obj = Publish.objects.filter(name="人民出版社")[0]print(pub_obj.book_set.all().values("name","price")) #book_set

print(type(pub_obj.book_set.all()))#方式三，用__

ret=Book.objects.filter(publish__name="人民出版社").values("name","price")#python基礎書出版社的名字

#法一

ret = Publish.objects.filter(book__name="Python基礎").values("name")#法二

ret3=Book.objects.filter(name="python基礎").values("publish__name")#北京出版出版的所有的書

ret = Book.objects.filter(publish__city="北京").values("name")

ret= Publish.objects.filter(city="北京")

一對一(外鍵+unique)

classBook(models.Model):

name=models.CharField(max_length=20)

price=models.FloatField()

pub_date=models.DateField()

publish=models.ForeignKey(

to= "Publish",

on_delete=models.CASCADE,

unique=True,

)#一對一

def __str__(self):returnself.nameclassPublish(models.Model):

name=models.CharField(max_length=32)

city=models.CharField(max_length=32)def __str__(self):return self.name

多對多(關系表)

多對多關系及參數

ManyToManyField(RelatedField)

to, 要進行關聯的表名

related_name=None, 反向操作時，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()

related_query_name=None, 反向操作時，使用的連接前綴，用于替換【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')

limit_choices_to=None, 在Admin或ModelForm中顯示關聯數據時，提供的條件：

如：- limit_choices_to={'nid__gt': 5}- limit_choices_to=lambda : {'nid__gt': 5}

symmetrical=None, 僅用于多對多自關聯時，symmetrical用于指定內部是否創建反向操作的字段#可選字段有：code, id, m1

classBB(models.Model):

code= models.CharField(max_length=12)

m1= models.ManyToManyField('self',symmetrical=True)#可選字段有: bb, code, id, m1

classBB(models.Model):

code= models.CharField(max_length=12)

m1= models.ManyToManyField('self',symmetrical=False)

through=None, 自定義第三張表時，使用字段用于指定關系表

through_fields=None, 自定義第三張表時，使用字段用于指定關系表中那些字段做多對多關系表from django.db importmodelsclassPerson(models.Model):

name= models.CharField(max_length=50)classGroup(models.Model):

name= models.CharField(max_length=128)

members=models.ManyToManyField(

Person,

through='Membership',

through_fields=('group', 'person'),

)classMembership(models.Model):

group= models.ForeignKey(Group, on_delete=models.CASCADE)

person= models.ForeignKey(Person, on_delete=models.CASCADE)

inviter=models.ForeignKey(

Person,

on_delete=models.CASCADE,

related_name="membership_invites",

)

invite_reason= models.CharField(max_length=64)

db_constraint=True, 是否在數據庫中創建外鍵約束

db_table= None, 默認創建第三張表時，數據庫中表的名稱

書籍和作者是多對多的關系

注：使用authors = models.ManyToManyField("Author")，會自動創建book_authors表，也可以自己創建關系表(不會有authors屬性)classBook(models.Model):

name=models.CharField(max_length=20)

price=models.FloatField()

pub_date=models.DateField()

authors= models.ManyToManyField("Author") #多對多

def __str__(self):returnself.nameclassAuthor(models.Model):

name= models.CharField(max_length=32)

age= models.IntegerField(default=20)def __str__(self):return self.name

-----------增#綁定多表關系

book_obj = Book.objects.get(id=4)

authors_objs= Author.objects.get(id=2) #authors_objs = Author.objects.all()

book_obj.authors.add(authors_objs)-----------查#多對多的關系，第三張表關系表

#通過對象的方式綁定關系

#書找作者

book_obj=Book.objects.get(id=3)print(book_obj.authors.all())#作者找書

author_obj = Author.objects.get(id=2)print(author_obj.book_set.all())return HttpResponse("添加成功")-----------刪#解除多表關系

book_obj = Book.objects.get(id=4)

authors_objs= Author.objects.all() #是列表

book_obj.authors.remove(*authors_objs)

book_obj.authors.remove(2) #刪除的是數量

#清空

book_obj.authors.clear()-----------改#修改的set()方法

book_obj = Book.objects.get(id=4)

book_obj.authors.set([2,3])

手動創建的多表關系

#手動創建關系表

classBook(models.Model):

name=models.CharField(max_length=20)

price=models.FloatField()

pub_date=models.DateField()def __str__(self):returnself.nameclassBook_Author(models.Model):

book=models.ForeignKey("Book",on_delete=models.CASCADE)

author=models.ForeignKey("Author",on_delete=models.CASCADE)classAuthor(models.Model):

name= models.CharField(max_length=32)

age= models.IntegerField(default=20)def __str__(self):return self.name

-----------增#手動創建的關系表

Book_Author.objects.create(book_id=2,author_id=3)-----------查#關聯查詢，查找書的所有作者

obj = Book.objects.get(id=2)print(obj.book_author_set.all()[0].author)#chen出過的書和價格

ret = Book.objects.filter(book_author__author__name="chen").values("name","price")

手動創建的表因為沒有第三張的字段，因此沒有自動創建的表查詢的方便，而自動創建的表默認只有三個字段

因此引入? ?手動+自動聯合創建表

classUser(models.Model):

username= models.CharField(max_length=32,db_index=True)def __str__(self):returnself.usernameclassTag(models.Model):

title= models.CharField(max_length=16)

m=models.ManyToManyField(

to='User',

through='UserToTag',

through_fields=['u','t']

)def __str__(self):returnself.title#使用ManyToManyField只能在第三張表中創建三列數據

classUserToTag(models.Model):#nid = models.AutoField(primary_key=True)

u = models.ForeignKey(to='User')

t= models.ForeignKey(to='Tag')

ctime=models.DateField()#用于關系表u，t兩個字段共同約束唯一

classMeta:

unique_together=[

('u','t'),

]

自關聯

用戶粉絲互相關注(在同一張用戶表里，用戶互相關聯)

classUser(models.Model):

username= models.CharField(max_length=32,db_index=True)

d= models.ManyToManyField('User',related_name='b')def __str__(self):return self.username

注：自關聯的跨表查詢

symmetrical=None, 僅用于多對多自關聯時，symmetrical用于指定內部是否創建反向操作的字段#可選字段有：code, id, m1

classBB(models.Model):

code= models.CharField(max_length=12)

m1= models.ManyToManyField('self',symmetrical=True)#可選字段有: bb, code, id, m1

classBB(models.Model):

code= models.CharField(max_length=12)

m1= models.ManyToManyField('self',symmetrical=False)

聚合函數，Q函數，F函數

先導入模塊

from django.db.models importMin,Avg,Max,Sumfrom django.db.models import F,Q

#聚合函數(需要先導入函數)

ret = Book.objects.all().aggregate(Avg("price"))

ret= Book.objects.all().aggregate(chen_money = Sum("price")) #取別名

#查各個作者的書的價格總和

value:按照作者名字分組

ret= Book.objects.values("authors__name").annotate(Sum("price"))print(ret)#查各個出版社出的書的最小

ret = Publish.objects.values("name").annotate(Min("book__price"))print(ret)#-----------------------------------------------------------------------------------------------------------------------------

#F查詢和Q查詢,(使用前要導入模塊)#F拿到的值

Book.objects.all().update(price=F("price")+10)#Q可以做or操作 ，~Q表示非

re = Book.objects.filter(Q(price=80) | Q(name="GO"))#組合查詢

re = Book.objects.filter(Q(name__contains="G"))#Q查詢和關鍵字查詢組合，Q要在前面

re = Book.objects.filter(Q(name="GO"),price=80)

惰性取值，迭代對象，exists()函數

#只有在使用ret使用的時候才去查詢，惰性取值

re = Book.objects.filter(price=80) #不會取值

for i in re: #使用時才會去查詢

print(i)print(re)#---------------------------------------------------------------------

#exists()

re = Book.objects.filter(price=80)

re.exists()#會查詢，但re不會被賦值，只有使用re變量的時候才會被賦值

#----------------------------------------------------------------------

#iterator() 迭代器對象

ret = Book.objects.filter(price=80)

ret= ret.iterator()

總結

以上是生活随笔為你收集整理的python数据模型搭建_python之路（19）django数据库模型(model)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。