查找
示例模型
# blog.models
from django.db import models
class Blog(models.Model):
name = models.CharField(max_length=100)
tagline = models.TextField()
def __str__(self):
return self.name
class Author(models.Model):
name = models.CharField(max_length=200)
email = models.EmailField()
def __str__(self):
return self.name
class Entry(models.Model):
blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
headline = models.CharField(max_length=255)
body_text = models.TextField()
pub_date = models.DateField()
mod_date = models.DateField()
authors = models.ManyToManyField(Author)
n_comments = models.IntegerField()
n_pingbacks = models.IntegerField()
rating = models.IntegerField()
def __str__(self):
return self.headline
字段查找Field lookups
字段查找和SQL的WHERE语句一样。你可以使用QuerySet的fiter()，exclude()和get()方法来指定关键字参数。
基本的查找关键字模板：field__lookuptype=value。
比如：
Entry.objects.filter(pub_date__lte="2018-11-18"
和下面的SQL语句一样：
SELECT * FROM blog_entry WHERE pubdate <= "2018-11-18"
在字段查找的指定字段必须是模型的字段名，但有一个例外，在ForeignKey中你可以指定字段名+_id。在这种情况下，值的参数默认是包含foreign模型的主键(默认id为主键，没有额外指定主键）。比如：
Entry.objects.filter(blog_id=4)
跨关系查找Lookups that span relationships
跨关系查找，就是使用字段（带ForeignKey的字段）的相关字段名，用双下划线来分隔，来跨关系查找。
比如查找所有的包含所有Blog对象的名字为"Beatles Blog"的Entry对象：
Entry.objects.filter(blog__name="beatles Blog")
# blog是Entry的一个字段， name是Blog的一个字段，通过blog字段来跨关系查找。
这个也能反向查找。使用模型名字的小写来翻转查找。
一个查询所有包含Entry对象的headline有“Lennon"的Blog对象：
Blog.object.filter(entry__headling__contain="lennon")
跨多关系的查找Spanning multi-valued relationships
每当你基于多对多字段ManytoManyField或者反转一个ForeignKey，你可能会对两种不同的过滤分类感兴趣。在Blog/Entry关系里（Blog和Entry是一种一对多的关系)，我们可能需要找到所有标题用"Lenon"和发布在2018的blog，或者标题用”Lenon"并且发布在2018年的blog（这尼玛有什么不同）
缓存和查询集Caching and QuerySet
每一个QuerySet包含缓存来减少数据库的访问。明白他是怎么运作的能让我们写出更有效的代码。
在最新建的QuerySet里，它的缓存是空的。当一个QuerySet第一次赋值，然后，进行一次数据库查询，Django保存查询的结果在QuerySet里面然后返回显示请求的结果。之后的QuerySet赋值再次使用缓存的结果。
要注意缓存的行为，用的不对的话，它可能会咬你。例如，下面的例子会产生两次QuerySet，对它们赋值，然后把它们扔了。
>>>print([e.headline for e in Entry.objects.all()]
>>>print([e.pubdate for e in Entry.objects.all()]
这意味这相同的数据库查询会执行两次，双倍你数据库的加载。
要避免这个问题，只要保存QuerySet然后再次使用它。
>>>queryset = Entry.objects.all()
>>>print([p.headline for p in queryset]) # 赋值queryset
>>>print([p.pubdate for p in queryset]) # 再次使用赋值的缓存
当QuerySet没有缓存
Querysets并不总是保存结果。当执行queryset的一部分的时候，会检查缓存，但是如果没有迁移(populated），之后的查询返回的结果不会缓存。特别的，这意味着使用切片限制queryset或者使用索引不会迁移缓存。
例如，在一个queryset对象重复的获取一定的索引每次都会查询数据库：
queryset = Entry.objects.all()
print(queryset[5]) # 查询数据库
print(queryset[5]) # 查询数据路
然而，如果整个queryset已经被执行，它会检查缓存：
>>>queryset = Entry.objects.all()
>>>[entry for entry in queryset] # 查询数据库
>>>print(queryset[5]) # 使用缓存
>>>print(queryset[5]) # 使用缓存
这是一些会赋值整个queryset然后迁移到缓存的操作：(弱引用?）
>>>[entry for entry in queryset]
>>>bool(queryset)
>>>entry in queryset
>>>list(queryset)
另外，打印queryset不会迁移缓存，这是因为调用repr()只会返回整个queryset的切片。
相关对象
每当你在模型里定义一种关系(ForeignKey,OneToOneField or ManyToManyField)，那个模型的实例会有一个方便的API去访问相关的对象。
比如，一个Entry对象e可以得到它关联的Blog对象通过访问它的blog属性：e.blog。
Django也为另一边关系的对象创造了API：从相关对象到模型之间的关系连接。例如，一个Blog对象b可以通过entry_set属性访问所有的相关对象Entry：b.entry_set.all().
一对多关系
向前
如果一个模型有ForeignKey，这个模型的实例可以通过简单的属性访问相关的(foreign)j对象。
>>>e = Entry.objects.get(id=2)
>>>e.blog # 返回相关的Blog对象
一对多关系的向前访问在相关对象第一次访问的时候缓存了。之后访问同一个对象实例在缓存中。
>>>e = Entry.objects.get(id=2)
>>>print(e.blog) # 访问数据库来搜索相关的Blog
>>>pirnt(e.blog) # 没有访问数据库
注意select_related()Query方法递归地提前迁移所有一对多关系缓存。
>>>e = Entry.objects.select_related().get(id=2)
>>>print(e.blog) # 没有访问数据库， 使用缓存
>>>print(e.blog) # 没有访问数据库，使用缓存
关系向后Following relationships "backward"
如果一个模型有ForeignKey，foreign-key模型的实例可以通过一个Manager来访问第一个模型的所有实例。默认情况下，这个Manager命名为FOO_set，FOO是源模型的小写名字。
>>> b = Blog.objects.get(id=1)
>>>b.entry_set.all() # 返回所有关于Blog的Entry对象
>>>b.entry_set.filter(headline__contains="Lenon")
# b.entry_set是一个返回Queryset的Manager
你可以通过在ForeignKey定义里设置related_name参数重载FOO_name名字。
使用自定义的反向管理Using a custom reverse manager
默认的用来反向关系的RelatedManager是defaultmanager的一个子类。所以你可以给给定的查询指定不同的管理器：(Pythonic)
from django.db import models
class Entry(models.Model):
objects = models.Manager() # 默认管理器
entries = EntryManager() # 自定义管理器
b = Blog.objects.get(id=1)
b.entry_set(manager="entries").all()
多对多关系Many-to-many relationships
和一对多一样，定义ManyToManyField的模型使用属性名来访问，而翻转模型使用名字小写加_set来访问。
一对一
在一对一关系里面，反转模型也可以通过Manager对象访问，不过Manager代表的是单个对象，而不是对象的集合。
class EntryDetail(models.Model):
entry = models.OneToOneField(Entry, on_delete=models.CASCADE)
details = models.TextField()
e = Entry.objects.get(id=2)
e.entrydetail # 返回EntryDetail对象
