您可以使用下面的QuerySetChain类。当它与Django的分页器一起使用时，它应该只对所有查询集进行COUNT（*）查询，而只对记录显示在当前页面上的查询集进行SELECT（）查询。

注意，如果使用带有泛型视图的QuerySetChain，则需要指定template_name=，即使链接的查询集都使用相同的模型。

from itertools import islice, chain

class QuerySetChain(object):
    """
    Chains multiple subquerysets (possibly of different models) and behaves as
    one queryset.  Supports minimal methods needed for use with
    django.core.paginator.
    """

    def __init__(self, *subquerysets):
        self.querysets = subquerysets

    def count(self):
        """
        Performs a .count() for all subquerysets and returns the number of
        records as an integer.
        """
        return sum(qs.count() for qs in self.querysets)

    def _clone(self):
        "Returns a clone of this queryset chain"
        return self.__class__(*self.querysets)

    def _all(self):
        "Iterates records in all subquerysets"
        return chain(*self.querysets)

    def __getitem__(self, ndx):
        """
        Retrieves an item or slice from the chained set of results from all
        subquerysets.
        """
        if type(ndx) is slice:
            return list(islice(self._all(), ndx.start, ndx.stop, ndx.step or 1))
        else:
            return islice(self._all(), ndx, ndx+1).next()

在您的示例中，用法如下：

pages = Page.objects.filter(Q(title__icontains=cleaned_search_term) |
                            Q(body__icontains=cleaned_search_term))
articles = Article.objects.filter(Q(title__icontains=cleaned_search_term) |
                                  Q(body__icontains=cleaned_search_term) |
                                  Q(tags__icontains=cleaned_search_term))
posts = Post.objects.filter(Q(title__icontains=cleaned_search_term) |
                            Q(body__icontains=cleaned_search_term) | 
                            Q(tags__icontains=cleaned_search_term))
matches = QuerySetChain(pages, articles, posts)

然后像您在示例中使用result_list一样，将匹配项与分页器一起使用。

itertools模块是在Python2.3中引入的，因此它应该可以在Django运行的所有Python版本中使用。

此递归函数将查询集数组连接成一个查询集。

def merge_query(ar):
    if len(ar) ==0:
        return [ar]
    while len(ar)>1:
        tmp=ar[0] | ar[1]
        ar[0]=tmp
        ar.pop(1)
        return ar

当前方法的一个大缺点是它对大型搜索结果集的效率低下，因为每次都必须从数据库中删除整个结果集，即使您只打算显示一页结果。

为了只从数据库中提取实际需要的对象，必须对QuerySet而不是列表使用分页。如果这样做，Django实际上会在执行查询之前对QuerySet进行切片，因此SQL查询将使用OFFSET和LIMIT来只获取实际显示的记录。但是，除非您能够以某种方式将搜索塞进一个查询中，否则无法做到这一点。

既然您的三个模型都有标题和正文字段，为什么不使用模型继承？只需让所有三个模型都继承自具有标题和正文的共同祖先，并作为对祖先模型的单个查询执行搜索。

这将在不使用任何其他库的情况下完成工作：

result_list = page_list | article_list | post_list

要求：Django==2.0.2，Django querysetsequence==0.8

如果您希望组合查询集，但仍然使用QuerySet，则可能需要检查django查询集序列。

但需要注意的是，它只需要两个查询集作为参数。但使用python-reduce，您可以始终将其应用于多个查询集。

from functools import reduce
from queryset_sequence import QuerySetSequence

combined_queryset = reduce(QuerySetSequence, list_of_queryset)

下面是我遇到的一个情况，以及我如何使用列表理解、reduce和django查询集序列

from functools import reduce
from django.shortcuts import render    
from queryset_sequence import QuerySetSequence

class People(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    mentor = models.ForeignKey('self', null=True, on_delete=models.SET_NULL, related_name='my_mentees')

class Book(models.Model):
    name = models.CharField(max_length=20)
    owner = models.ForeignKey(Student, on_delete=models.CASCADE)

# as a mentor, I want to see all the books owned by all my mentees in one view.
def mentee_books(request):
    template = "my_mentee_books.html"
    mentor = People.objects.get(user=request.user)
    my_mentees = mentor.my_mentees.all() # returns QuerySet of all my mentees
    mentee_books = reduce(QuerySetSequence, [each.book_set.all() for each in my_mentees])

    return render(request, template, {'mentee_books' : mentee_books})

最好的选择是使用Django内置方法：

# Union method
result_list = page_list.union(article_list, post_list)

这将返回这些查询集中所有对象的并集。

如果您只想获取三个查询集中的对象，您会喜欢内置的查询集方法intersection。

# intersection method
result_list = page_list.intersection(article_list, post_list)