django 模型层（2）

2023-08-27 22:57:34

Django 模型层(2)

多表操作---模型之间的关系

1 一对一：作者----作者详细信息

2 一对多：书籍----出版社

3 多对多：书籍----作者

一创建模型(主键(id)自动创建)

没有任何关系的一张表的创建

class Emp(models.Model):

    name=models.CharField(max_length=32)

    age=models.IntegerField()

    salary=models.DecimalField(max_digits=8,decimal_places=2)

    dep=models.CharField(max_length=32)

    province=models.CharField(max_length=32)

单独一张表对应的模型类

1 一对一 OneToOneField

models.OneToOneField(to='AuthorDetail',null=True,on_delete=models.CASCADE)
参数to:表示与AuthorDetail绑定一对一关系
参数 null=True：表示允许为空；
参数on_delete：级联删除，表示当一对一关系的一方数据被删除了，其对应关系也删除了

class Author(models.Model):

        '''

        ...其他字段省去

        '''

       # 作者与authordetail建立一对一关系

    authordetail=models.OneToOneField(to='AuthorDetail',null=True,on_delete=models.CASCADE)

2一对多 ForeignKey (在多的一方（Book）绑定)

 基本书写格式：
　　　ForeignKey(to='被关联的表名’，null=True,on_delete=models.CASCADE)

class Book(models.Model):

    '''

        。。。

    '''

    # 创建一对多的关系:一个出版社可以对应多本书

    publish = models.ForeignKey(to='Publish', null=True, on_delete=models.CASCADE)

3 多对多 ManyToMany

　　注意：

　　　　1 自动创建关系表book_author；

 authors = models.ManyToManyField(to='Author')

class Book(models.Model):

    '''

      ...

    '''

    # 书籍与作者创建多对多的关系

    authors = models.ManyToManyField(to='Author')

from django.db import models

# Create your models here.

# 关系户:书籍------作者  多对多

#        书籍------出版社  一对多

#        作者------作者详细信息  一对一

class Book(models.Model):

    '''

        创建书籍表

    '''

    title = models.CharField(max_length=32)

    pub_date = models.DateField()

    price = models.DecimalField(max_digits=5, decimal_places=2)

    # 创建一对多的关系:一个出版社可以对应多本书

    publish = models.ForeignKey(to='Publish', null=True, on_delete=models.CASCADE)

    # 书籍与作者创建多对多的关系

    authors = models.ManyToManyField(to='Author')

    def __str__(self):

        return self.title

class Publish(models.Model):

    '''

       创建出版社表

       '''

    name = models.CharField(max_length=32)

    city = models.CharField(max_length=32)

    email = models.EmailField()

    def __str__(self):

        return self.name

class Author(models.Model):

    '''

    创建作者表

    '''

    name=models.CharField(max_length=32)

    age=models.IntegerField()

    # 作者与authordetail建立一对一关系

    authordetail=models.OneToOneField(to='AuthorDetail',null=True,on_delete=models.CASCADE)

    def __str__(self):

        return self.name

class AuthorDetail(models.Model):

    '''

    创建作者详细信息表

    '''

    birthday=models.DateField()

    telephone=models.BigIntegerField()

    addr=models.CharField(max_length=64)

    def __str__(self):

        return self.addr

创建表模型类的完整代码

4 数据迁移

方法一

python manage.py makemigrations

python manage.py migrate

数据迁移代码

方法二

pycharm 中快捷启动方式

5 创建的表结果

二添加记录

单表添加数据的两种基本方式

models.AuthorDetail(id=1,birthday="1995-12-12",telephone=110,addr="北京")

方式一（类的是实例化）

obj=models.AuthorDetail.objects.create(birthday="1995-12-12",telephone=110,addr="北京")

方式二（模型类objects管理器下的create方法）

1 一对一

 # 添加一对一关系记录方式一

    models.Author.objects.create(name='alex',age='',authordetail_id=1)

 # 添加一对一关系记录方式二

wusir_d = models.AuthorDetail.objects.create(birthday="1999-8-12", telephone=666, addr="上海")

wusir=models.Author.objects.create(name='wusir',age=18,authordetail=wusir_d) #接收记录对象

2 一对多

# 绑定方式一

python=models.Book.objects.create(title='python',pub_date='2015-10-8',price=120,publish_id=1)

# 绑定方式二

strawberry=models.Publish.objects.create(name='草莓出版社',city='武汉',email='999@eee')

go=models.Book.objects.create(title='go',pub_date='2014-12-9',price=150,publish=strawberry)

3 多对多(如何给关系表添加数据)

正向:找关联属性

 # 正向绑定用字段  书籍找关系表通过Author属性

   python=models.Book.objects.filter(title='python').first()

    go=models.Book.objects.filter(title='go').first()

    alex=models.Author.objects.filter(name='alex').first()

    egon=models.Author.objects.filter(name='egon').first()

    print(python,alex,egon)

    print(python.publish.city)

给python书籍绑定两个作者信息

反向:表名小写

    linux = models.Book.objects.filter(title="linux").first()

    R = models.Book.objects.filter(title="R").first()

    wusir = models.Author.objects.filter(name="wusir").first()

    wusir.book_set.add(linux,R)

给egon绑定两本书

给关联表添加记录的方法

#以python书籍对象为例

python.authors.remove(alex)#移除作者信息 alex

python.authors.clear()  #清空作者信息

python.authors.add(作者对象1,作者对象2) #添加作者信息

python.authors.add(1,2) #添加作者信息

python.authors.set([ 1,]) #先清空后设置值

关联表的方法

二基于对象的跨表查询 ********

方法总结

                正向查询:按照关系字段

       对象1  -----------------------------------------> 对象2

             <----------------------------------------

                    反向查询:按照表名小写_set.all()

                    是否需要_set取决于结果的个数,

                    多个结果加_set.all()

1 一对一

 # 正向制作者--->作者详细信息

    #alex---->电话号码

    # alex=models.Author.objects.filter(name='alex').first()

    # result=alex.authordetail.telephone

正向查询

    # 反向查询作者<----作者详细信息

    #tel=110的作者是谁

    # ad=models.AuthorDetail.objects.filter(telephone=110).first()

    # result=ad.author.name

反向查询

2 一对多

 # 查询linux这本书籍的出版社信息地址(正向查询)

    linux=models.Book.objects.filter(title='linux').first()

    result=linux.publish.city

正向查询

    # 反向查询(出版社--->书籍)

    # 查询橘子出版社出版过的所有书籍

    publish=models.Publish.objects.filter(name='橘子出版社').first()

    print(publish)

    result=publish.book_set.all()

    print(result) #<QuerySet [<Book: java>]>

    for  i  in result:

        print(i.title)

反向查询

3 多对多

正向查询

反向查询

三基于双下划线的跨表查询

模型类.objects.filter().values()

1 跨表操作在filter 和values使用__(双下划线)进行跨表操作;

2 正向查询按关联字段,反向查询按照表名小写;

　　1 一对一

    # 查询alex的手机号

    # 正向查询

    ret=Author.objects.filter(name="alex").values("authordetail__telephone")

    # 反向查询

    ret=AuthorDetail.objects.filter(author__name="alex").values("telephone")

　　2 一对多

# 练习:  查询苹果出版社出版过的所有书籍的名字与价格(一对多)

    # 正向查询 按字段:publish

    queryResult=Book.objects

　　　　　　　　　　　　.filter(publish__name="苹果出版社")

　　　　　　　　　　　　.values_list("title","price")

    # 反向查询 按表名:book

    queryResult=Publish.objects

　　　　　　　　　　　　　　.filter(name="苹果出版社")

　　　　　　　　　　　　　　.values_list("book__title","book__price")

　　3 多对多

# 练习: 查询alex出过的所有书籍的名字(多对多)

    # 正向查询 按字段:authors:

    queryResult=Book.objects

　　　　　　　　　　　　.filter(authors__name="yuan")

　　　　　　　　　　　　.values_list("title")

    # 反向查询 按表名:book

    queryResult=Author.objects

　　　　　　　　　　　　　　.filter(name="yuan")

　　　　　　　　　　　　　　.values_list("book__title","book__price")

　　4 进阶练习(连续跨表)

# 练习: 查询人民出版社出版过的所有书籍的名字以及作者的姓名

    # 正向查询

    queryResult=Book.objects

　　　　　　　　　　　　.filter(publish__name="人民出版社")

　　　　　　　　　　　　.values_list("title","authors__name")

    # 反向查询

    queryResult=Publish.objects

　　　　　　　　　　　　　　.filter(name="人民出版社")

　　　　　　　　　　　　　　.values_list("book__title","book__authors__age","book__authors__name")

# 练习: 手机号以151开头的作者出版过的所有书籍名称以及出版社名称

    # 方式1:

    queryResult=Book.objects

　　　　　　　　　　　　.filter(authors__authorDetail__telephone__regex="")

　　　　　　　　　　　　.values_list("title","publish__name")

    # 方式2:

    ret=Author.objects

              .filter(authordetail__telephone__startswith="")

              .values("book__title","book__publish__name")

双下划线跨表跨表巩固

四聚合查询于分组

emp－dep:

id  name age   salary   dep_id   id   name

1   alex  12   2000       1      1    销售部

2   egon  22   3000       2      2    人事部

3   wen   22   5000       2      2    人事部

class Emp(models.Model):

    name=models.CharField(max_length=32)

    age=models.IntegerField()

    salary=models.DecimalField(max_digits=8,decimal_places=2)

    dep=models.CharField(max_length=32)

    province=models.CharField(max_length=32)

　　1 聚合 (aggregate) ---聚合函数 Sav, Max, Min, Avag

基本语法:

    模型类.objects.aggregate(聚合函数( 字段 ))
结果:queryset类型,一个对象一个字典保存数据

实例1:

# 计算所有图书的平均价格

    from django.db.models import Avg

    Book.objects.all().aggregate(Avg('price')) #  {'price__avg': 34.35}

实例2:

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

    Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))

#{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

　　2 分组(annotate)

key:

    跨表分组查询本质就是将关联表join成一张表，再按单表的思路进行分组查询。

语法格式:

    (1)模型类.objects.all().value('分组条件').annotate('聚合函数')

                结果是queryset对象,其中元素是字典

              <QuerySet [{..},{...}]>

    (2)模型类.objects.all().annotate('聚合函数') #以主键分组

                结果是queryset对象,其中元素是对象

                #<QuerySet [<Book: java>,<Book: java>]>

　　3 练习

(1)统计每个出版社的最便宜的书

publish_list=models.Publish.objects.annotate(min("book_price"))

for publish_obj in publish_list:

    print(publish_obj.name,publish_obj.MinPrice)

简化代码:

queryResult= Publish.objects

　　　　　　　　　　　　.annotate(MinPrice=Min("book__price"))

　　　　　　　　　　　　.values_list("name","MinPrice")

print(queryResult)

SELECT "app01_publish"."name", MIN("app01_book"."price")  AS "MinPrice" FROM "app01_publish"

LEFT  JOIN "app01_book" ON ("app01_publish"."nid" = "app01_book"."publish_id")

GROUP BY "app01_publish"."nid", "app01_publish"."name", "app01_publish"."city", "app01_publish"."email"

对应mysql语句

(2)统计每本书的作者个数

models.Book.objects.annotate(authorsNum=Count('authors'))#待会检测

(3)统计每一本以py开头的书籍的作者个数

models.Book.objects.filter(title_startswith='py')
　　　　　　　　　　　　.annocate(num_authors=Count('authors')
　　　　　　　　　　　　.values('title','c')

(4)统计不止一个作者的图书

models.Book.objects

                   .annocate( num_authors=Count('author'))

                   .filter(num_authors__lg=1)

(5)根据一本图书作者数量的多少对查询集 QuerySet进行排序

models.Book.objects

           .annotate(num_authors=Count('authors'))

          .order_by('num_authors')

(6)查询各个作者出的书的总价格

models.author.objects

           .annotate(sum_price=sum('book__price'))

           .values('name','sum_price')

五 F查询与Q 查询

　　1 F查询 ---- F('字段名')

(1) 意义

1 在过滤条件中借助F查询,使得字段之间可以作比较;

    2 在过滤条件中借助F查询,使得字段之间可以做四则运算;

(2) 字段之间的比较实例

# 查询评论数大于收藏数的书籍

from django.db.models import F

models.objects.filter(commentNum__lg=F('keepNum'))

(3) 四则运算在过滤条件中的应用

# 查询评论数大于收藏数2倍的书籍

from django.db.models import F

models.Book.objects.filter(commerntNum__lg=F('keepNum')*2)

#修改操作也可以使用F函数,比如将每一本书的价格提高30元：

models.Book.objects.update(price=F('price)+30)

　　2 Q 查询 ---- Q('字段名')

(1) 意义

使得过滤条件的方式不再是单一的 & (与)运算

Q查询中的与|或|非

与: &

或: |

非: ~

(2)查询价格大于300或者名称以p开头的书籍 ( | 或运算)

queryset=models.Book.objects.filter(price__lg=300|Q(title__startswith='p')).values('title')

(3)查询价格大于300或者不是2019年一月份的书籍

models.Book.objects.filter(title__lg=300|~Q(Q(pub_date_year=2016)&Q(pub_date_mouth=1)))

码农公寓

Django 模型层(2)

多表操作---模型之间的关系

一 创建模型(主键(id)自动创建)

没有任何关系的一张表的创建

1 一对一 OneToOneField

2一对多 ForeignKey (在多的一方（Book）绑定)

3 多对多 ManyToMany

4 数据迁移

5 创建的表结果

二 添加记录

单表添加数据的两种基本方式

1 一对一

2 一对多

3 多对多(如何给关系表添加数据)

二 基于对象的跨表查询 ********

1 一对一

2 一对多

3 多对多

三 基于双下划线的跨表查询

1 一对一

2 一对多

3 多对多

4 进阶练习(连续跨表)

四 聚合查询于分组

1 聚合 (aggregate) ---聚合函数 Sav, Max, Min, Avag

2 分组(annotate)

3 练习

五 F查询与Q 查询

1 F查询 ---- F('字段名')

2 Q 查询 ---- Q('字段名')

相关文章

一创建模型(主键(id)自动创建)

二添加记录

二基于对象的跨表查询 ********

三基于双下划线的跨表查询

　　1 一对一

　　2 一对多

　　3 多对多

　　4 进阶练习(连续跨表)

四聚合查询于分组

　　1 聚合 (aggregate) ---聚合函数 Sav, Max, Min, Avag

　　2 分组(annotate)

　　3 练习

　　1 F查询 ---- F('字段名')

　　2 Q 查询 ---- Q('字段名')