快速,持续,稳定,傻瓜式
支持Mysql,Sqlserver数据同步

python之路19)django数据库模型model

在线QQ客服:1922638

专业的SQL Server、MySQL数据库同步软件

前言

对象关系映射(ORM)关系对象映射表,一个类实例被映射到一个表记录

目录

  • 数据库配置
  • 创建课程
  • 单表操作
  • 一对多(外键)
  • 一对一(外键+唯一)
  • 多对多(关系表)
  • 自我交往
  • 聚合函数,Q函数,F函数
  • 惰性值,迭代对象,存在()函数

\ 1.django默认使用sqlite数据库,如果需要使用mysql数据库,则需要在设置中修改配置信息

\

数据库= <跨度样式="颜色:#000000;"> {

" 默认 " :{

" 引擎 " :" django.db.backends.mysql "

" 名称 " :"" 数据库名称

" USER " :"" 您的数据库用户

" 密码 " :"" 您的数据库密码

" 主机 " :"" 您的数据库主机,默认本地主机

" 端口 " :" 3306 " 您的数据库端口

}

}

mysql数据库配置信息

\ 2.需要手动导入PyMySQL,导入_init_.py

导入MySQLdb 

  注意:如果要显示表执行的SQL语句,请在其中进行配置设置

记录 = {

" 版本 " :1

" disable_existing_loggers " :False,

" 处理程序 " :{

" 控制台 " :{

" 级别 " :" DEBUG "

" " :" logging.StreamHandler "

},

},

" 记录器 " :{

" django.db.backends " :{

" 处理程序 " :[" 控制台 " ],

" 传播 " :是,

" 级别 " :" DEBUG "

},

}

}


1.在models.py中创建一个类映射

 来自 django.db  import  型号

在此处创建模型。

图书(models.Model):

名称 = models.CharField(最大长度= 20

价格 = models.FloatField()

pub_date = models.DateField()

发布 = models.ForeignKey(" 发布 " ,on_delete = models.CASCADE) -很多

authors = models.ManyToManyField(" Author " 多对多

def __ str __ (自我):

返回 self.name

发布(models.Model):

名称 = models.CharField(max_length = 32

city = models.CharField(max_length = 32

def __ str __ (个体经营):

返回 self.name

作者(models.Model):

名称 = models.CharField(max_length = 32

年龄 = models.IntegerField(默认= 20

def __ str __ (个体经营):

返回 self.name

\ 2.输入\\ ubsp; python manage.py makemigrations \ nbsp ;, python manage.py migration 两条命令

类属性的高级操作

   UserInfo(models.Model):

age = CharFiled(是否为空,类型,长度,列名称,索引,错误提示,自定义验证规则)

...

...

 字段参数

null数据库中的字段是否可以为空

db_column数据库中字段的列名

default数据库中字段的默认值

primary_key数据库中的字段是否为主键

db_index数据库中的字段是否可以建立索引

唯一数据库中的字段是否可以唯一索引(一对一)

unique_for_date是否可以对数据库的字段[date]部分进行唯一索引

数据库的unique_for_month字段[month]部分是否可以创建唯一索引

数据库中的unique_for_year字段[year]是否可以创建唯一索引

verbose_name管理员中显示的字段名称

在空白管理员中是否允许空白输入

可以在可编辑的管理员中进行编辑

help_text Admin中此字段的提示信息

选择框的内容显示在选择Admin中,未更改的数据放置在内存中,以避免跨表操作

例如:gf = models.IntegerField(choices = [(0," chen " ),(1," xiaoyi " ),],默认= 1

error_messages自定义错误消息

字典运行状况:null,空白,无效,invalid_choice,唯一, unique_for_date

例如:{ " null " :" 不能为空。 " " 无效 " :" 格式错误 " }


-----------增加

单个表格

添加方法一

b =书(名称= " python基础 " ,价格= 99,作者= " chen " ,pub_date = " 2017-12-12 "

b。保存()

添加第二种方法

Book.objects.create(名称= " PHP基础 " ,价格= 70,作者= " chen " ,pub_date = " 2016-12-12 "

-----------删除

单个表格

Book.objects.filter(作者= " liu " )。删除()

-----------更改

单个表格

Book.objects.filter(作者= " chen " )。更新(价格= 100

-----------检查

单个表格

book_list = Book.objects.all()

打印 (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(作者= " chen " )。值(" 名称 " " 价格 " 以字典形式显示

ret = Book.objects.filter(作者= " chen " )。 Values_list(" 名称 " " 价格 " Yiyuan Group display

book_list = Book.objects.exclude(作者= " chen " )。值(" 名称 " " 价格 " 除来自外部的chen数据

book_list = Book.objects.all()。值(" 名称 " )。根据字段重复数据删除字段的不同() 根据字段重复数据删除

ret = Book.objects.all()。值(" 名称 " )。与众不同()。 count() 基于字段的重复数据删除

Book.objects.filter(authors__id__in = [1,2]) 获取ID等于1或2个数据

Book.objects.filter(authors__id__range = [1,2]) range

通用__

价格数量大于50/85.41

book_list = Book.objects.filter(price__gt = 50).values((" 名称 " " 价格 "

模糊查询

book_list = Book.objects.filter(name__icontains = " P " )。值(" 名称 " " 价格 "


外键关系和参数

  ForeignKey(ForeignObject)

到,要关联的表的名称

to_field = 无,要关联的表中的字段名称

on_delete = 无,删除关联表中的数据时,当前表及其关联行的行为

- models.CASCADE,删除关联的数据,然后删除关联的数据(通常)

- models.DO_NOTHING,删除关联的数据,抛出错误IntegrityError

- models.PROTECT,删除关联的数据,引发错误ProtectedError

- models.SET_NULL,删除关联的数据,并将与之关联的值设置为null(前提是FK字段需要设置为nullable)

- models.SET_DEFAULT,删除关联的数据,并将与之关联的值设置为默认值(如果FK字段需要设置默认值)

related_name = 无,使用反向操作中的字段名称代替[table name_set],例如:obj。表名_set.all()

related_query_name = None,反向操作中使用的连接前缀,用于替换[表名],例如:models.UserGroup.objects.filter(表名__字段名= 1).values(" 表名__字段名称 "

limit_choices_to = 无,在Admin或ModelForm中显示相关数据时提供的条件:

如:

-limit_choices_to = {" nid__gt " :5 }

-limit_choices_to = lambda :{" nid__gt " :5 }

db_constraint = 是否在数据库中创建外键约束为True

parent_link = False是否在Admin中显示相关数据

书籍和出版社之间存在一对多的关系

  图书(models.Model):

名称 = models.CharField(最大长度= 20

价格 = models.FloatField()

pub_date = models.DateField()

发布 = models.ForeignKey(" 发布 " ,on_delete = models.CASCADE) -很多

def __ str __ (自我):

返回 self.name

发布(models.Model):

名称 = models.CharField(max_length = 32

city = models.CharField(max_length = 32

def __ str __ (个体经营):

返回 self.name

添加数据的方法

  添加多个表

Book.objects.create(名称= " linux操作和维护 " ,价格= 77,pub_date = " 2017-12-12 " ,publish_id = 2

Book.objects.create(名称 = " GO " ,价格= 23,pub_date = " 2017-05-12 " ,publish = publish_obj)

多表查询方法

  包括外键:一对多查询

查询人民出版社出版的所有图书的名称和价格

方法一:

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

ret = Book.objects.filter(publish = pub_obj).values(" 名称 " " 价格 "

方法2

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

打印(pub_obj.book_set.all()。值(" 名称 " " 价格 " ))) book_set

打印 (类型(pub_obj.book_set.all()))

方法三,使用__

ret = Book.objects.filter(publish__name = " 人民出版社 " )。值(" name " " 价格 "

Python基础书籍发行者的名称

法伊

ret = Publish.objects.filter(book__name = " Python基础 " )。值(" 名称 "

方法二

ret3 = Book.objects.filter(名称= " python基础 " )。值(" publish__name "

在北京出版的所有书籍

ret = Book.objects.filter(publish__city = " 北京 " )。值(" 名称 "

ret = Publish.objects.filter(城市= " 北京 style =" color:#800000;">" )


  图书(models.Model):

名称 = models.CharField(最大长度= 20

价格 = models.FloatField()

pub_date = models.DateField()

发布 = models.ForeignKey(

到 = " 发布 "

on_delete = models.CASCADE,

唯一 = 是,

一对一

def __ str __ (自我):

返回 self.name

发布(models.Model):

名称 = models.CharField(max_length = 32

city = models.CharField(max_length = 32

def __ str __ (个体经营):

返回 self.name


多对多关系和参数

  ManyToManyField(RelatedField)

到,要关联的表的名称

related_name = 无,使用反向操作中的字段名称代替[table name_set],例如:obj。表名_set.all()

related_query_name = None,反向操作中使用的连接前缀,用于替换[表名],例如:models.UserGroup.objects.filter(表名__字段名= 1).values(" 表名__字段名称 "

limit_choices_to = 无,在Admin或ModelForm中显示相关数据时提供的条件:

如:

-limit_choices_to = {" nid__gt " :5 }

-limit_choices_to = lambda :{" nid__gt " :5 }

对称 = 无,仅用于多对多自关联,对称用于指定是否在内部创建用于反向操作的字段

可选字段为:code,id,m1

BB(models.Model):

代码 = models.CharField(max_length = 12

m1 = models.ManyToManyField(" self " ,对称= True)

可选字段为:bb,code,id,m1

BB(models.Model):

代码 = models.CharField(max_length = 12

m1 = models.ManyToManyField(" self " ,对称= 错误)

通过 = 无,自定义第三个表时,请使用该字段指定关系表

through_fields = 无,自定义第三个表时,请使用这些字段来指定关系表中的哪些字段用作多对多关系表

来自 django.db import 型号

人员(models.Model):

名称 = models.CharField(最大长度= 50

组(models.Model):

名称 = models.CharField(最大长度= 128

成员 = models.ManyToManyField(

人,

通过 = " 成员 "

through_fields =(" " " " ),

成员资格(models.Model):

组 = models.ForeignKey(组,on_delete = models.CASCADE)

人 = models.ForeignKey(人,on_delete = models.CASCADE)

邀请者 = models.ForeignKey(

人,

on_delete = models.CASCADE,

related_name = " Membership_invites "

Invitation_reason = models.CharField(max_length = 64

db_constraint = 是,是否在数据库中创建外键约束

db_table = None,默认情况下创建第三个表时数据库中表的名称

书籍和作者之间的关系是多对多的

注意:使用authors = models.ManyToManyField("   Author  "  ),将自动创建book_authors表,您也可以自己创建一个关系表(将没有authors属性)

图书(models.Model):

名称 = models.CharField(最大长度= 20

价格 = models.FloatField()

pub_date = models.DateField()

作者 = models.ManyToManyField(" Author " 多对多

def __ str __ (自我):

返回 self.name

作者(models.Model):

名称 = models.CharField(max_length = 32

年龄 = models.IntegerField(默认= 20

def __ str __ (个体经营):

返回 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

打印 (book_obj.authors.all())

作者查找书籍

author_obj = Author.objects.get(id = 2

打印 (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])

  手动创建关系表

图书(models.Model):

名称 = models.CharField(最大长度= 20

价格 = models.FloatField()

pub_date = models.DateField()

def __ str __ (个体经营):

返回 self.name

Book_Author(models.Model):

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

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

作者(models.Model):

名称 = models.CharField(max_length = 32

年龄 = models.IntegerField(默认= 20

def __ str __ (个体经营):

返回 self.name

-----------增加

手动创建的关系表

Book_Author.objects.create(book_id = 2,author_id = 3

-----------检查

关联查询以查找该书的所有作者

Obj = Book.objects.get(ID = 2

打印 (obj.book_author_set.all()[0].author)

Chen出版的书籍和价格

ret = Book.objects.filter(book_author__author__name = " chen " )。值(" 名称 " " 价格 "

因为在手动创建的表中没有第三个字段,所以查询自动创建的表不方便,并且默认情况下自动创建的表只有三个字段

因此,介绍一下手动+自动关节创建表

  用户(models.Model):

用户名 = models.CharField(max_length = 32,db_index = True)

def __ str __ (个体经营):

返回 self.username

标签(models.Model):

title = models.CharField(max_length = 16

m = models.ManyToManyField(

到 = " 用户 "

通过 = " UserToTag "

through_fields = [" u " " t " ]

def __ str __ (个体经营):

返回 self.title

ManyToManyField只能在第三张表中创建三列数据

UserToTag(models.Model):

nid = models.AutoField(primary_key = True)

u = models.ForeignKey(to = " 用户 "

t = models.ForeignKey(to = " 标记 "

ctime = models.DateField()

对于关系表u,两个字段共同约束唯一性

元:

unique_together = [

" u " " t " ),

]


用户粉丝彼此关注(在同一用户表中,用户彼此相关)

  用户(models.Model):

用户名 = models.CharField(max_length = 32,db_index = True)

d = models.ManyToManyField(" 用户 " ,related_name = " b "

def __ str __ (个体经营):

返回 self.username

注意:自相关交叉表查询
symmetrical = 无,仅用于多对多自相关,对称用于指定是否创建内部反向操作字段

可选字段为:code,id,m1

BB(models.Model):

代码 = models.CharField(max_length = 12

m1 = models.ManyToManyField(" self " ,对称= True)

可选字段为:bb,code,id,m1

BB(models.Model):

代码 = models.CharField(max_length = 12

m1 = models.ManyToManyField(" self " ,对称= False)


首先导入模块

 来自 django.db.models  import  最小值,平均值,最大值,总和

来自 django.db.models import F,Q

  聚合函数(需要首先导入函数)

ret = Book.objects.all()。聚合(平均(" 价格 " ))

ret = Book.objects.all()。总计(chen_money = Sum(" 价格 " ))) 别名

查看每位作者的书的总价

值:按作者姓名分组

ret = Book.objects.values((" authors__name " )。注释(求和(" 价格 " ))

打印 (ret)

检查各个出版商发行的图书的最低数量

ret = Publish.objects.values(" 名称 " )。注释(最小值(<(span style =" color:#800000;">" book__price " ))

打印 (ret)

-----------------------------------------------------------------------------------------------------------------------------

F查询和Q查询,(使用之前导入模块)

F得到了值

Book.objects.all()。更新(price = F(" price " + 10

Q可以执行或操作,Q表示不可以

re = Book.objects.filter(Q(价格= 80)| Q(名称= " GO " ))

组合查询

re = Book.objects.filter(Q(name__contains = " G " ))

Q查询和关键字查询组合,Q应该在前面

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


  仅在使用ret和lazy值时查询

Re = Book.objects.filter(价格= 80) 无值

for i in re: 仅在使用时,您才查询

打印 (i)

打印 (重新)

--------------------------------------------------------------------

存在()

Re = Book.objects.filter(价格= 80

re.exists() 将会查询,但不会分配re,只能使用仅当为re变量分配值

----------------------------------------------------------------------

iterator()迭代器对象

Ret = Book.objects.filter(价格= 80

Ret = ret.iterator()

相关推荐

咨询软件
 
QQ在线咨询
售前咨询热线
QQ1922638