查询-四个方法

查找是数据库操作中一个非常重要的技术。查询一般就是使用all()、filter()、exclude()以及get()四个方法来实现。

all()

filter()

get()

get返回的是一个对象，数据不存在或者有多条数据都会抛出异常

  1.     try:
  2.         message = Message.objects.get(name='yyy')
  3.     except Message.DoesNotExist as e:
  4.         print(e)
  5.     except Message.MultipleObjectsReturned as e:
  6.         print(e)

exclude()

查询-按字段查询

我们可以在调用查询方法的时候传递不同的参数来实现查询需求。

在ORM层面，这些查询条件都是使用field+__+condition的方式来使用的。以下将那些常用的查询条件来一一解释。

(1) exact

使用精确的=进行查找。如果提供的是一个None，那么在SQL层面就是被解释为NULL。示例代码如下：

  1. article = Article.objects.get(id__exact=14)
  2. article = Article.objects.get(id__exact=None)

以上的两个查找在翻译为SQL语句为如下：

  1. select ... from article where id=14;
  2. select ... from article where id IS NULL;

(2) iexact

使用like进行查找。示例代码如下：

  1. article = Article.objects.filter(title__iexact='hello world')

那么以上的查询就等价于以下的SQL语句：

  1. select ... from article where title like 'hello world';

注意上面这个sql语句，因为在MySQL中，没有一个叫做ilike的。所以exact和iexact的区别实际上就是LIKE和=的区别，在大部分collation=utf8_general_ci情况下都是一样的（collation是用来对字符串比较的）。

iexact在底层会被翻译成LIKE。

  • LIKE和=：大部分情况下都是等价的，只有少数情况下是不等价的。
  • exict和iexact：他们的区别其实就是LIKE和=的区别，因为exact会被翻译成=，而iexact会被翻译成LIKE。
  • 因为field__exact=xxx其实等价于filed=xxx，因此我们直接使用filed=xxx就可以了，并且因为大部分情况exact和iexact又是等价的，因此我们以后直接使用field=xxx就可以了。

QuerySet.query：query可以用来查看这个ORM查询语句最终被翻译成的SQL语句。但是query只能被用在QuerySet对象上，不能用在普通的ORM模型上。因此如果你的查询语句是通过get来获取数据的，那么就不能使用query，因为get返回的是满足条件的ORM模型，而不是QuerySet。如果你是通过filter等其他返回QuerySet的方法查询的，那么就可以使用query。

(3) contains

大小写敏感，判断某个字段是否包含了某个数据。示例代码如下：

  1. articles = Article.objects.filter(title__contains='hello')

在翻译成SQL语句为如下：

  1. select ... where title like BINARY '%hello%';

BINARY意味着大小写敏感！

要注意的是，在使用contains的时候，翻译成的sql语句左右两边是有百分号的，意味着使用的是模糊查询。而exact翻译成sql语句左右两边是没有百分号的，意味着使用的是精确的查询。

(4) icontains

使用大小写不敏感的判断，某个字符串是否被包含在指定的字段中。这个查询语句在被翻译成SQL的时候，使用的是like，而like在MySQL层面就是不区分大小写的。
区分
contains和icontains：在被翻译成SQL的时候使用的是%hello%，就是只要整个字符串中出现了hello都能过够被找到，而iexact没有百分号，那么意味着只有完全相等的时候才会被匹配到。

(5) in（重要！！！）

可以直接指定某个字段的是否在某个集合中。示例代码如下：

  1. # 查找id在[1,2,3]中的文章
  2. articles = Article.objects.filter(id__in=[1,2,3])

也可以通过其他的表的字段来判断是否在某个集合中。示例代码如下：

  1. # 查找id为1,2,3的文章的分类
  3. # 看准宾语是啥！宾语是分类，那就用Category.objects来查找！
  4. categories = Category.objects.filter(article__id__in=[1,2,3])

如果要判断相关联的表的字段，那么也是通过__来连接。并且在做关联查询的时候，不需要写models_set，直接使用模型的名字的小写化就可以了。比如通过分类去查找相应的文章，那么通过article__id__in就可以了，而不是写成article_set__id__in的形式。当然如果你不想使用默认的形式，可以在外键定义的时候传递related_query_name来指定反向查询的名字。示例代码如下：

  1. class Category(models.Model):
  2.     name = models.CharField(max_length=100)
  3.     class Meta:
  4.         db_table = 'category'
  7. class Article(models.Model):
  8.     title = models.CharField(max_length=200)
  9.     content = models.TextField()
  10.     cateogry = models.ForeignKey("Category",on_delete=models.CASCADE,null=True,related_query_name='articles')
  11.     class Meta:
  12.         db_table = 'article'

因为在cateogry的ForeignKey中指定了related_query_name为articles，因此你不能再使用article来进行反向查询了。这时候就需要通过articles__id__in来进行反向查询。

并且，如果在做反向查询的时候，如果查询的字段就是模型的主键，那么可以省略掉这个字段，直接写成article__in就可以了，不需要这个id了。

区分：反向引用VS反向查询

反向查询是将模型名字小写化。比如article__in。可以通过related_query_name来指定自己的方式，而不使用默认的方式。
反向引用是将模型名字小写化，然后再加上_set，比如article_set，可以通过related_name来指定自己的方式，而不是用默认的方式。

in不仅仅可以指定列表/元组，还可以为QuerySet。比如要查询“文章标题中包含有hello的所有分类”，那么可以通过以下代码来实现：

  1. articles = Article.objects.filter(title__icontains='hello')
  2. categories = Category.objects.filter(articles__in=articles)
  3. for cateogry in categories:
  4.     print(cateogry)

(6) gt、gte、lt、lte

代表的是大于、大于等于、小于、小于等于的条件。示例代码如下：

  1. articles = Article.objects.filter(id__lte=3)

(7) startswith、istartswith、endswith、iendswith

表示以某个值开始，不区分大小写的以某个值开始、以某个值结束、不区分大小写的以某个值结束。示例代码如下：

  1. articles = Article.objects.filter(title__endswith="hello")

(8) 关于时间的查询条件

【视频P68】

  • range：可以指定一个时间段。并且时间应该标记为aware时间，不然django会报警告。示例代码如下：
  1. from django.utils.timezone import make_aware
  2. from datetime import datetime
  3. start_time = make_aware(datetime(year=2018,month=4,day=4,hour=17,minute=0,second=0))
  4. end_time = make_aware(datetime(year=2018,month=4,day=4,hour=18,minute=0,second=0))
  5. articles = Article.objects.filter(create_time__range=(start_time,end_time))
  6. print(articles.query)
  7. print(articles)
  • date：

用年月日来进行过滤。如果想要使用这个过滤条件，那么前提必须要在MySQL中添加好那些时区文件。如何添加呢？如下。

注意，因为默认情况下MySQL的表中是没有存储时区相关的信息的。因此我们需要下载一些时区表的文件，然后添加到Mysql的配置路径中。如果你用的是windows操作系统。那么在http://dev.mysql.com/downloads/timezones.html下载timezone_2018d_posix.zip - POSIX standard。然后将下载下来的所有文件拷贝到C:\ProgramData\MySQL\MySQL Server 5.7\Data\mysql中，如果提示文件名重复，那么选择覆盖即可。
如果用的是linux或者mac系统，那么在命令行中执行以下命令：mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -D mysql -u root -p，然后输入密码，从系统中加载时区文件更新到mysql中。

示例代码如下：

  1. articles = Article.objects.filter(create_time__date=datetime(year=2018,month=4,day=4))
  • year/month/day：表示根据年/月/日进行查找。示例代码如下：
  1. articles = Article.objects.filter(create_time__year__gte=2018)
  • week_day：根据星期来进行查找。1表示星期天，7表示星期六，2-6代表的是星期一到星期五。比如要查找星期三的所有文章，那么可以通过以下代码来实现：
  1. articles = Article.objects.filter(create_time__week_day=4)
  • time：根据分时秒来进行查找。如果要具体到秒，一般比较难匹配到，可以使用区间的方式来进行查找。区间使用range条件。比如想要获取17时/10分/27-28秒之间的文章，那么可以通过以下代码来实现：
  1. start_time = time(hour=17,minute=10,second=27)
  2. end_time = time(hour=17,minute=10,second=28)
  3. articles = Article.objects.filter(create_time__time__range=(start_time,end_time))

(9) isnull

根据值是否为空进行查找。示例代码如下：

  1. articles = Article.objects.filter(pub_date__isnull=False)

以上的代码的意思是获取所有发布日期不为空的文章。
将来翻译成SQL语句如下：

  1. select ... where pub_date is not null;

(10) regex和iregex

大小写敏感和大小写不敏感的正则表达式。示例代码如下：

  1. articles = Article.objects.filter(title__regex=r'^hello')

以上代码的意思是提取所有标题以hello字符串开头的文章。
将翻译成以下的SQL语句：

  1. select ... where title regexp binary '^hello';

iregex是大小写不敏感的。

(11) 根据关联的表进行查询：

假如现在有两个ORM模型，一个是Article，一个是Category。代码如下：

  1. class Category(models.Model):
  2.     """文章分类表"""
  3.     name = models.CharField(max_length=100)
  5. class Article(models.Model):
  6.     """文章表"""
  7.     title = models.CharField(max_length=100,null=True)
  8.     category = models.ForeignKey("Category",on_delete=models.CASCADE)

比如想要获取文章标题中包含”hello”的所有的分类。那么可以通过以下代码来实现：

  1. categories = Category.object.filter(article__title__contains("hello"))

查询-聚合函数

如果你用原生SQL，则可以使用聚合函数来提取数据。比如提取某个商品销售的数量，那么可以使用Count，如果想要知道商品销售的平均价格，那么可以使用Avg。
聚合函数是通过aggregate方法来实现的。在讲解这些聚合函数的用法的时候，都是基于以下的模型对象来实现的。

  1. from django.db import models
  3. class Author(models.Model):
  4.     """作者模型"""
  5.     name = models.CharField(max_length=100)
  6.     age = models.IntegerField()
  7.     email = models.EmailField()
  9.     class Meta:
  10.         db_table = 'author'
  13. class Publisher(models.Model):
  14.     """出版社模型"""
  15.     name = models.CharField(max_length=300)
  17.     class Meta:
  18.      db_table = 'publisher'
  21. class Book(models.Model):
  22.     """图书模型"""
  23.     name = models.CharField(max_length=300)
  24.     pages = models.IntegerField()
  25.     price = models.FloatField()
  26.     rating = models.FloatField()
  27.     author = models.ForeignKey(Author,on_delete=models.CASCADE)
  28.     publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)
  30.     class Meta:
  31.         db_table = 'book'
  34. class BookOrder(models.Model):
  35.     """图书订单模型"""
  36.     book = models.ForeignKey("Book",on_delete=models.CASCADE)
  37.     price = models.FloatField()
  38.     create_time = models.DateTimeField(auto_now_add=True)
  40.     class Meta:
  41.         db_table = 'book_order'

Avg：求平均值

比如想要获取所有图书的价格平均值。那么可以使用以下代码实现：

  1. from django.db.models import Avg
  2. result = Book.objects.aggregate(Avg('price'))
  3. print(result)

以上的打印结果是：

  1.  {"price__avg":23.0}

其中price__avg的结构是根据field__avg规则构成的。如果想要修改默认的名字，那么可以将Avg赋值给一个关键字参数，参数的名字就是聚合函数执行完成的名字。示例代码如下：

  1. from django.db.models import Avg
  2. result = Book.objects.aggregate(my_avg=Avg('price'))
  3. print(result)

那么以上的结果打印为：

  1. {"my_avg":23}

Count：求个数

Count：用来求某个数据的个数。比如要求所有图书的数量，那么可以使用以下代码：

  1. from django.db.models import Count
  2. result = Book.objects.aggregate(book_nums=Count("id"))

并且Count可以传递distinct=True参数，用来剔除那些重复的值，只保留一个。比如要获取作者表中，不同邮箱的个数，那么这时候可以使用distinct=True。示例代码如下：

  1. from djang.db.models import Count
  2. result = Author.objects.aggregate(email_nums=Count('email',distinct=True))

现让你查询每本书的销量是多少，怎么做？

  1. from django.db import connection
  3. books = Book.objects.annotate(book_num=Count("bookorder__id"))  #查Book在BookOrder表中id的个数并按id分组
  4. books = Book.objects.annotate(book_num=Count("bookorder"))  # 因为如果要查询的字段是id的话可以省略不写，故上面等价于这个
  6. for book in books:
  7.     print("%s/%s" % (book.name, book.book_num)) 
  8. print(connection.queries)  # 来查看原生的SQL语句

Max和Min：求最值

Max和Min：求指定字段的最大值和最小值。示例代码如下：

  1. from django.db.models import Max,Min
  2. result = Author.objects.aggregate(max=Max("age"),min=Min("age"))  # 其实aggregate不论给多少值都能求出来！

如果最大的年龄是88,最小的年龄是18。那么以上的result将为：

  1. {"age__max":88,"age__min":18}

如何获取每一本图书售卖时的最大价格和最小价格？

  1. from django.db.models import Max,Min
  2. books = Book.objects.annotate(max=Max(bookorder__price), min=Min(bookorder__price))
  3. for book in books:
  4.     print("%s:%s/%s" % (book.name, book.min, book.max))
  5. print(connection.queries)

Sum：求总和

Sum：求某个字段值的总和。比如要求每种图书的销售总额。那么可以使用以下代码实现：

  1. from djang.db.models import Sum
  2. result = Book.objects.annotate(total=Sum("bookstore__price")).values("name","total")

以上的代码annotate的意思是给Book表在查询的时候为每本图书添加一个字段叫做total，这个字段的数据来源是从BookStore模型的price的总和而来。values方法是只提取name和total两个字段的值。

aggregate和annotate方法可以在任何的QuerySet对象上调用。因此只要是返回了QuerySet对象，那么就可以进行链式调用。比如要获取2018年度的销售总额，那么可以先过滤年份，再求聚合函数。示例代码如下：

  1. BookOrder.objects.filter(create_time__year=2018).aggregate(total=Sum('price'))

新题：求每一本图书在2018年度的销售总额

  1. from djang.db.models import Sum
  2. books = Book.objects.filter(bookorder__create_time__year=2018).annotate(total=Sum("bookorder__price"))
  4. for book in books:
  5.     print("%s/%s" % (book.name, book.total))

aggregate VS annotate

【P72集】

  1. aggregate：这个方法不会返回一个QuerySet对象，而是返回一个字典。这个字典中的key就是聚合函数的名字，值就是聚合函数执行后的结果。
  2. aggregate和annotate的相同和不同：
    • 相同：这两个方法都可以执行聚合函数。
    • 不同：
      • aggregate返回的是一个字典，在这个字典中存储的是这个聚合函数执行的结果。而annotate返回的是一个QuerySet对象，并且会在查找的模型上添加一个聚合函数的属性。
      • aggregate不会做分组，而annotate会使用group by子句进行分组，只有调用了group by子句，才能对每一条数据求聚合函数的值。

比如以上Sum的例子，如果使用的是annotate，那么将在每本图书的数据上都添加一个字段叫做total，计算这本书的销售总额。
而如果使用的是aggregate，那么将求所有图书的销售总额。

操作-表达式

F表达式（优化大师）

F表达式是用来优化ORM操作数据库的。比如我们要将公司所有员工的薪水都增加1000元，如果按照正常的流程，应该是先从数据库中提取所有的员工工资到Python内存中，然后使用Python代码在员工工资的基础之上增加1000元，最后再保存到数据库中。这里面涉及的流程就是，首先从数据库中提取数据到Python内存中，然后在Python内存中做完运算，之后再保存到数据库中。示例代码如下：

  1. employees = Employee.objects.all()
  2. for employee in employees:
  3.     employee.salary += 1000
  4.     employee.save()

而我们的F表达式就可以优化这个流程，他可以不需要先把数据从数据库中提取出来，计算完成后再保存回去，他可以直接在数据库层面执行SQL语句，就将员工的工资增加1000元。示例代码如下：

  1. from djang.db.models import F
  2. Employee.objects.update(salary=F("salary")+1000)

F表达式并不会马上从数据库中获取数据，而是在生成SQL语句的时候，动态地获取传给F表达式的值。

动态获取是F表达式的精髓！可以把F理解成Fetch的缩写~只是起一个标识的作用。使用F表达式可以避免查询操作，从而提高性能。

因此，F() 可以通过以下方式提供性能优势：

  • 让数据库，而不是 Python 来完成工作
  • 减少某些操作所需的查询次数

比如如果想要获取作者中，name和email相同的作者数据。如果不使用F表达式，那么需要使用以下代码来完成：

  1. authors = Author.objects.all()
  2. for author in authors:
  3.     if author.name == author.email:
  4.         print(author)

如果使用F表达式，那么一行代码就可以搞定。示例代码如下：

  1. from django.db.models import F
  2. authors = Author.objects.filter(name=F("email"))

使用 F() 避免竞争条件

F() 的另一个有用的好处是，让数据库——而不是 Python——更新一个字段的值，避免了 竞争条件。

如果两个 Python 线程执行上面第一个例子中的代码，一个线程可以在另一个线程从数据库中获取一个字段的值后，检索、递增并保存它。第二个线程保存的值将基于原始值，第一个线程的工作将丢失。

如果数据库负责更新字段，那么这个过程就比较稳健：它只会在执行 [save()](https://docs.djangoproject.com/zh-hans/3.2/ref/models/instances/#django.db.models.Model.save) 或 update() 时，根据数据库中字段的值来更新字段，而不是根据检索实例时的值来更新。

Q表达式：

如果想要实现所有价格高于100元，并且评分达到9.0以上评分的图书。那么可以通过以下代码来实现：

  1. books = Book.objects.filter(price__gte=100,rating__gte=9)

以上这个案例是一个并集查询，可以简单的通过传递多个条件进去来实现。
但是如果想要实现一些复杂的查询语句，比如要查询所有价格低于10元，或者是评分低于9分的图书。那就没有办法通过传递多个条件进去实现了。这时候就需要使用Q表达式来实现了。示例代码如下：

  1. from django.db.models import Q
  2. books = Book.objects.filter(Q(price__lte=10) | Q(rating__lte=9))

以上是进行或运算，当然还可以进行其他的运算，比如有&和~（非）等。一些用Q表达式的例子如下：

  1. from django.db.models import Q
  2. # 获取id等于3的图书
  3. books = Book.objects.filter(Q(id=3))
  4. # 获取id等于3，或者名字中包含文字"记"的图书
  5. books = Book.objects.filter(Q(id=3)|Q(name__contains("记")))
  6. # 获取价格大于100，并且书名中包含"记"的图书
  7. books = Book.objects.filter(Q(price__gte=100)&Q(name__contains("记")))
  8. # 获取书名包含“记”，但是id不等于3的图书
  9. books = Book.objects.filter(Q(name__contains='记') & ~Q(id=3))

操作-QuerySet API

我们通常做查询操作的时候，都是通过模型名字.objects的方式进行操作。其实模型名字.objects是一个django.db.models.manager.Manager对象，而Manager这个类是一个“空壳”的类，他本身是没有任何的属性和方法的。他的方法全部都是通过Python动态添加的方式，从QuerySet类中拷贝过来的。示例图如下：

QuerySet和Manager-16492581552011.png

所以我们如果想要学习ORM模型的查找操作，必须首先要学会QuerySet上的一些API的使用。前面说了，【模型.objects】这个对象是django.db.models.manager.Manager的对象，Manager源码解析：

  1. class_name = "BaseManagerFromQuerySet"
  3. class_dict = {
  4.     '_queryset_class': QuerySet
  5. }
  7. class_dict.update(cls._get_queryset_methods(QuerySet))
  9. # type动态的时候创建类
  10. # 第一个参数是用来指定创建的类的名字。创建的类名是：BaseManagerFromQuerySet
  11. # 第二个参数是用来指定这个类的父类。
  12. # 第三个参数是用来指定这个类的一些属性和方法
  13. return type(class_name,(cls,),class_dict)
  15. _get_queryset_methods：这个方法就是将QuerySet中的一些方法拷贝出来

返回新的QuerySet的方法：

在使用QuerySet进行查找操作的时候，可以提供多种操作。比如过滤完后还要根据某个字段进行排序，那么这一系列的操作我们可以通过一个非常流畅的链式调用的方式进行。比如要从文章表中获取标题为123，并且提取后要将结果根据发布的时间进行排序，那么可以使用以下方式来完成：

  1. articles = Article.objects.filter(title='123').order_by('create_time')

可以看到order_by方法是直接在filter执行后调用的。这说明filter返回的对象是一个拥有order_by方法的对象。而这个对象正是一个新的QuerySet对象。因此可以使用order_by方法。

那么以下将介绍在那些会返回新的QuerySet对象的方法。

1.filter

  1. filter：将满足条件的数据提取出来，返回一个新的QuerySet。因此，可以链式调用来完成复杂查询。具体的filter可以提供什么条件查询。请见查询操作章节。

2.exclude

  1. exclude：排除满足条件的数据，返回一个新的QuerySet。示例代码如下： 
    1. Article.objects.exclude(title__contains='hello')

    以上代码的意思是提取那些标题不包含hello的图书。

3.annotate

  1. annotate：给QuerySet中的每个对象都添加一个使用查询表达式（聚合函数、F表达式、Q表达式、Func表达式等）的新字段。示例代码如下： 
    1. articles = Article.objects.annotate(author_name=F("author__name"))

    以上代码将在每个对象中都添加一个author__name的字段，用来显示这个文章的作者的年龄。

4.order_by

  1. order_by：指定将查询的结果根据某个字段进行排序。如果要倒叙排序，那么可以在这个字段的前面加一个负号。示例代码如下： 
    1. # 根据创建的时间正序排序
    2. articles = Article.objects.order_by("create_time")
    3. # 根据创建的时间倒序排序（最新的排在最前面）
    4. articles = Article.objects.order_by("-create_time")
    5. # 根据作者的名字进行排序（根据关联表的字段排序）
    6. articles = Article.objects.order_by("author__name")
    7. # 首先根据创建的时间进行排序，如果时间相同，则根据作者的名字进行排序（多字段排序）
    8. articles = Article.objects.order_by("create_time",'author__name')

    一定要注意的一点是，多个order_by，会把前面排序的规则给打乱，而使用后面的排序方式。比如以下代码：
    他会根据作者的名字进行排序，而不是使用文章的创建时间。
    题目：根据图书的销量进行从大到小排序

5.values（获取JSON格式）

  1. values：用来指定在提取数据出来，需要提取哪些字段（指哪打哪）。默认情况下会把表中所有的字段全部都提取出来，可以使用values来进行指定，并且使用了values方法后，提取出的QuerySet中的数据类型不是模型，而是在values方法中指定的字段和值形成的字典： 
    1. articles = Article.objects.values("title",'content')
    2. for article in articles:
    3.  print(article)

    以上打印出来的article是类似于{"title":"abc","content":"xxx"}的形式。
    如果在values中没有传递任何参数，那么将会返回这个模型中所有的属性。
    如果想要提取关联表中的字段，只需像之前一样使用双下划线即可：
    打印结果如下：
    但是，author__name这个键名太丑了，我想美化一下，怎么办？试试下面这样：
    很不幸，报错了。
    正解：
    需要注意的是：自定义的键名，不能和模型上本身拥有的字段一样，比如以上的author_name如果取名为author就会报错，因为Book上本身就有一个名为author的字段。
    既然vaules都能实现关联查询了，那怎么好意思不支持一下聚合函数呢？
    有没有感觉到，有了values，是不是就可以不用annotate了呢？
    再来一个问题：如果调用values时啥都没传，那是返回整个模型呢？还是返回空字典呢？
    都不是，是返回整个模型的字典形式！

6.values_list

  1. values_list：类似于values。只不过返回的QuerySet中，存储的不是字典，而是元组。示例代码如下： 
    1. articles = Article.objects.values_list("id","title")
    2. print(articles)

    那么在打印articles后，结果为<QuerySet [(1,'abc'),(2,'xxx'),...]>等。
    如果在values_list中只有一个字段。那么你可以传递flat=True来将结果扁平化。示例代码如下：

7.all

  1. all：获取这个ORM模型的QuerySet对象。

8.select_related（优化大师）

  1. select_related：在提取某个模型的数据的同时，也提前将相关联的数据提取出来。比如提取文章数据，可以使用select_related将author信息提取出来，以后再次使用article.author的时候就不需要再次去访问数据库了。可以减少数据库查询的次数。示例代码如下： 
    1. article = Article.objects.get(pk=1)
    2. >> article.author # 重新执行一次查询语句
    3. article = Article.objects.select_related("author").get(pk=2)
    4. >> article.author # 不需要重新执行查询语句了

    看到这里，你有没有感觉怪怪的，前面的values和filter中使用关联表__属性进行关联查询它不香吗？为什么又来一个select_related？这不是多此一举吗？
    其实，只要打印一下原生的SQL语句就会发现，前面的那些都是左外连接，而这个selected_related是内连接！
    selected_related只能用在多对一或者一对一中，不能用在多对多或者一对多中。比如可以提前获取文章的作者，但是不能通过作者获取这个作者的文章，或者是通过某篇文章获取这个文章所有的标签。

9.prefetch_related（优化大师）

[P84集]

  1. prefetch_related：这个方法和select_related非常的类似，就是在访问多个表中的数据的时候，减少查询的次数。这个方法是为了解决多对一和多对多的关系的查询问题。比如要获取标题中带有hello字符串的文章以及他的所有标签，示例代码如下： 

    1. from django.db import connection
    2. articles = Article.objects.prefetch_related("tag_set").filter(title__contains='hello')
    3. print(articles.query) # 通过这条命令查看在底层的SQL语句
    4. for article in articles:
    5.  print("title:",article.title)
    6.  print(article.tag_set.all())
    8. # 通过以下代码可以看出以上代码执行的sql语句
    9. for sql in connection.queries:
    10.  print(sql)


    但是如果在使用article.tag_set的时候，如果又创建了一个新的QuerySet那么会把之前的SQL优化给破坏掉。比如以下代码：
    那如果确实是想要在查询的时候指定过滤条件该如何做呢，这时候我们可以使用django.db.models.Prefetch来实现，Prefetch这个可以提前定义好queryset。示例代码如下：
    因为使用了Prefetch，即使在查询文章的时候使用了filter，也只会发生两次查询操作。

10.defer

  1. defer：在一些表中，可能存在很多的字段，但是一些字段的数据量可能是比较庞大的，而此时你又不需要，比如我们在获取文章列表的时候，文章的内容我们是不需要的，因此这时候我们就可以使用defer来过滤掉一些字段。这个字段跟values有点类似，只不过defer返回的不是字典，而是模型。示例代码如下： 
    1. articles = list(Article.objects.defer("title"))
    2. for sql in connection.queries:
    3. print('='*30)
    4. print(sql)

    在看以上代码的sql语句，你就可以看到，查找文章的字段，除了title，其他字段都查找出来了。当然，你也可以使用article.title来获取这个文章的标题，但是会重新执行一个查询的语句。示例代码如下：
    defer虽然能过滤字段，但是有些字段是不能过滤的，比如id，即使你过滤了，也会提取出来。

11.only

  1. only：跟defer类似，只不过defer是过滤掉指定的字段，而only是只提取指定的字段。

12.get

  1. get：获取满足条件的数据。这个函数只能返回一条数据，并且如果给的条件有多条数据，那么这个方法会抛出MultipleObjectsReturned错误，如果给的条件没有任何数据，那么就会抛出DoesNotExit错误。所以这个方法在获取数据的只能，只能有且只有一条。

13.create（优雅大师）

  1. create：创建一条数据，并且保存到数据库中。这个方法相当于先用指定的模型创建一个对象，然后再调用这个对象的save方法。示例代码如下： ```python article = Article(title=’abc’) article.save()

下面这行代码相当于以上两行代码

article = Article.objects.create(title=’abc’)

  3. <a name="bb00ff5b"></a>
  4. ### 14.get_or_create（优雅大师）
  6. 14.  `get_or_create`：根据某个条件进行查找，如果找到了那么就返回这条数据，如果没有查找到，那么就创建一个。示例代码如下： 
  7. ```python
  8. obj,created= Category.objects.get_or_create(title='默认分类')


如果有标题等于默认分类的分类，那么就会查找出来，如果没有，则会创建并且存储到数据库中。
这个方法的返回值是一个元组，元组的第一个参数obj是这个对象，第二个参数created代表是否创建的。

15.bulk_create（便捷大师&性能大师）

  1. bulk_create：create一次只能创建一条数据，但bulk_create可以一次性创建多个数据。示例代码如下： 
    1. Tag.objects.bulk_create([
    2. Tag(name='111'),
    3. Tag(name='222'),
    4. ])

不管多少调数据，只执行一次SQL语句。

16.count（性能大师）

  1. count：获取提取的数据的个数。如果想要知道总共有多少条数据，那么建议使用count，而不是使用len(articles)这种。因为count在底层是使用select count(*)来实现的，这种方式比使用len函数更加的高效。

不会将数据提取到内存，只执行一条SQL语句。

17.first和last

  1. first和last：返回QuerySet中的第一条和最后一条数据。

如果QuerySet为空，这两个方法就会返回None

18.aggregate

  1. aggregate：使用聚合函数。

19.exists（性能大师）

  1. exists：判断某个条件的数据是否存在。如果要判断某个条件的元素是否存在，那么建议使用exists，这比使用count或者直接判断QuerySet更有效得多。示例代码如下： 
    1. if Article.objects.filter(title__contains='hello').exists():
    2. print(True)
    3. # 比使用count更高效：
    4. if Article.objects.filter(title__contains='hello').count() > 0:
    5. print(True)
    6. # 也比直接判断QuerySet更高效：
    7. if Article.objects.filter(title__contains='hello'):
    8. print(True)

应用场景：判断用户是否已经注册。

20.distinct

  1. distinct：去除掉那些重复的数据。这个方法如果底层数据库用的是MySQL，那么不能传递任何的参数。比如想要提取所有销售的价格超过80元的图书，并且删掉那些重复的，那么可以使用distinct来帮我们实现，示例代码如下： 
    1. books = Book.objects.filter(bookorder__price__gte=80).distinct()

    需要注意的是，如果在distinct之前使用了order_by，那么因为order_by会提取order_by中指定的字段，因此再使用distinct就会根据多个字段来进行唯一化（只要有一个字段不一样，就认为不一样！），所以就不会把那些重复的数据删掉。示例代码如下：
    那么以上代码因为使用了order_by，即使使用了distinct，也会把重复的book_id提取出来。

21.update

  1. update：执行更新操作，在SQL底层走的也是update命令。比如要将所有category为空的article的article字段都更新为默认的分类。示例代码如下： 
    1. Article.objects.filter(category__isnull=True).update(category_id=3)

    注意这个方法走的是更新的逻辑。所以更新完成后保存到数据库中不会执行save方法，因此不会更新auto_now设置的字段。

22.delete

  1. delete：删除所有满足条件的数据。删除数据的时候，要注意on_delete指定的处理方式，一定要对表的结构了如指掌，否则会因为级联操作而误删很多数据！

23.切片操作

  1. 切片操作：有时候我们查找数据，有可能只需要其中的一部分。那么这时候可以使用切片操作来帮我们完成。QuerySet使用切片操作就跟列表使用切片操作是一样的。示例代码如下： 
    1. books = Book.objects.all()[1:3]
    2. for book in books:
    3. print(book)

    切片操作并不是把所有数据从数据库中提取出来再做切片操作。而是在数据库层面使用LIMIE和OFFSET来帮我们完成。所以如果只需要取其中一部分的数据的时候，建议大家使用切片操作。
    应用场景：分页、点击加载。

什么时候Django会将QuerySet转换为SQL去执行（并发大师&性能大师）

生成一个QuerySet对象并不会马上转换为SQL语句去执行。所以你可以放心大胆的使用objects.all()，接下来用多少循环多少就是了！

比如我们获取Book表下所有的图书：

  1. books = Book.objects.all()
  2. print(connection.queries)

我们可以看到在打印connection.quries的时候打印的是一个空的列表。说明上面的QuerySet并没有真正的执行。
在以下情况下QuerySet会被转换为SQL语句执行：

  1. 迭代：在遍历QuerySet对象的时候，会首先先执行这个SQL语句，然后再把这个结果返回进行迭代。比如以下代码就会转换为SQL语句： 
    1. for book in Book.objects.all():
    2. print(book)
  1. 使用步长做切片操作：QuerySet可以类似于列表一样做切片操作。做切片操作本身不会执行SQL语句，但是如果如果在做切片操作的时候提供了步长，那么就会立马执行SQL语句。需要注意的是，做切片后不能再执行filter方法，否则会报错。
  2. 调用len函数：调用len函数用来获取QuerySet中总共有多少条数据也会执行SQL语句。
  3. 调用list函数：调用list函数用来将一个QuerySet对象转换为list对象也会立马执行SQL语句。
  4. 判断：如果对某个QuerySet进行判断，也会立马执行SQL语句。