此模块包含与搜索索引相关的类和函数。
whoosh.searching.
Searcher
(reader, weighting=<class 'whoosh.scoring.BM25F'>, closereader=True, fromindex=None, parent=None)¶包裹一个 IndexReader
对象,并提供用于搜索索引的方法。
参数: |
|
---|
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"'
参数: |
|
---|---|
返回类型: |
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")]
参数: |
|
---|---|
返回: | “term”,score)元组的列表。 |
key_terms_from_text
(fieldname, text, numterms=5, model=<class 'whoosh.classify.Bo1Model'>, normalize=True)¶从给定文本返回“numterms”最重要的术语。
参数: |
|
---|
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"])
参数: |
|
---|
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
.
参数: |
|
---|---|
返回类型: |
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
如果您要求的页码高于结果查询中的页数。
参数: |
|
---|---|
返回: |
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
对象。您需要访问收集器以获取搜索后收集器可能保存的结果对象或其他信息。
参数: |
|
---|
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))
参数: |
|
---|
up_to_date
()¶如果此搜索者代表支持版本控制的后端索引的最新版本,则返回true。
whoosh.searching.
Results
(searcher, q, top_n, docset=None, facetmaps=None, runtime=0, highlighter=None)¶此对象由搜索者返回。此对象表示搜索查询的结果。您可以把它当作字典列表来使用,其中每个字典都是文档在结果中该位置的存储字段。
请注意,结果对象保持对创建它的搜索者的引用,因此保持对结果对象的引用将保持搜索者的活动状态,并保持它使用的所有文件都处于打开状态。
参数: |
|
---|
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”术语。““最重要的”通常被定义为经常出现在热门歌曲中,但相对较少出现在整个收藏中的术语。
参数: |
|
---|---|
返回: | 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”中,否则将保持其当前相对位置。这不会将其他结果对象中的文档添加到此结果对象中。
参数: |
|
---|
upgrade_and_extend
(results)¶结合extend()和upgrade()的效果:同时在“results”中引发点击。然后,来自其他results对象的任何不在此results对象中的命中都将附加到末尾。
参数: | results -- 另一个结果对象。 |
---|
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"]
参数: |
|
---|
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
参数: |
|
---|
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"])
参数: |
|
---|
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()
参数: |
|
---|
docnum
(n)¶返回此页上第n个位置处命中的文档编号。
is_last_page
()¶如果此对象表示结果的最后一页,则返回true。
score
(n)¶返回此页第n个位置的命中得分。
whoosh.searching.
NoTermsException
¶引发异常您尝试访问 Results
对象是在没有它们的情况下创建的。要记录哪些术语与哪个文档匹配,需要调用 Searcher.search()
方法与 terms=True
.
whoosh.searching.
TimeLimit
¶由提高 TimeLimitedCollector
如果在搜索完成之前达到时间限制。如果您有对收集器的引用,则可以通过调用 TimeLimitedCollector.results()
.