orm优化数据库访问：https://docs.djangoproject.com/en/1.11/topics/db/optimization/
一、QuerySet
可迭代
querysey=models.Book.objects.all() for book in querysey: print(book.title)
可切片
Book.objects.all()[:3] Book.objects.all()[3:6] # 不支持负的索引，例如Book.objects.all()[0:-1]。通常，查询集的切片返回一个新的查询集，它不会执行查询。
惰性查询
QuerySet 是懒惰的 -- 创建查询集不会带来任何数据库的访问；直到查询集需要求值时，Django 才会真正运行这个查询。
queryset = models.Book.objects.all() # not hits database print(queryset) # hits database for book in queryset: print(book.title) # Hits database
缓存机制
每个查询集都包含一个缓存来最小化对数据库的访问。理解它是如何工作的将让你编写最高效的代码。
在一个新创建的查询集中，缓存为空。首次对查询集进行求值，同时发生数据库查询，Django 将保存查询的结果到查询集的缓存中并返回明确请求的结果（例如，如果正在迭代查询集，则返回下一个结果）。接下来对该查询集的求值将重用缓存的结果。
请牢记这个缓存行为，因为对查询集使用不当的话，它会坑你的。例如，下面的语句创建两个查询集，对它们求值，然后扔掉它们：
print(book.title for book in models.Book.objects.all()) # hits database print(book.price for book in models.Book.objects.all()) # hits database
这意味着相同的数据库查询将执行两次，显然倍增了你的数据库负载。同时，还有可能两个结果列表并不包含相同的数据库记录，因为在两次请求期间有可能有 book 被添加进来或删除掉。为了避免这个问题，只需保存查询集并重新使用它：
queryset = models.Book.objects.all() print(book.title for book in queryset) print(book.price for book in queryset) # 下面也是一次数据库查询 for book in querysey: print(book.title) print(book.price)
何时查询集不会被缓存?
当只对查询集的部分进行求值时会检查缓存， 如果这个部分不在缓存中，那么接下来查询返回的记录都将不会被缓存。所以，这意味着使用切片或索引来限制查询集将不会填充缓存。
例如，重复获取查询集对象中一个特定的索引将每次都查询数据库：
queryset = models.Book.objects.all() print(queryset[1]) # hits database print(queryset[1]) # hits database
然而，如果已经对全部查询集求值过，则将检查缓存：
queryset = models.Book.objects.all() [book for book in queryset] # hits database print(queryset[1]) # use cache print(queryset[1]) # use cache
简单地打印查询集不会填充缓存：
queryset = models.Book.objects.all() print(queryset) # hits database print(queryset) # hits database
exists() 和 iterator()
简单的使用 if 语句进行判断也会完全执行整个 queryset 并且把数据放入cache，虽然你并不需要这些数据！为了避免这个，可以用 exists() 方法来检查是否有数据：
queryset = models.Author.objects.all() if queryset.exists(): print("True")
更优于：
queryset = models.Author.objects.all() if queryset: print("True")
它们的sql查询分别为：
SELECT (1) AS "a" FROM "app01_author" LIMIT 1; args=() SELECT "app01_author"."id", "app01_author"."name", "app01_author"."age", "app01_author"."author_detail_id" FROM "app01_author"; args=()
当queryset非常巨大时，cache会成为问题。
处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统进程，让程序濒临崩溃。要避免在遍历数据的同时产生 queryset cache，可以使用 iterator() 方法来获取数据，处理完数据就将其丢弃。
# iterator() 可以一次只从数据库获取少量数据，这样可以节省内存 objs = models.Book.objects.all().iterator() for obj in objs: print(obj.title) # 注意，再次遍历没有打印，因为迭代器已经在上一次遍历（next）到最后一次了，没得遍历了 for obj in objs: print(obj.title)
当然，使用 iterator() 方法来防止生成cache，意味着遍历同一个 queryset 时会重复执行查询。所以使用 iterator() 的时候要当心，确保你的代码在操作一个大的 queryset 时没有重复执行查询。
总结
queryset 的 cache 是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。 使用 exists() 和 iterator() 方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能会造成额外的数据库查询。
二、查询优化
from django.db import models from django.contrib.auth.models import AbstractUser class UserInfo(AbstractUser): """ 用户信息 """ nid = models.AutoField(primary_key=True) telephone = models.CharField(verbose_name="联系电话", max_length=11, null=True, unique=True) avatar = models.FileField(verbose_name="头像", upload_to="avatars/", default="/avatars/default.png") create_time = models.DateTimeField(verbose_name="创建时间", auto_now_add=True) blog = models.OneToOneField(verbose_name="个人站点", to="Blog", to_field="nid", null=True) def __str__(self): return self.username class Blog(models.Model): """ 博客信息 """ nid = models.AutoField(primary_key=True) title = models.CharField(verbose_name="个人博客标题", max_length=64) site = models.CharField(verbose_name="个人博客后缀", max_length=32, unique=True) theme = models.CharField(verbose_name="博客主题", max_length=32) def __str__(self): return self.title class Category(models.Model): """ 个人文章分类表 """ nid = models.AutoField(primary_key=True) title = models.CharField(verbose_name="分类标题", max_length=32) blog = models.ForeignKey(verbose_name="所属博客", to="Blog", to_field="nid") # 一个博客站点可以有多个分类 def __str__(self): return self.title class Tag(models.Model): """ 标签表 """ nid = models.AutoField(primary_key=True) title = models.CharField(verbose_name="标签名称", max_length=32) blog = models.ForeignKey(verbose_name="所属博客", to="Blog", to_field="nid") # 一个博客站点可以有多个标签 def __str__(self): return self.title class Article(models.Model): """ 文章表 """ nid = models.AutoField(primary_key=True) title = models.CharField(max_length=50, verbose_name="文章标题") description = models.CharField(max_length=255, verbose_name="文章描述") create_time = models.DateTimeField(verbose_name="创建时间", auto_now_add=True) comment_count = models.IntegerField(verbose_name="评论数", default=0) up_count = models.IntegerField(verbose_name="点赞数", default=0) down_count = models.IntegerField(verbose_name="反对数", default=0) category = models.ForeignKey(verbose_name="所属分类", to="Category", to_field="nid", null=True) user = models.ForeignKey(verbose_name="作者", to="UserInfo", to_field="nid") tags = models.ManyToManyField( verbose_name="所属标签", to="Tag", through="ArticleToTag", through_fields=("article", "tag"), ) def __str__(self): return self.title class ArticleDetail(models.Model): """ 文章详细表 """ nid = models.AutoField(primary_key=True) content = models.TextField(verbose_name="文章内容") article = models.OneToOneField(verbose_name="关联文章", to="Article", to_field="nid") class ArticleToTag(models.Model): """ 文章和标签的多对多关系表 """ nid = models.AutoField(primary_key=True) article = models.ForeignKey(verbose_name="文章", to="Article", to_field="nid") tag = models.ForeignKey(verbose_name="标签", to="Tag", to_field="nid") class Meta: unique_together = [ ("article", "tag"), ] def __str__(self): v = self.article.title + "--" + self.tag.title return v class ArticleUpDown(models.Model): """ 点赞表 哪个用户对哪篇文章点了赞 """ nid = models.AutoField(primary_key=True) user = models.ForeignKey(verbose_name="用户id", to="UserInfo", null=True) article = models.ForeignKey(verbose_name="文章id", to="Article", null=True) is_up = models.BooleanField(verbose_name="是否为赞", default=True) class Meta: unique_together = [ ("article", "user"), ] class Comment(models.Model): """ 评论表 """ nid = models.AutoField(primary_key=True) user = models.ForeignKey(verbose_name="评论者", to="UserInfo", to_field="nid") article = models.ForeignKey(verbose_name="评论文章", to="Article", to_field="nid") create_time = models.DateTimeField(verbose_name="创建时间", auto_now_add=True) content = models.CharField(verbose_name="评论内容", max_length=255) parent_comment = models.ForeignKey("self", null=True) def __str__(self): return self.content
select_related
简单实用
对于一对一字段和外键字段，可以使用 select_related 来对 QuerySet 进行优化。
select_related 返回一个 QuerySet，当执行它的查询时它沿着外键关系查询关联的对象的数据。它会生成一个复杂的查询并引起性能的损耗，但是在以后使用外键关系时将不需要数据库查询。
简单说，在对 QuerySet 使用 select_related() 函数后，Django会获取相应外键对应的对象，从而在之后需要的时候不必再查询数据库了。
示例：
# 查询 id=1 的文章的分类名称，下面是一个标准的查询： article = models.Article.objects.get(nid=1) # hits database print(article.category.title) # hits database again to get the related Category object
SELECT `blog_article`.`nid`, `blog_article`.`title`, `blog_article`.`description`, `blog_article`.`create_time`, `blog_article`.`comment_count`, `blog_article`.`up_count`, `blog_article`.`down_count`, `blog_article`.`category_id`, `blog_article`.`user_id` FROM `blog_article` WHERE `blog_article`.`nid` = 1; args=(1,) SELECT `blog_category`.`nid`, `blog_category`.`title`, `blog_category`.`blog_id` FROM `blog_category` WHERE `blog_category`.`nid` = 1; args=(1,)
如果使用 select_related() 函数：
article = models.Article.objects.select_related("category").get(nid=1) print(article.category.title)
SELECT `blog_article`.`nid`, `blog_article`.`title`, `blog_article`.`description`, `blog_article`.`create_time`, `blog_article`.`comment_count`, `blog_article`.`up_count`, `blog_article`.`down_count`, `blog_article`.`category_id`, `blog_article`.`user_id`, `blog_category`.`nid`, `blog_category`.`title`, `blog_category`.`blog_id` FROM `blog_article` LEFT OUTER JOIN `blog_category` ON (`blog_article`.`category_id` = `blog_category`.`nid`) WHERE `blog_article`.`nid` = 1; args=(1,)
多个外键查询
这是针对 category 的外键查询，如果是另外一个外键呢？让我们一起看下：
article = models.Article.objects.select_related("category").get(nid=1) print(article.articledetail)
观察 logging 发现依然需要查询两次，所以需要改为：
article = models.Article.objects.select_related("category", "articledetail").get(nid=1) print(article.articledetail)
或者：
# 链式操作 article = models.Article.objects.select_related("category").select_related("articledetail").get(nid=1) print(article.articledetail)
SELECT `blog_article`.`nid`, `blog_article`.`title`, `blog_article`.`description`, `blog_article`.`create_time`, ` blog_article`.`comment_count`, `blog_article`.`up_count`, `blog_article`.`down_count`, `blog_article`.`category_id`, `blog_article`.`user_id`, `blog_category`.`nid`, `blog_category`.`title`, `blog_category`.`blog_id`, `blog_articledetail`.`nid`, `blog_articledetail`.`content`, `blog_articledetail`.`article_id` FROM `blog_article` LEFT OUTER JOIN `blog_category` ON (`blog_article`.`category_id` = `blog_category`.`nid`) LEFT OUTER JOIN `blog_articledetail` ON (`blog_article`.`nid` = `blog_articledetail`.`article_id`) WHERE `blog_article`.`nid` = 1; args=(1,)
深层查询
# 查询 id=1 的文章的博客名称 article = models.Article.objects.select_related("user").get(nid=1) print(article.user.blog.title)
依然需要查询两次；
这是因为第一次查询没有 query 到 blog 表，所以，修改如下：
article = models.Article.objects.select_related("user__blog").get(nid=1) print(article.user.blog.title)
总结
1、select_related主要针一对一和多对一关系进行优化。
2、select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
3、可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线"__"连接字段名来实现指定的递归查询。
4、没有指定的字段不会缓存，没有指定的深度不会缓存，如果要访问的话Django会再次进行SQL查询。
5、也可以通过depth参数指定递归的深度，Django会自动缓存指定深度内所有的字段。如果要访问指定深度外的字段，Django会再次进行SQL查询。
6、也接受无参数的调用，Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪费。
7、Django >= 1.7，链式调用的select_related相当于使用可变长参数。Django < 1.7，链式调用会导致前边的select_related失效，只保留最后一个。
prefetch_related()
对于多对多字段和一对多字段，可以使用 prefetch_related() 来进行优化。
prefetch_related() 和 select_related() 的设计目的很相似，都是为了减少SQL查询的数量，但是实现的方式不一样。后者是通过JOIN语句，在SQL查询内解决问题。但是对于多对多关系，使用SQL语句解决就显得有些不太明智，因为JOIN得到的表将会很长，会导致SQL语句运行时间的增加和内存占用的增加。
prefetch_related() 的解决方法是，分别查询每个表，然后用 Python 处理他们之间的关系。
# 查询所有文章关联的所有标签 queryset = models.Article.objects.all() for article in queryset: print(article.tags.all()) # 9篇文章: hits database 10
如果实用 prefetch_related() 函数：
queryset = models.Article.objects.prefetch_related("tags").all() for article in queryset: print(article.tags.all()) # 9篇文章: hits database 2
ELECT `blog_article`.`nid`, `blog_article`.`title`, `blog_article`.`description`, `blog_article`.`create_time`, `blog_article`.`comment_count`, `blog_article`.`up_count`, `blog_article`.`down_count`, `blog_article`.`category_id`, `blog_article`.`user_id` FROM `blog_article`; args=() SELECT (`blog_articletotag`.`article_id`) AS `_prefetch_related_val_article_id`, `blog_tag`.`nid`, `blog_tag`.`title`, `blog_tag`.`blog_id` FROM `blog_tag` INNER JOIN `blog_articletotag` ON (`blog_tag`.`nid` = `blog_articletotag`.`tag_id`) WHERE `blog_articletotag`.`article_id` IN (1, 2, 3, 4, 5, 6, 7, 8, 9); args=(1, 2, 3, 4, 5, 6, 7, 8, 9)
三、其他优化
不要检索你不需要的东西
使用values()或values_list()
queryset = models.Article.objects.filter(nid=1) print(queryset)
SELECT
`blog_article`.`nid`,
`blog_article`.`title`,
`blog_article`.`description`,
`blog_article`.`create_time`,
`blog_article`.`comment_count`,
`blog_article`.`up_count`,
`blog_article`.`down_count`,
`blog_article`.`category_id`,
`blog_article`.`user_id` FROM
`blog_article`
WHERE
`blog_article`.`nid` = 1 LIMIT 21; args=(1,)
queryset = models.Article.objects.filter(nid=1).values("title") print(queryset)
SELECT
`blog_article`.`title`
FROM
`blog_article`
WHERE
`blog_article`.`nid` = 1 LIMIT 21; args=(1,)
使用only()或defer()
如果存在您知道在大多数情况下不需要（或在大多数情况下不需要）的数据库列，请使用 defer() 和 only() 来避免加载它们。 请注意，如果您确实使用它们，ORM必须在单独的查询中获取它们，如果您不恰当地使用它，则会产生非常悲剧的结果。
odels.Author.objects.only("name") models.Author.objects.defer("id", "age", "author_detail") # 两条sql是一样的，如下 # SELECT "app01_author"."id", "app01_author"."name" FROM "app01_author" LIMIT 21; args=()
直接使用外键值
# 如果只需要外键值，请使用已有对象上的外键值，而不是获取整个相关对象并获取其主键。 article.user_nid 代替 article.user.nid
批量插入
创建对象时，尽可能使用 bulk_create() 来减少SQL查询的数量。例如：
Entry.objects.bulk_create([ Entry(headline='This is a test'), Entry(headline='This is only a test'), ])
更优于：
Entry.objects.create(headline='This is a test') Entry.objects.create(headline='This is only a test')
注意该方法有很多注意事项，所以得确保它适用于你的情况。
这也可以用在ManyToManyFields中，所以：
my_band.members.add(me, my_friend)
更优于：
my_band.members.add(me)
my_band.members.add(my_friend)
其中 Bands 与 Artists 具有多对多关系。
四、extra
def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) # 构造额外的查询条件或者映射，如：子查询 Tb1.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,)) Tb1.objects.extra(where=['headline=%s'], params=['Lennon']) Tb1.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) Tb1.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
有些情况下，Django的查询语法难以表达复杂的 where 子句，对于这种情况，Django 提供了 extra() QuerySet 修改机制：它能在 QuerySet 生成的SQL从句中注入新子句。
extra 可以指定一个或多个参，例如 select、where、tables；这些参数都不是必须的，但是你至少要使用一个！要注意这些额外的方式对不同的数据库引擎可能存在移植性问题。（因为你在显式的书写SQL语句）,除非万不得已，尽量避免这样做。
select 参数
select 参数可以让你在 SELECT 从句中添加其他字段信息，它应该是一个字典，存放着属性名到 SQL 从句的映射。
query_result=models.Article.objects.extra(select={'is_recent': "create_time > '2018-01-20'"})
结果集中每个 Article 对象都有一个额外的属性 is_recent，它是一个布尔值，表示 Article 对象的 create_time 是否晚于 2018-01-20。
article_obj=models.Article.objects .filter(nid=1) .extra(select={"standard_time": "strftime('%%Y-%%m-%%d', create_time)"}) .values("standard_time", "nid", "title") print(article_obj) # <QuerySet [{'title': 'Python基础', 'standard_time': '2018-01-20', 'nid': 1}]>
where / tables 参数
您可以使用 where 定义显式 SQL WHERE 子句，也许执行非显式连接。您可以使用 tables 手动将表添加到 SQL FROM 子句。
where 和 tables 都接受字符串列表。所有 where 参数均为"与"任何其他搜索条件。
示例：
query_result=models.Article.objects.extra(where=['nid in (1,3) OR title like "y%"', 'nid>2'])