`searching` 模块¶

此模块包含与搜索索引相关的类和函数。

正在搜索类¶

class whoosh.searching.Searcher(reader, weighting=<class 'whoosh.scoring.BM25F'>, closereader=True, fromindex=None, parent=None)¶

包裹一个 IndexReader 对象，并提供用于搜索索引的方法。

参数

reader -- 安 IndexReader 要搜索的索引的对象。
weighting -- A whoosh.scoring.Weighting 用于对找到的文档进行评分的对象。
closereader -- 当搜索者关闭时，是否将关闭基础读取器。
fromindex -- 对基础读取器索引的可选引用。这是必需的 Searcher.up_to_date() 和 Searcher.refresh() 工作。

boolean_context()¶: shortcut返回一个SearchContext集，用于不计分（布尔）搜索。

collector(limit=10, sortedby=None, reverse=False, groupedby=None, collapse=None, collapse_limit=1, collapse_order=None, optimize=True, filter=None, mask=None, terms=False, maptype=None, scored=True)¶

低级方法：返回已配置的 whoosh.collectors.Collector 基于给定参数的对象。You can use this object with Searcher.search_with_collector() 搜索。

有关 Searcher.search() 用于描述参数的方法。

此方法可能有助于获取基本的收集器对象，然后用来自 whoosh.collectors 或者你自己的收藏家：

# Equivalent of
# results = mysearcher.search(myquery, limit=10)
# but with a time limt...

# Create a TopCollector
c = mysearcher.collector(limit=10)

# Wrap it with a TimeLimitedCollector with a time limit of
# 10.5 seconds
from whoosh.collectors import TimeLimitedCollector
c = TimeLimitCollector(c, 10.5)

# Search using the custom collector
results = mysearcher.search_with_collector(myquery, c)

context(**kwargs)¶: 生成一个 SearchContext 对于这个搜索者。

correct_query(q, qstring, correctors=None, terms=None, maxdist=2, prefix=0, aliases=None)¶

使用默认值返回给定用户查询的正确版本 whoosh.spelling.ReaderCorrector .

默认值：

更正索引中未出现的任何单词。
从索引中的单词中获取建议。要使某些字段使用自定义校正器，请使用 correctors 传递字典映射字段名到的参数 whoosh.spelling.Corrector 物体。

需要更复杂纠正行为的专家用户可以创建自定义 whoosh.spelling.QueryCorrector 用这个代替这个方法。

返回A whoosh.spelling.Correction 对象与A query 包含已更正的 whoosh.query.Query 对象与A string 包含已更正查询字符串的属性。

>>> from whoosh import qparser, highlight
>>> qtext = 'mary "litle lamb"'
>>> q = qparser.QueryParser("text", myindex.schema)
>>> mysearcher = myindex.searcher()
>>> correction = mysearcher().correct_query(q, qtext)
>>> correction.query
<query.And ...>
>>> correction.string
'mary "little lamb"'
>>> mysearcher.close()

你可以使用 Correction 对象的 format_string 方法使用 whoosh.highlight.Formatter 对象。例如，可以将更正后的字符串格式化为HTML，强调更改后的单词。

>>> hf = highlight.HtmlFormatter(classname="change")
>>> correction.format_string(hf)
'mary "<strong class="change term0">little</strong> lamb"'

参数

q -- 这个 whoosh.query.Query 要更正的对象。
qstring -- 从中创建查询对象的原始用户查询。可以传递none而不是字符串，其中返回的元组中的第二个项也将为none。
correctors -- 将字段名映射到的可选字典 whoosh.spelling.Corrector 物体。默认情况下，此方法使用索引的内容拼写检查查询中的术语。您可以使用此参数“重写”具有不同正确性的某些字段，例如 whoosh.spelling.GraphCorrector .
terms -- 一系列 ("fieldname", "text") 要在查询中更正的元组。默认情况下，此方法更正索引中不显示的术语。可以使用此参数重写该行为并显式指定应更正的术语。
maxdist -- 原始单词和任何建议之间允许的“编辑”的最大数目（插入、删除、替换或换位）。值高于 2 可能是缓慢的。
prefix -- 建议的替换词必须与原始词共享这个数量的初始字符。甚至增加到 1 可以大大加快建议的速度，而且可能是合理的，因为拼写错误很少涉及单词的第一个字母。
aliases -- 将查询中的字段名映射到不同字段名以用作拼写建议源的可选字典。中的映射 correctors 在此之后应用。

返回类型

whoosh.spelling.Correction

doc_count()¶: 返回索引中未删除的文档数。

doc_count_all()¶: 返回索引中已删除或未删除的文档总数。

docs_for_query(q, for_deletion=False)¶: Returns an iterator of document numbers for documents matching the given whoosh.query.Query 对象。

document(**kw)¶

便利方法返回与给定关键字参数匹配的文档的存储字段，其中关键字键是字段名，值是必须出现在字段中的术语。

此方法等效于：

searcher.stored_fields(searcher.document_number(<keyword args>))

searcher.documents（）返回生成器时，此函数返回字典或无字典。当假定给定的关键字参数与零或一个文档（即至少有一个字段是唯一键）匹配时，可以使用它。

>>> stored_fields = searcher.document(path=u"/a/b")
>>> if stored_fields:
...   print(stored_fields['title'])
... else:
...   print("There is no document with the path /a/b")

document_number(**kw)¶

返回与给定关键字参数匹配的文档的文档编号，其中关键字关键字是字段名，值是必须出现在字段中的术语。

>>> docnum = searcher.document_number(path=u"/a/b")

Where Searcher.document_numbers() returns a generator, this function returns either an int or None. Use it when you assume the given keyword arguments either match zero or one documents (i.e. at least one of the fields is a unique key).

返回类型: int

document_numbers(**kw)¶

返回与给定关键字参数匹配的文档的文档编号生成器，其中关键字关键字是字段名，值是必须出现在字段中的术语。如果不指定任何参数（ Searcher.document_numbers() ，此方法将产生 all 文件编号。

>>> docnums = list(searcher.document_numbers(emailto="matt@whoosh.ca"))

documents(**kw)¶

便利方法返回与给定关键字参数匹配的文档的存储字段，其中关键字键是字段名，值是必须出现在字段中的术语。

返回包含与关键字参数匹配的任何文档的存储字段的字典生成器。如果不指定任何参数（ Searcher.documents() ，此方法将产生 all 文件。

>>> for stored_fields in searcher.documents(emailto=u"matt@whoosh.ca"):
...   print("Email subject:", stored_fields['subject'])

get_parent()¶: 返回此搜索者的父级（如果has_parent（）为true），或者返回self。

idf(fieldname, text)¶: 计算当前术语的文档反向频率（对搜索者的加权对象调用idf（））。

key_terms(docnums, fieldname, numterms=5, model=<class 'whoosh.classify.Bo1Model'>, normalize=True)¶

从“docnums”中列出的文档（按编号）返回“numterms”最重要的术语。您可以使用document_number（）和document_numbers（）方法获取您感兴趣的文档的文档编号。

“最重要”通常被定义为经常出现在热门歌曲中，但在整个收藏中相对较少出现的术语。

>>> docnum = searcher.document_number(path=u"/a/b")
>>> keywords_and_scores = searcher.key_terms([docnum], "content")

此方法返回（“term”，score）元组的列表。如果你想知道关键术语的“强度”，分数可能会很有用，但是要想得到术语本身，你可以这样做：

>>> kws = [kw for kw, score in searcher.key_terms([docnum], "content")]

参数

fieldname -- 看看这个领域的术语。此字段必须存储向量。
docnums -- 指定从哪些文档中提取关键术语的文档编号序列。
numterms -- 返回这些重要术语。
model -- 要使用的Classify.Expansion模型。参见分类模块。
normalize -- 标准化分数。

返回

“term”，score）元组的列表。

key_terms_from_text(fieldname, text, numterms=5, model=<class 'whoosh.classify.Bo1Model'>, normalize=True)¶

从给定文本返回“numterms”最重要的术语。

参数

numterms -- 返回这些重要术语。
model -- 要使用的Classify.Expansion模型。参见分类模块。

more_like(docnum, fieldname, text=None, top=10, numterms=5, model=<class 'whoosh.classify.Bo1Model'>, normalize=False, filter=None)¶

返回A Results 基于给定字段中的“关键字”包含与给定文档类似的文档的对象：

# Get the ID for the document you're interested in
docnum = search.document_number(path=u"/a/b/c")

r = searcher.more_like(docnum)

print("Documents like", searcher.stored_fields(docnum)["title"])
for hit in r:
    print(hit["title"])

参数

fieldname -- 用于测试相似性的字段的名称。
text -- 默认情况下，该方法将尝试从文档的存储字段或术语向量加载字段的内容。如果索引中没有存储或矢量化字段，但您可以通过其他方式访问文本（例如，从文件或数据库加载），则可以使用 text 参数。
top -- 要返回的结果数。
numterms -- 要从点击和搜索中提取的“关键术语”数。使用更多的术语比较慢，但可能会产生越来越准确的结果。
model -- （专家）A whoosh.classify.ExpansionModel 用于计算“关键术语”。
normalize -- 是否规范化术语权重。
filter -- 查询、结果对象或一组docnum。结果将只包含同样在筛选对象中的文档。

postings(fieldname, text, weighting=None, qf=1)¶: 返回A whoosh.matching.Matcher 对于给定术语的过账。不像 whoosh.reading.IndexReader.postings() 方法，该方法自动从搜索者的权重对象设置匹配器上的得分函数。

reader()¶: 返回基础 IndexReader .

refresh()¶

返回索引最新版本的新搜索者：：

my_searcher = my_searcher.refresh()

如果创建此搜索者后索引没有更改，则只返回此搜索者。

此方法可能会关闭刷新的搜索者不再需要的基础资源，因此在调用后不能继续使用原始搜索者 refresh() 关于它。

search(q, **kwargs)¶

运行一个 whoosh.query.Query 对象，并返回 Results 对象。见如何搜索更多信息。

此方法采用许多关键字参数（如下所述）。

见排序和分面有关使用的信息 sortedby 和/或 groupedby . 见折叠结果有关使用的详细信息 collapse ， collapse_limit 和 collapse_order .

参数

query -- 一 whoosh.query.Query 用于匹配文档的对象。
limit -- 要评分的最大文档数。如果您只对前n个文档感兴趣，可以设置limit=n以限制更快搜索的得分。默认值为10。
scored -- 是否得分。被推翻 sortedby . 如果两者 scored=False 和 sortedby=None 结果将按任意顺序排列，但通常计算速度比计分或排序结果快。
sortedby -- 看见排序和分面 .
reverse -- 反转排序方向。默认值为假。
groupedby -- 看见排序和分面 .
optimize -- use optimizations to get faster results when possible. 默认值为true。
filter -- 查询、结果对象或一组docnum。结果将只包含同样在筛选对象中的文档。
mask -- 查询、结果对象或一组docnum。结果将不包含mask对象中的任何文档。
terms -- 如果为真，则记录在每个匹配文档中找到的术语。见如何搜索更多信息。默认值为假。
maptype -- 默认情况下，使用 groupedby 是将组名映射到组中文档编号的有序列表的字典。你可以通过 whoosh.sorting.FacetMap 此关键字参数的子类，以指定不同（通常更快）的分组方法。例如， maptype=sorting.Count 将只存储每个组中的文档数，而不是文档ID的完整列表。
collapse -- 一 facet 用于折叠结果。见折叠结果更多信息。
collapse_limit -- 使用同一折叠键允许的最大文档数。见折叠结果更多信息。
collapse_order -- 可选的排序 facet 控制折叠时保留哪些文档。缺省值（默认值） collapse_order=None ）使用结果顺序（例如得分搜索中得分最高的文档）。

返回类型

Results

search_page(query, pagenum, pagelen=10, **kwargs)¶

这种方法就像 Searcher.search() 方法，但返回 ResultsPage 对象。这是一个方便的函数，用于获取给定查询结果的特定“页面”，在Web搜索界面中通常很有用。

例如：：

querystring = request.get("q")
query = queryparser.parse("content", querystring)

pagenum = int(request.get("page", 1))
pagelen = int(request.get("perpage", 10))

results = searcher.search_page(query, pagenum, pagelen=pagelen)
print("Page %d of %d" % (results.pagenum, results.pagecount))
print("Showing results %d-%d of %d"
      % (results.offset + 1, results.offset + results.pagelen + 1,
         len(results)))
for hit in results:
    print("%d: %s" % (hit.rank + 1, hit["title"]))

（请注意，如果没有足够的结果来填充页面，results.pagelen可能小于pagelen参数。）

您提供的任何其他关键字参数都将传递给 Searcher.search() . 例如，可以获取排序搜索的分页结果：

results = searcher.search_page(q, 2, sortedby="date", reverse=True)

当前，使用pagelen为10搜索第100页所用的时间与使用 Searcher.search() 找到前1000个结果。也就是说，此方法对于从完整结果列表中间获取页面没有任何特殊的优化或效率。（未来的增强可能允许使用上一页的结果来提高查找下一页的效率。）

此方法将引发 ValueError 如果您要求的页码高于结果查询中的页数。

参数

query -- 这个 whoosh.query.Query 要匹配的对象。
pagenum -- 要检索的页码，从 1 第一页。
pagelen -- 每页的结果数。

返回

ResultsPage

search_with_collector(q, collector, context=None)¶

低级方法：运行 whoosh.query.Query 使用给定的 whoosh.collectors.Collector 要收集结果的对象：：

myquery = query.Term("content", "cabbage")

uc = collectors.UnlimitedCollector()
tc = TermsCollector(uc)

mysearcher.search_with_collector(myquery, tc)
print(tc.docterms)
print(tc.results())

请注意，此方法不返回 Results 对象。您需要访问收集器以获取搜索后收集器可能保存的结果对象或其他信息。

参数

q -- 一 whoosh.query.Query 用于匹配文档的对象。
collector -- 一 whoosh.collectors.Collector 要将结果馈送到的对象。

suggest(fieldname, text, limit=5, maxdist=2, prefix=0)¶

返回给定键入错误的单词的建议更正的排序列表 text 基于给定字段的内容：

>>> searcher.suggest("content", "specail")
["special"]

这是一种方便的方法。如果您计划在同一个字段中获得多个单词的建议，则获得 Corrector 对象并直接使用：

corrector = searcher.corrector("fieldname")
for word in words:
    print(corrector.suggest(word))

参数

limit -- 只回复这么多建议。如果字段中没有足够的术语 maxdist 对于给定的单词，返回的列表将短于此数字。
maxdist -- 从给定单词到要查看的最大编辑距离。大于2的数字不是非常有效或有效。
prefix -- require suggestions to share a prefix of this length with the given word. This is often justifiable since most misspellings do not involve the first letter of the word. Using a prefix dramatically decreases the time it takes to generate the list of words.

up_to_date()¶: 如果此搜索者代表支持版本控制的后端索引的最新版本，则返回true。

结果类¶

class whoosh.searching.Results(searcher, q, top_n, docset=None, facetmaps=None, runtime=0, highlighter=None)¶

此对象由搜索者返回。此对象表示搜索查询的结果。您可以把它当作字典列表来使用，其中每个字典都是文档在结果中该位置的存储字段。

请注意，结果对象保持对创建它的搜索者的引用，因此保持对结果对象的引用将保持搜索者的活动状态，并保持它使用的所有文件都处于打开状态。

参数

searcher -- 这个 Searcher object that produced these results.
query -- 创建这些结果的原始查询。
top_n -- 表示前n个搜索结果的（score，docnum）元组列表。

copy()¶: 返回此结果对象的深度副本。

docnum(n)¶: 返回排名文档列表中n处结果的文档编号。

docs()¶: 返回一个类似集合的对象，该对象包含与查询匹配的文档编号。

estimated_length()¶: 估计的最大匹配文档数，或者匹配文档的确切数目（如果已知）。

estimated_min_length()¶: 估计的最小匹配文档数，或者匹配文档的确切数目（如果已知）。

extend(results)¶

将“results”（不在此results对象中）的命中附加到这些结果的结尾。

参数: results -- 另一个结果对象。

facet_names()¶: 返回可用的方面名称，用于 groups() 方法。

fields(n)¶: 返回文档的存储字段 n th position in the results. 使用 Results.docnum() 如果需要原始文档编号而不是存储字段。

filter(results)¶: 删除不在其他结果对象中的任何命中。

groups(name=None)¶

如果使用 groupedby 关键字参数 search() 方法，可以使用此方法检索组。你可以使用 facet_names() 方法获取可用方面名称的列表。

>>> results = searcher.search(my_query, groupedby=["tag", "price"])
>>> results.facet_names()
["tag", "price"]
>>> results.groups("tag")
{"new": [12, 1, 4], "apple": [3, 10, 5], "search": [11]}

如果只使用一个方面，则可以调用不带方面名称的方法来获取方面的组。

>>> results = searcher.search(my_query, groupedby="tag")
>>> results.groups()
{"new": [12, 1, 4], "apple": [3, 10, 5, 0], "search": [11]}

默认情况下，这将返回将类别名称映射到文档编号列表的字典，其相对顺序与它们在结果中的显示顺序相同。

>>> results = mysearcher.search(myquery, groupedby="tag")
>>> docnums = results.groups()
>>> docnums['new']
[12, 1, 4]

然后你可以使用 Searcher.stored_fields() 获取与文档ID关联的存储字段。

如果您指定了不同的 maptype 对于搜索时的方面，字典中的值取决于 whoosh.sorting.FacetMap .

>>> myfacet = sorting.FieldFacet("tag", maptype=sorting.Count)
>>> results = mysearcher.search(myquery, groupedby=myfacet)
>>> counts = results.groups()
{"new": 3, "apple": 4, "search": 1}

has_exact_length()¶: 如果此结果对象已经知道匹配文档的确切数量，则返回true。

has_matched_terms()¶

如果搜索记录了哪些术语与哪些文档匹配，则返回true。

>>> r = searcher.search(myquery)
>>> r.has_matched_terms()
False
>>>

is_empty()¶: 如果文档与查询不匹配，则返回true。

items()¶: 返回结果中已评分文档的（docnum，score）对迭代器。

key_terms(fieldname, docs=10, numterms=5, model=<class 'whoosh.classify.Bo1Model'>, normalize=True)¶

返回这些结果中顶部“docs”文档中最重要的“numterms”术语。““最重要的”通常被定义为经常出现在热门歌曲中，但相对较少出现在整个收藏中的术语。

参数

fieldname -- 看看这个领域的术语。此字段必须存储向量。
docs -- 看看这些结果的顶级文档。
numterms -- 返回这些重要术语。
model -- 要使用的Classify.Expansion模型。参见分类模块。

返回

Unicode字符串列表。

matched_terms()¶

返回 ("fieldname", "text") 表示查询中与一个或多个前n个文档匹配的术语的元组（这不会报告与查询匹配的文档的术语，但分数不够高，无法生成前n个结果）。您可以将此集合与原始查询中的术语进行比较，以查找任何匹配文档中没有出现的术语。

只有当你使用 terms=True 在搜索调用中记录匹配的术语。否则将引发异常。

>>> q = myparser.parse("alfa OR bravo OR charlie")
>>> results = searcher.search(q, terms=True)
>>> results.terms()
set([("content", "alfa"), ("content", "charlie")])
>>> q.all_terms() - results.terms()
set([("content", "bravo")])

score(n)¶: 返回排名文档列表中第n个位置的文档得分。如果搜索没有得分，这可能不会返回任何结果。

scored_length()¶

返回结果中计分的文档数，等于或小于 limit 搜索的关键字参数。

>>> r = mysearcher.search(myquery, limit=20)
>>> len(r)
1246
>>> r.scored_length()
20

这可能少于与查询匹配的文档总数，这就是 len(Results) 返回。

upgrade(results, reverse=False)¶

对结果重新排序，使“results”中的任何点击都出现在点击之前，而不是“results”中，否则将保持其当前相对位置。这不会将其他结果对象中的文档添加到此结果对象中。

参数

results -- 另一个结果对象。
reverse -- 如果为真，则降低“其他结果”对象中的命中位置，而不是升高它们。

upgrade_and_extend(results)¶

结合extend（）和upgrade（）的效果：同时在“results”中引发点击。然后，来自其他results对象的任何不在此results对象中的命中都将附加到末尾。

参数: results -- 另一个结果对象。

class whoosh.searching.Hit(results, docnum, pos=None, score=None)¶

表示结果对象中的单个搜索结果（“命中”）。

此对象的作用类似于匹配文档存储字段的字典。如果出于某种原因你需要一个 dict 使用对象 Hit.fields() 得到一个。

>>> r = searcher.search(query.Term("content", "render"))
>>> r[0]
< Hit {title = u"Rendering the scene"} >
>>> r[0].rank
0
>>> r[0].docnum == 4592
True
>>> r[0].score
2.52045682
>>> r[0]["title"]
"Rendering the scene"
>>> r[0].keys()
["title"]

参数

results -- 此命中所属的结果对象。
pos -- 此命中结果列表中的位置，例如pos=0表示这是第一次（得分最高）命中。
docnum -- 此命中的文档编号。
score -- 这次命中的分数。

fields()¶: 返回此对象所代表文档的存储字段的字典。

highlights(fieldname, text=None, top=3, minscore=1)¶

返回给定字段中突出显示的代码段：：

r = searcher.search(myquery)
for hit in r:
    print(hit["title"])
    print(hit.highlights("content"))

见如何创建突出显示的搜索结果摘要 .

To change the fragmeter, formatter, order, or scorer used in highlighting, you can set attributes on the results object:

from whoosh import highlight

results = searcher.search(myquery, terms=True)
results.fragmenter = highlight.SentenceFragmenter()

…或使用自定义 whoosh.highlight.Highlighter 对象：

hl = highlight.Highlighter(fragmenter=sf)
results.highlighter = hl

参数

fieldname -- 要突出显示的字段的名称。
text -- 默认情况下，该方法将尝试从文档的存储字段中加载字段的内容。如果要突出显示的字段未存储在索引中，但您可以通过其他方式访问文本（例如，从文件或数据库加载），则可以使用 text 参数。
top -- 要返回的最大片段数。
minscore -- 在高光中出现的片段的最低分数。

matched_terms()¶

返回 ("fieldname", "text") 表示此文档中匹配的查询中的术语的元组。You can compare this set to the terms from the original query to find terms which didn't occur in this document.

只有当你使用 terms=True 在搜索调用中记录匹配的术语。否则将引发异常。

>>> q = myparser.parse("alfa OR bravo OR charlie")
>>> results = searcher.search(q, terms=True)
>>> for hit in results:
...   print(hit["title"])
...   print("Contains:", hit.matched_terms())
...   print("Doesn't contain:", q.all_terms() - hit.matched_terms())

more_like_this(fieldname, text=None, top=10, numterms=5, model=<class 'whoosh.classify.Bo1Model'>, normalize=True, filter=None)¶

基于给定字段中的“关键字”返回一个新的结果对象，该对象包含与此命中类似的文档：

r = searcher.search(myquery)
for hit in r:
    print(hit["title"])
    print("Top 3 similar documents:")
    for subhit in hit.more_like_this("content", top=3):
      print("  ", subhit["title"])

参数

fieldname -- 用于测试相似性的字段的名称。
text -- 默认情况下，该方法将尝试从文档的存储字段或术语向量加载字段的内容。如果索引中没有存储或矢量化字段，但您可以通过其他方式访问文本（例如，从文件或数据库加载），则可以使用 text 参数。
top -- 要返回的结果数。
numterms -- 要从点击和搜索中提取的“关键术语”数。使用更多的术语比较慢，但可能会产生越来越准确的结果。
model -- （专家）A whoosh.classify.ExpansionModel 用于计算“关键术语”。
normalize -- 是否规范化术语权重。

class whoosh.searching.ResultsPage(results, pagenum, pagelen=10)¶

表示较长结果列表中的一页，返回者为 whoosh.searching.Searcher.search_page() . 支持接口的子集 Results 对象，即使用uuGetItem_uuuu（方括号）、迭代和 score() 和 docnum() 方法。

这个 offset 属性包含此页开始的结果编号（从0开始编号）。例如，如果页面长度为10，则 offset 第二页的属性是 10 .

这个 pagecount 属性包含可用的页数。

这个 pagenum 属性包含页码。如果结果的页数太少，则这可能小于您请求的页。例如，如果您这样做：

ResultsPage(results, 5)

但是结果对象只包含3页的点击量， pagenum 将是3。

这个 pagelen 属性包含此页上的结果数（如果这是结果的最后一页，则可能小于您请求的页面长度）。

这个 total 属性包含结果中的命中总数。

>>> mysearcher = myindex.searcher()
>>> pagenum = 2
>>> page = mysearcher.find_page(pagenum, myquery)
>>> print("Page %s of %s, results %s to %s of %s" %
...       (pagenum, page.pagecount, page.offset+1,
...        page.offset+page.pagelen, page.total))
>>> for i, fields in enumerate(page):
...   print("%s. %r" % (page.offset + i + 1, fields))
>>> mysearcher.close()

设置语法高亮属性（例如 formatter ）访问底层 Results 对象：

page.results.formatter = highlight.UppercaseFormatter()

参数

results -- 一 Results 对象。
pagenum -- 要使用的结果的哪一页，编号来源 1 .
pagelen -- 每页点击数。

docnum(n)¶: 返回此页上第n个位置处命中的文档编号。

is_last_page()¶: 如果此对象表示结果的最后一页，则返回true。

score(n)¶: 返回此页第n个位置的命中得分。

例外情况¶

exception whoosh.searching.NoTermsException¶: 引发异常您尝试访问 Results 对象是在没有它们的情况下创建的。要记录哪些术语与哪个文档匹配，需要调用 Searcher.search() 方法与 terms=True .

exception whoosh.searching.TimeLimit¶: 由提高 TimeLimitedCollector 如果在搜索完成之前达到时间限制。如果您有对收集器的引用，则可以通过调用 TimeLimitedCollector.results() .

`searching` 模块¶

正在搜索类¶

结果类¶

例外情况¶

目录

上一个主题

下一个主题

searching 模块¶

正在搜索类¶

结果类¶

例外情况¶

`searching` 模块¶