Django进阶-ORM框架的一般操作

必知必会

返回QuerySet对象

1 .all()            # 所有
2 .filter()            # 符合条件的
3 .exclude()        # 排除符合条件的
4 .values()            # 取出相应的字段值(不写字段,取出所有), 可以连表取值 --> 字典格式{}
5 .values_list()    # 取出相应的字段值(不写字段,取出所有), 可以连表取值 --> 元祖格式()
6 .order_by()        # 对查询结果排序
7 .reverse()        # 对查询结果反向排序, 只能在已定义顺序的QuerySet上调用
8 .distinct()        # 去重

返回具体对象

9 .get()            # 符合条件的, 只返回一个,找不到就报错
10 .first()            # 返回第一个
11 .last()            # 返回最后一个

返回布尔值

12 .exists()        # 判断表里有没有数据

返回具体数值

13. count()            # 返回查询到的QuerySet的数量

总体示例

import os

if __name__ == "__main__":
    # 加载Django项目的配置信息
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ormday69.settings")
    # 导入Django, 并启动
    import django
    django.setup()

    from app01 import models
    ret = models.Person.objects.all()
    print(ret)

    ret = models.Person.objects.filter(name='一米')
    print(ret)

    ret = models.Person.objects.get(id=1)
    print(ret)

    ret = models.Person.objects.exclude(name='小黑')
    print(ret)

    ret = models.Person.objects.values('name')
    print(ret)

    ret = models.Person.objects.values_list()
    print(ret)

    ret = models.Person.objects.values_list().order_by('birthday')
    print(ret)

    ret = models.Person.objects.all().order_by('age').reverse()
    print(ret)

    ret = models.Person.objects.all().count()
    print(ret)

    ret = models.Person.objects.all().first()
    print(ret)

    ret = models.Person.objects.all().last()
    print(ret)

    ret = models.Person.objects.exists()
    print(ret)

queryset方法补充

##################################################################
# PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
##################################################################

def all(self)
    # 获取所有的数据对象

def filter(self, *args, **kwargs)
    # 条件查询
    # 条件可以是：参数，字典，Q

def exclude(self, *args, **kwargs)
    # 条件查询
    # 条件可以是：参数，字典，Q

def select_related(self, *fields)
    性能相关：表之间进行join连表操作，一次性获取关联的数据。

    总结：
    1. select_related主要针一对一和多对一关系进行优化。
    2. select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。

def prefetch_related(self, *lookups)
    性能相关：多表连表操作时速度会慢，使用其执行多次SQL查询在Python代码中实现连表操作。

    总结：
    1. 对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。
    2. prefetch_related()的优化方式是分别查询每个表，然后用Python处理他们之间的关系。

def annotate(self, *args, **kwargs)
    # 用于实现聚合group by查询

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

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
    # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
    # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
    # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

def distinct(self, *field_names)
    # 用于distinct去重
    models.UserInfo.objects.values('nid').distinct()
    # select distinct nid from userinfo

    注：只有在PostgreSQL中才能使用distinct进行去重

def order_by(self, *field_names)
    # 用于排序
    models.UserInfo.objects.all().order_by('-id','age')

def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    # 构造额外的查询条件或者映射，如：子查询

    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

 def reverse(self):
    # 倒序
    models.UserInfo.objects.all().order_by('-nid').reverse()
    # 注：如果存在order_by，reverse则是倒序，如果多个排序则一一倒序


 def defer(self, *fields):
    models.UserInfo.objects.defer('username','id')
    或
    models.UserInfo.objects.filter(...).defer('username','id')
    #映射中排除某列数据

 def only(self, *fields):
    #仅取某个表中的数据
     models.UserInfo.objects.only('username','id')
     或
     models.UserInfo.objects.filter(...).only('username','id')

 def using(self, alias):
     指定使用的数据库，参数为别名（setting中的设置）


##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
##################################################

def raw(self, raw_query, params=None, translations=None, using=None):
    # 执行原生SQL
    models.UserInfo.objects.raw('select * from userinfo')

    # 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名
    models.UserInfo.objects.raw('select id as nid from 其他表')

    # 为原生SQL设置参数
    models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])

    # 将获取的到列名转换为指定列名
    name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
    Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)

    # 指定数据库
    models.UserInfo.objects.raw('select * from userinfo', using="default")

    ################### 原生SQL ###################
    from django.db import connection, connections
    cursor = connection.cursor()  # cursor = connections['default'].cursor()
    cursor.execute("""SELECT * from auth_user where id = %s""", [1])
    row = cursor.fetchone() # fetchall()/fetchmany(..)


def values(self, *fields):
    # 获取每行数据为字典格式

def values_list(self, *fields, **kwargs):
    # 获取每行数据为元祖

def dates(self, field_name, kind, order='ASC'):
    # 根据时间进行某一部分进行去重查找并截取指定内容
    # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
    # order只能是："ASC"  "DESC"
    # 并获取转换后的时间
        - year : 年-01-01
        - month: 年-月-01
        - day  : 年-月-日

    models.DatePlus.objects.dates('ctime','day','DESC')

def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
    # 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间
    # kind只能是 "year", "month", "day", "hour", "minute", "second"
    # order只能是："ASC"  "DESC"
    # tzinfo时区对象
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))

    """
    pip3 install pytz
    import pytz
    pytz.all_timezones
    pytz.timezone(‘Asia/Shanghai’)
    """

def none(self):
    # 空QuerySet对象


####################################
# METHODS THAT DO DATABASE QUERIES #
####################################

def aggregate(self, *args, **kwargs):
   # 聚合函数，获取字典类型聚合结果
   from django.db.models import Count, Avg, Max, Min, Sum
   result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
   ===> {'k': 3, 'n': 4}

def count(self):
   # 获取个数

def get(self, *args, **kwargs):
   # 获取单个对象

def create(self, **kwargs):
   # 创建对象

def bulk_create(self, objs, batch_size=None):
    # 批量插入
    # batch_size表示一次插入的个数
    objs = [
        models.DDD(name='r11'),
        models.DDD(name='r22')
    ]
    models.DDD.objects.bulk_create(objs, 10)

def get_or_create(self, defaults=None, **kwargs):
    # 如果存在，则获取，否则，创建
    # defaults 指定创建时，其他字段的值
    obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2})

def update_or_create(self, defaults=None, **kwargs):
    # 如果存在，则更新，否则，创建
    # defaults 指定创建时或更新时的其他字段
    obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1})

def first(self):
   # 获取第一个

def last(self):
   # 获取最后一个

def in_bulk(self, id_list=None):
   # 根据主键ID进行查找
   id_list = [11,21,31]
   models.DDD.objects.in_bulk(id_list)

def delete(self):
   # 删除

def update(self, **kwargs):
    # 更新

def exists(self):
   # 是否有结果

QuerySet方法大全

注意的两个优化查询方法:

select_related()        # 把所有的外键都列出来, 仅限于一对一和多对一的时候进行优化(原理:SQL的join连表)
prefetch_related()    # 多对多和一对多的时候,进行优化   (原理: 用python代码把结果连起来)

注意的一个批量创建方法

bulk_create(obj_list, 10)    # obj_list --> 对象列表 ; 10 --> 10个对象save一下

例子

books_list = [models.Book(title='沙河异闻录{}'.format(i)) for i in range(1, 100)]
models.Book.objects.bulk_create(books_list, 10) 

表单查询之双下划线

    __gt=                # 大于
    __lt=                # 小于

    __gte=                # 大于等于
    __lte=                # 小于等于

    __in=                # 在[a,b,c,d]里面的
    __range=             # 在[a,b]之间的 (包含a b)    

    __contains=            # 包含
    __icontains=           # 包含            (忽略大小写)
    
    __startswith=          # 以...开头
    __istartswith=         # 以...开头        (忽略大小写)
    __endswith=            # 以...结尾
    __iendswith=           # 以...结尾        (忽略大小写)
    
    __year=                # date类型字段的年份是
    __month=               # date类型字段的月份是
    __day=                 # date类型字段的日份是

#!./usr/bin/env python
# -*- coding: utf-8 -*-
# Date: 2018/10/1

import os

if __name__ == "__main__":
    # 加载Django项目的配置信息
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ormday69.settings")
    # 导入Django, 并启动
    import django
    django.setup()

    from app01 import models
    
    ret = models.Person.objects.filter(id__gt=1, id__lt=4)      # id大于1,小于4
    print(ret)

    ret = models.Person.objects.filter(id__in=[1, 4])       # id 在[1, 4]里面的
    print(ret)

    ret = models.Person.objects.exclude(id__in=[1, 4])      # id 不在[1, 4]里面的
    print(ret)

    ret = models.Person.objects.filter(name__contains='小')  # name字段有'小'的
    print(ret)

    ret = models.Person.objects.filter(name__icontains='ven')  # name字段有'ven'的,且忽略大小写
    print(ret)

    ret = models.Person.objects.filter(id__range=[1, 4])       # id大于等于,小于1小于4
    print(ret)

    ret = models.Person.objects.filter(name__startswith='s')  # name字段以's'开头的
    print(ret)

    ret = models.Person.objects.filter(name__istartswith='s')  # name字段以's'开头的(忽略大小写)
    print(ret)

    ret = models.Person.objects.filter(name__endswith='d')  # name字段以'd'结束的
    print(ret)

    ret = models.Person.objects.filter(name__iendswith='d')  # name字段以'd'结束的(忽略大小写)
    print(ret)

    ret = models.Person.objects.filter(birthday__year=2000)  # birthday的年份是2000的
    print(ret)

    ret = models.Person.objects.filter(birthday__month=8)    # birthday的月份是8月的
    print(ret)

    ret = models.Person.objects.filter(birthday__day=15)  # birthday的天是15的
    print(ret)

    ret = models.Person.objects.filter(birthday__year=2018, birthday__month=8)  # birthday的年份是2000,且月份是8月的
    print(ret)

外键的跨表查询

数据库

from django.db import models


# Create your models here.


class Author(models.Model):
    nid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    age = models.IntegerField()

    # 与AuthorDetail建立一对一的关系
    authorDetail = models.OneToOneField(to="AuthorDetail", on_delete=models.CASCADE)


class AuthorDetail(models.Model):
    nid = models.AutoField(primary_key=True)
    birthday = models.DateField()
    telephone = models.BigIntegerField()
    addr = models.CharField(max_length=64)


class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=32)
    email = models.EmailField()


class Book(models.Model):
    nid = models.AutoField(primary_key=True)
    title = models.CharField(max_length=32)
    publishDate = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2)

    # 与Publish建立一对多的关系,外键字段建立在多的一方
    publish = models.ForeignKey(to="Publish", to_field="nid", on_delete=models.CASCADE)
    # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表
    authors = models.ManyToManyField(to='Author', )

基于对象

正向查询
　　通过【.字段】来查询
反向查询
　　通过【.表名小写_set】来查询，注意：一对一时不用加_set
　　注意： 可以指定related_name，如果指定related_name，则需以【.related_name的值】来查询

正向查询例子：

# 一对多   book --> publish
# 查询python书籍的出版社名字
python = models.Book.objects.filter(title="python").first()
print(python.publish.name)
# 多对多   book --> author
# 查询python的书籍的作者
python = models.Book.objects.filter(title="python").first()
authors = python.authors.all()
for author in authors:
    print(author.name)
# 一对一   author --> authordetail
# 查询作者是alex的地址
author = models.Author.objects.filter(name="alex").first()
print(author.authorDetail.addr)

反向查询例子

# 一对多   publish --> book
# 查询苹果出版社出版过的书籍
publish = models.Publish.objects.filter(name="苹果出版社").first()
books = publish.book_set.all()
for book in books:
    print(book.title)
# 多对多   author --> book
# 查询作者是alex出版过的书
author = models.Author.objects.filter(name="alex").first()
books = author.book_set.all()
for book in books:
    print(book.title)
# 一对一   authordetail --> author (不用加_set)
# 查询地址是山东的作者
authordetails = models.AuthorDetail.objects.filter(addr="山东")
for authordetail in authordetails:
    print(authordetail.author.name)

基于双下划线

可以在filter()里面连表　　　　　　　　    -->   不需要加""(引号)
也可以在values/values_list()里面连表　　 -->   需要加""(引号)

正向查询
　　【字段__】
反向查询
　　【表名小写__】
　　可以指定related_name，如果指定related_name，则需以【related_name的值__】来查询

整体例子

# 一对多   book --> publish
# 查询python书籍的出版社名字
print(models.Book.objects.filter(title="python").values("publish__name"))   # 正向    字段__
print(models.Publish.objects.filter(book__title="python").values("name"))   # 反向    表名小写__

# 多对多   book --> author
# 查询python的书籍的作者
print(models.Book.objects.filter(title="python").values("authors__name"))   # 正向    字段__
print(models.Author.objects.filter(book__title="python").values("name"))    # 反向    表名小写__

# 一对一   author --> authordetail
# 查询作者是alex的地址
print(models.Author.objects.filter(name="alex").values("authorDetail__addr"))   # 正向    字段__
print(models.AuthorDetail.objects.filter(author__name="alex").values("addr"))   # 反向    表名小写__

# ############### // #################
# 一对多   publish --> book
# 查询苹果出版社出版过的书籍
print(models.Publish.objects.filter(name="苹果出版社").values("book__title"))    # 正向    字段__
print(models.Book.objects.filter(publish__name="苹果出版社").values("title"))    # 反向    表名小写__

# 多对多   author --> book
# 查询作者是alex出版过的书
print(models.Author.objects.filter(name="alex").values("book__title"))      # 正向    字段__
print(models.Book.objects.filter(authors__name="alex").values("title"))     # 反向    表名小写__

# 一对一   authordetail --> author
# 查询地址是山东的作者
print(models.AuthorDetail.objects.filter(addr="山东").values("author__name"))     # 正向    字段__
print(models.Author.objects.filter(authorDetail__addr="山东").values("name"))     # 反向    表名小写__

比较难的例子

# 查询手机号以151开头的作者出版过的书籍名称以及书籍对应的出版社名称
print(models.AuthorDetail.objects.filter(telephone__startswith="151").values("author__book__title", "author__book__publish__name"))
print(models.Book.objects.filter(authors__authorDetail__telephone__startswith="151").values("title", "publish__name"))

ManyToManyField

"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。

它存在于下面两种情况：
　　外键关系的反向查询
　　多对多关联关系

简单来说就是当 【点】【后面的对象】 可能存在多个的时候就可以使用以下的方法。

方法

    1 .create()        # 创建一个新的对象
    2 .add()           # 添加对象　　　　　　　　　　需要加*打散传进去　　创建的时候用这个方法
    3 .set()           # 更新model对象的关联对象　　不用加*打散　　　　　更新的时候用这个方法
    
    4 .remove()        # 移除执行的model对象    --> 与之关联的值要允许为空
    5 .clear()        # 清空对象                --> 与之关联的值要允许为空

#!./usr/bin/env python
# -*- coding: utf-8 -*-
# Date: 2018/10/2

import os

if __name__ == "__main__":
    # 加载Django项目的配置信息
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ormday69.settings")
    # 导入Django, 并启动
    import django
    django.setup()

    from app01 import models

    author_obj = models.Author.objects.first()
    print(author_obj)
    # 查询
    ret = author_obj.books.all()
    print(ret)

    # author_obj.books.create(title="金老板自传", publisher_id=1)      # 创建一本书

    # book_obj = models.Book.objects.last()
    # print(book_obj)
    # author_obj.books.add(book_obj)                    # 单个对象
    # book_objs = models.Book.objects.filter(id__gt=9)
    # print(book_objs)
    # author_obj.books.add(*book_objs)                  # 多个对象
    # author_obj.books.add(12)                          # 通过ID添加

    # ret = author_obj.books.all()
    # print(ret)
    # books = models.Book.objects.filter(id__lt=4)
    # print(books)
    # author_obj.books.set(books)                     # 更新

    # yuan_obj = models.Author.objects.get(id=4)
    # print(yuan_obj)
    # del_book = models.Book.objects.get(id=3)            # 移除del_book这本书对象
    # yuan_obj.books.remove(del_book)
    # yuan_obj.books.remove(5)                          # 移除id为5的书

    # yuan_obj = models.Author.objects.get(id=4)
    # yuan_obj.books.clear()                            # 清空books
    # 补充(外键的反向操作)
    # publisher_obj = models.Publisher.objects.get(id=4)
    # print(publisher_obj)
    # publisher_obj.books.clear()         # 这样操作的时候,书的出版社id要允许为空

    print("新的测试".center(80, '#'))
    authors_objs = models.Book.objects.first().authors

    # 查询id1的书的作者
    book_obj = models.Book.objects.get(id=1)
    print(book_obj)
    print(book_obj.authors)

聚合和分组

--> 对queryset对象操作

导入

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

聚合(aggregate)

--> 整体　　　　　　整体指的是一整张表

根据某个字段聚合得到一条结果

models.Book.objects.all().aggregate(Avg("price"))            # 不指定名称,默认为price__avg
models.Book.objects.aggregate(average_price=Avg('price'))    # 为聚合值指定一个名称
models.Book.objects.all().aggregate(Avg("price"), Max("price"), Min("price"))    # 生成多个聚合

分组(annotate)

--> 涉及到每一个　　　　每一个指的是, 例如每一个作者,每一本书,每个出版社

示例1

# 查询每一本书的作者个数
# 先对每一本【书分组】, 再对【作者id做聚合处理】,现在ret仍然是book列表,但多了author_num字段

ret = models.Book.objects.all().annotate(author_num=Count('authors'))        # 写不写all()都可以
# print(ret.values('title', 'author_num'))
for i in ret:
    print('书:{} 个数:{}'.format(i.title, i.author_num))

# 流程分析
　　1 先从书这张表里对【书进行分组】
　　2 对【作者聚合】,根据聚合函数做相应操作

示例2

# 统计出每个出版社卖的最便宜的书的价格
# 先对【出版社分组,再对【书的价钱聚合处理】,现在ret仍然是book列表,但多了min_price字段

ret = models.Publisher.objects.annotate(min_price=Min('books__price'))
# print(ret.values('name', 'min_price'))
for i in ret:
    print('出版社:{} 价格:{}'.format(i.name, i.min_price))

示例3

--> 方法二

# 统计出每个出版社卖的最贵的书的价格
# 先在book里连表->publisher__name, 再根据publisher__name进行分组,再对price做聚合处理

ret = models.Book.objects.values('publisher__name').annotate(max_price=Max('price'))
for i in ret:
    print(i)

示例4

# 统计不止一个作者的图书 --> 先统计每本书的作者个数

ret = models.Book.objects.annotate(Count('authors')).filter(authors__count__gt=0)
print(ret.values('title', 'authors__count'))

示例5

# 查询各个作者出的书的总价格

ret = models.Author.objects.annotate(Sum('books__price'))
# print(ret.values('name', 'books__price__sum'))
for i in ret.values('name', 'books__price__sum'):
    print(i)

F查询和Q查询

导入

from django.db.models import F, Q

F查询

同一列数据的两个字段做比较
相当于SQL原生语句里的子查询

# 更新数据库字段

示例1

# 库存大于卖出数的

ret = models.Book.objects.filter(kucun__gt=F("maichu"))
print(ret)

示例2

# 刷单, 把每一本书的卖出数+1乘于3

models.Book.objects.update(maichu=((F('maichu')+1)*3))

示例3

# 所有的书加上 第一版

from django.db.models.functions import Concat
from django.db.models import Value    
models.Book.objects.update(title=Concat(F('title'), Value("第一版")))

Q查询

ORM的【或操作】

# 构造复杂条件

示例1

# 查询卖出数大于1000 或者 价格小于100的所有书

ret = models.Book.objects.filter(Q(maichu__gt=1000) | Q(price__lt=100))
print(ret)

示例2(注意)

# 在示例的基础上, 筛选出名字含有"金老板"的字段

# Q查询和字段查询同时存在时, 字段查询要放在Q查询的后面

ret = models.Book.objects.filter(Q(maichu__gt=1000) | Q(price__lt=100), title__contains='金老板')
print(ret)