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)
