11.29

目录

• 1、非外键字段数据
  • 1.1 增加
  • 1.2 查询
    • 1.2.1 常用方法
      • (1)先获取QuerySet对象
      • (2)基于QuerySet获取数据对象
      • (3)基于数据对象获取数据值
      • (4)其他
    • 1.2.3 模糊查询
  • 1.3 修改
  • 1.4 删除
• 2、外键字段数据
  • 2.0 级联更新
    • 2.1 一对一
    • 2.2 一对多
      • 2.2.1 增加
      • 2.2.2 修改
      • 2.2.3 删除
      • 2.2.4 注意点
      • 2.3 多对多
      • 2.3.1 增加：add()
        • 绑定id值
        • 传对象
      • 2.3.2 修改：set()
      • 2.3.3 删除：remove()
      • 2.3.4 清空 ：clear()
    • 2.4 跨表查询
      • 2.4.1 正反向查询
      • 2.4.2 基于对象的跨表查询
      • 2.4.3 基于双下滑线的跨表查询
• 3、聚合查询
  • 3.1 聚合函数
  • 3.2 分组查询
• 3、F查询
  • 3.1 使用F查询
• 4、Q查询
  • 4.1 Q查询的基本使用方法
  • 4.2 Q查询的高级使用方法
• 5、orm字段及参数
  • 5.1 常用字段
  • 5.2 自定义char字段
• 6、orm中的事务操作
  • 6.1 什么是事务
  • 6.2 django使用事务
• 7、orm查询优化
  • 7.1 orm惰性查询
  • 7.2 only与defer
  • 7.3 select_related与prefetch_related

1、非外键字段数据

1.1 增加

1、create方法

#以books表为例
#在create方法中,以逗号分隔，以关键字参数传字段数据，它们是AND关系
book_obj = models.Books.objects.create()

2、对象的绑定方法save

'''
1、先实例化一个表数据对象
2、调用对象绑定方法save
'''
book_obj = models.Books()  # 实例化参数：关键字形式，字段名=字段值
book_obj.save()

1.2 查询

1.2.1 常用方法

(1)先获取QuerySet对象

QuerySet对象

filter查询出来的结果是一个QuerySet对象

• 只要是QuerySet对象就可以无限制的调用QuerySet的方法

  res= models.Books.objects.filter(pk=1).filter().filter().filter().filter()

• 只要是QuerySet对象就可以点query查看当前结果内部对应的sql语句

1、all()

查询所有，返回的结果为QuerySet对象

res = models.Books.objects.all()

2、filter()

筛选，返回结果为QuerySet对象

res = models.Books.objects.filter(pk=1,title='三')  # 支持多个参数 并且是and关系

3、get()

筛选，返回结果为数据对象

条件不存在直接报错 并且查询条件必须是唯一的

 res = models.Books.objects.get(title='西游记')

4、values()

获取数据对象中指定的字段的值

返回的结果为：queryset对象，值为列表套字典，如：

res = models.Books.objects.values('title','price')
print(res)
'''
<QuerySet [{'title': '三国演义', 'price': Decimal('222.66')}, {'title': '红楼梦', 'price': Decimal('888.99')}, {'title': '西游记', 'price': Decimal('444.66')}, {'title': '西游记', 'price': Decimal('666.22')}]>
'''

5、values_list()

获取数据对象中指定的字段的值

返回的结果为：queryset对象，值为列表套原则，如：

res = models.Books.objects.values_list('title','price')
print(res)
'''
<QuerySet [('三国演义', Decimal('222.66')), ('红楼梦', Decimal('888.99')), ('西游记', Decimal('444.66')), ('西游记', Decimal('666.22'))]>
'''

6、order_by()

按照指定的顺序排序

#默认升序

res = models.Books.objects.order_by('price')
res1 = models.Books.objects.all().order_by('price')

#降序：排序字段前加-号

res1 = models.Books.objects.all().order_by('-price')

7、reverse()

颠倒顺序

前提是跌倒的对象必须有顺序，即被排序过了的

res = models.Books.objects.all()
res1 = models.Books.objects.all().reverse()

8、exclude()

排除什么什么之外，返回的是QuerySet对象

res = models.Books.objects.all().exclude(title='三国演义')

9、distinct()

对查询结果进行去重操作

去重的前提：数据必须是完全相同的情况下才能够去重，包括主键

res = models.Books.objects.values('title','price')
res = models.Books.objects.values('title','price').distinct()

(2)基于QuerySet获取数据对象

4、first()

取queryset中第一个数据对象

res = models.Books.objects.filter(title='西游记').first()

5、last()

取queryset中第一个数据对象

res = models.Books.objects.filter(title='西游记').last()

(3)基于数据对象获取数据值

数据对象可以通过对象.属性的方式获取值

# 以Books表的一条数据对象为例

value = book_obj.name

(4)其他

1、exists()

判断查询结果是否有值，返回结果是一个布尔值

res = models.Books.objects.filter(pk=1).exists()

2、count()

统计数据的个数

num = models.Books.objects.count()

1.2.2 双下划线查询
语法：字段名__方法名

使用：一般作为filter()的过滤条件

下表中示例语句，省略models.Books.objects.

方法	说明	示例
__gt	大于	filter(price__gt=500
__lt	小于	filter(price__lt=400)
__gte	大于等于	filter(price__gte=500)
__lte	小于等于	filter(price__lte=500)
__in	在...中	filter(price__in=[222,444,500])
__range	在某区间内，参数为[]，包含两端	filter(price__range=(200,800))
__year	是某年	filter(publish_date__year='2019')
__month	是某月	filter(publish_date__month='1')

1.2.3 模糊查询

语法：字段名__方法名

使用：一般作为filter()参数

以下示例，省略models.Books.objects.

方法	说明	示例
__startswith	以某字符串结尾	filter(title__startswith='三')
__endswith	以某字符串结束	filter(title__endswith='1')
__contains	包含某字符串	filter(title__contains='游')
__icontains	包含某字符串，但忽略大小写	filter(title__icontains='p')

1.3 修改

1、QuerySet方法

 models.Books.objects.filter(pk=1).update(price=444.66)

2、对象的绑定方法

# 先获取对象

book_obj = models.Books.objects.get(pk=1)

# 再调用对象的绑定方法

book_obj.save()

注意点：

利用对象的修改 内部其实是重头到位将数据的所有字段都重新写一遍

1.4 删除

1、QuerySet方法

 models.Books.objects.filter(pk=1).delete()

2、对象的绑定方法

# 先获取对象

book_obj = models.Books.objects.get(pk=1)

# 再调用对象的绑定方法

book_obj.delete()

2、外键字段数据

2.0 级联更新

指的是：当一对一或多对一关系中，表中的外键字段指向的数据被删除/更新时，该表中的数据也会被删除/更新

mysql数据库，1版本默认级联更新、级联删除，2版本需要手动指定外键字段的约束条件

ON DELETE CASCADE 级联删除
ON UPDATE CASCADE 级联更新

2.1 一对一

2.2 一对多

2.2.1 增加

1、create()

同非外键字段的create方法，传主键值

2、传虚拟字段

# 先查询关联的数据对象

publish_obj = models.Publish.objects.filter(pk=2).first()

# 再将对象作为参数传给外键（定义中写到的外键，是一个虚拟字段）

models.Book.objects.create(title='红楼梦',price=444.33,publish=publish_obj)  # Book表中只有publish_id字段，publish字段是一个虚拟字段，是定义表时创建的

2.2.2 修改

1、update()

同非外键字段的update方法

models.Book.objects.filter(pk=1).update(publish_id=2)

2、传虚拟字段

使用update方法，但是以虚拟字段传参，同2.2.1

2.2.3 删除

models.Publish.objects.filter(pk=1).delete() 

2.2.4 注意点

默认级联删除，级联更新

2.3 多对多

以表Book和Author为例

1、先查有外键的表中的数据对象

book_obj = models.Book.objects.filter(pk=2).first()

2、数据对象点外键，可能直接获取外键关联的数据对象

book_obj.authors

# 获取到关联的数据对象，即现在已经从Book跨到Author了

此时就能操作多对多的记录了

2.3.1 增加：add()

使用add方法，给多对多关系的第三张表，即关系表中添加对应的关系

绑定id值

book_obj.authors.add(1)  # 在第三张表里面给书籍绑定一个主键为1的作者

book_obj.author.add(1,2)  # 由于时多对多，因此可以绑定多个

传对象

# 先查出来对应的对象

author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()

# 再使用add传值，操作关系表

book_obj.authors.add(author_obj,author_obj1)  # 可以绑定多个

2.3.2 修改：set()

使用set方法，修改多对多关系表中的数据

使用方式，同增加add

注意点：

传参数时，要用可迭代对象的形式，如元组

set((1,2))  # 传数字
set((author_obj,author_obj1))  # 传对象

2.3.3 删除：remove()

使用delete方法，删除多对多关系表中的数据

使用方式，同增加add

注意点：

传参数时，不需要使用迭代对象，跟add方法基本一致

2.3.4 清空 ：clear()

删除某个数据在第三张表中的所有记录，不需要参数

book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.clear()

2.4 跨表查询

2.4.1 正反向查询

以A查B为例，A中定义了A和B的关系，有外键key

正向查询：从A查B

反向查询：从B查A

关键语法：

# 正向查询 :对象.外键

# 反向查询 :对象.关联的表名小写 + _set

# 当一对一关系时，反向查询不需要加_set

2.4.2 基于对象的跨表查询

# 正向查询 :对象.外键

a_obj = models.A.objects.filter(tk=2).first()
b_obj = a_obj.key # 对象.外键即可得到关联的对象

b_obj_list = a_obj.key.all()  # 当关联的数据对象有多个时，要加all()才能得到，否则得到的是app01.A.None

# 反向查询 :对象.关联的表名小写 + _set

b_obj = models.B.objects.filter(tk=3).first()
a_obj = b_obj.a_set

a_obj_list = b_obj.a_set.all()  # 同样，当关联多个数据时，要加all(),否则得到的是app01.B.None

2.4.3 基于双下滑线的跨表查询

1、写外键字段就相当于已经跨到外键字段所关联的表

2、你想要改表的哪个字段信息 你只需要加__获取即可

3、models后面点的谁 就以谁为基表

示例：

1.查询书籍pk为2的出版社名称
    # 正向
res = models.Book.objects.filter(pk=2).values('publish__name') 
    # 反向
res = models.Publish.objects.filter(book__pk=2).values('name')

2.查询书籍pk为2的作者姓名和邮箱
res = models.Book.objects.filter(pk=2).values('authors__name','authors__email')
res = models.Author.objects.filter(book__pk=2).values('name','email')

3.查询作者是egon的家庭地址
res = models.Author.objects.filter(name='egon').values('author_detail__addr')
res = models.AuthorDetail.objects.filter(author__name='egon').values('addr')

4.查询出版社是东方出版社出版过的书的名字
res = models.Publish.objects.filter(name='东方出版社').values('book__title')
res = models.Book.objects.filter(publish__name='东方出版社').values('title')

5.查询书籍pk是2的作者的手机号
res = models.Book.objects.filter(pk=2).values('authors__author_detail__phone')
res = models.Author.objects.filter(book__pk=2).values('author_detail__phone')

3、聚合查询

3.1 聚合函数

Max/Min/Sum/Avg/Count

需要导入模块：from django.db.models import Max, Min, Sum, Count, Avg

关键语法：aggregate(分组名=聚合函数(参数))

查询结果：字典

注意点：

1、聚合函数必须在分组之后才能使用

2、没有分组，即默认整体就是一组

3、给聚合函数的调用取名，则可以使用改名引用查询结果

4、取名时，结果中的key为分组名，不取名时，django会自动用参数字段名__聚合函数名作为key

# 参数一般为字段名，如：

models.Book.objects.aggregate(mr = Max('price'))

示例：

# test.py 在测试文件中测试，打印结果

# 1.筛选出价格最高的书籍

res = models.Book.objects.aggregate(mr = Max('price'))

# 2.求书籍总价格

res = models.Book.objects.aggregate(sm = Sum('price'))

# 3.求书籍平均价格

res = models.Book.objects.aggregate(av = Avg('price'))

# 4.同时使用多个聚合函数

res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('price'),Avg('price'))

3.2 分组查询

1、关键字：annotate

2、关键语法：QuerSet对象.annotate(聚合函数)

示例：

1.统计每一本书的作者个数、书名和对应的作者人数
res = models.Book.objects.annotate(author_num=Count('authors__id')).values('title','author_num')
print(res)

2.统计出每个出版社卖的最便宜的书的价格、出版社的名字和价格
res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
print(res)

按照其他字段分组
res = models.Publish.objects.values('想要分组的字段名').annotate(min_price=Min('book__price')).values('name','min_price')
print(res)

3.统计不止一个作者的图书
res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title','author_num')
print(res)

4.查询各个作者出的书的总价格  作者名字  总价格
res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
print(res)

3、F查询

3.1 使用F查询

F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值

需要导入模块：from django.db.models import F

示例：

from django.db.models import F

# 1. 查询库存数大于卖出数的书籍

res = models.Book.objects.filter(kun_cun__gt = F('mai_cun')).values('title')  # 后面的条件是来自于数据库的其他字段值

# 2. 将所有书的价格上涨100块

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

3.2 利用F查询，修改char字段

# 将所有书的名称后面全部加上 "爆款" 后缀

# 操作字符串数据需要借助于Concat方法

from django.db.models.functions import Concat
from django.db.models import Value
ret3 = models.Book.objects.update(title=Concat(F('title'), Value('新款')))

4、Q查询

4.1 Q查询的基本使用方法

filter() 等方法中逗号隔开的条件是与的关系

如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象

操作符：

&：代表AND

|：代表OR

~：代表取反

注意点：

0、使用逗号分隔多个参数

1、可以组合使用操作符以及括号来编写任意复杂的Q对象

2、查询函数可以混合使用Q 对象和关键字参数

3、所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起

4、但是，如果出现Q 对象，它必须位于所有关键字参数的前**

示例：

from django.db.models import Q

# 1.查询一下书籍名称是三国演义 或者 库存数是500的书籍

res = models.Book.objects.filter(title='三国演义',kun_cun=500)  # and关系
res = models.Book.objects.filter(Q(title='三国演义'),Q(kun_cun=500))  # Q包裹之后逗号还是and关系
res = models.Book.objects.filter(Q(title='三国演义') | Q(kun_cun=500))  #  |就是or的关系
res = models.Book.objects.filter(~Q(title='三国演义') | Q(kun_cun=500))  #   ~就是not关系
print(res)

4.2 Q查询的高级使用方法

q = Q()
q.connector = 'or'  # 默认是and  可以改成or
q.children.append(('title','三国演义'))
q.children.append(('kun_cun__gt',500))
res = models.Book.objects.filter(~q)  # 取反
print(res)

5、orm字段及参数

5.1 常用字段

CharField     varchar
IntegerField   int
BigIntegerField   bigint
EmailField    varchar(254)
DateField
DateTimeField
'''
    参数说明：
    auto_now:每次修改数据的时候 都会自动将当前修改时间更新上去  实时更新
    auto_now_add:在创建数据的时候 会将当前时间自动记录 之后不会自动修改  除非你人为修改
    '''
AutoField     auto_increment   

BooleanField    布尔值  
'''
    该字段在存储的时候 你只需要传布尔值True或False
    它会自动存成1/0
'''

TextField  专门用来存大段文本

FileField  专门用来文件路径   '/etc/data/a.txt'   

upload_to = '/etc/data'
'''
    给该字段传值的时候 直接传文件对象
    会自动将文件对象保存到upload_to后面指定的文件路径中
    然后将路径保存到数据库
'''

DecimalField(Field)
'''
    1、10进制小数
    2、参数：
    max_digits，小数总长度
    decimal_places，小数位长度
'''

5.2 自定义char字段

class MyCharField(models.Field):
    def __init__(self, max_length, *args, **kwargs):
        self.max_length = max_length
        # 重新调用父类的方法         
​        super().__init__(max_length=max_length, *args, **kwargs)

​        def db_type(self, connection):
​            return 'char(%s)' % self.max_length

5.3 特殊参数choices
1、定义字段时，指定参数choices

2、choices的值为元组套元组（事先定义好，一般在该表类中定义该字段之前定义）

3、每一个元组存放两个元素，形成一种对应关系

4、往数据库中存值时，该字段的值存为元组第一个元素即可

5、通过方式对象.get_字段名_display()获取对应的元组第二个元素值，当没有对应关系时，返回的是它本身

示例：

# 定义一个User表

class User(models.Model):
    username = models.CharField(max_length=64)
    gender_choices = ((1,'男'),(2,'女'),(3,'其他'))
    gender = models.IntegerField(choices=gender_choices)
    

# 同步迁移到数据库

python manage.py makemigrations
python manage.py migrate

# 在test.py配置测试环境

# 录入数据

models.User.objects.create(username='aaa', gender=1)
models.User.objects.create(username='bbb', gender=2)
models.User.objects.create(username='ccc', gender=3)
models.User.objects.create(username='ddd', gender=4)

# 验证choices

for user_obj in models.User.objects.all():
    print(user_obj.gender,end=' ')
    print(user_obj.get_gender_display())
'''
1 男
2 女
3 其他
4 4
'''    

6、orm中的事务操作

6.1 什么是事务

将多个sql语句操作编程原子性操作，要么同时成功，否则有一个失败则里面回滚到原来的状态，保证数据的完整性和一致性（NoSQL数据库对于事务则是部分支持）

6.2 django使用事务

from django.db import transaction

with transaction.atomic():
    # 在缩进的代码中书写数据库操作
    # 该缩进内的所有代码 都是一个事务
    pass

7、orm查询优化

即尽量减少对数据库的操作，减轻数据库的压力

# 在缩进的代码中书写数据库操作
# 该缩进内的所有代码 都是一个事务

​ pass
7、orm查询优化
即尽量减少对数据库的操作，减轻数据库的压力

7.1 orm惰性查询

orm内所有的sql查询语句，都是惰性操作，即当你需要使用查询结果时，才会真正去执行sql语句访问数据库，否则是不会执行查询的

可使用代码验证：

1、配置settings文件，使得当执行sql语句时，在终端打印sql命令

2、验证

# 只查询，不使用查询结果

models.User.objects.all()

# 将查询结果赋值给变量res

res = models.User.object.all()

# 分别执行，查看终端的打印结果

7.2 only与defer

only查询：指定查询某字段时，将全部结果一次性获取出来，以后再访问该字段数据时，直接从内存中拿即可，不需要再操作数据库

defer查询：指的是一次性获取指定字段之外的所有字段数据，封装到对象中，以后再访问这些字段数据时，直接从内存中拿即可，不需要再操作数据库

代码：

# 同样，可以配置settings，在终端中打印被执行的sql命令

# all()查询

res = models.User.objects.all()  # 访问一次数据库，打印一条sql命令,获取所有的User表中的数据到内存

# only查询

res = models.User.objects.only(username)  # 访问一次数据库，打印一条sql命令，仅仅获取username的所有数据到内存
for user_obj in res:
    print(user_obj.username)  # 直接从内存中获取，不访问数据库，不打印sql命令
    print(user_obj.gender)  # 每执行一次，就访问一次数据库，打印一次sql命令
    

# defer 查询

res = models.User.objects.defer(usernmae)  # 访问一次数据库，打印一条sql命令，获取除了username之外的所有数据到内存
for user_obj in res:
    print(user_obj.username)  # 每执行一次，访问一次数据库，打印一条sql命令
    print(user_obj.gender)  # 直接从内存中获取，不访问数据库，不打印sql命令

7.3 select_related与prefetch_related

当表中有外键时，使用方法减轻数据库的压力

select_related:指定外键，将本表与该外键关联的表拼成一张表（inner join），并获取所有数据到内存，不能指定多对多关系的外键

prefetch_related:指定外键，先查询本表所有数据，再根据外键查询对应的数据表所有数据，相当于子查询，可以指定多个外键，即多个子查询