sorting 模块

基类型

class whoosh.sorting.FacetType

“方面”的基类，可以排序/方面的方面。

categorizer(global_searcher)

返回A Categorizer 对应于这个方面。

参数

global_searcher -- 父搜索者。如果需要全局文档ID引用，可以使用此搜索器。

class whoosh.sorting.Categorizer

分类程序对象的基类，它根据某些条件计算文档的键值，用于排序/方面。

分类程序是由facettype对象通过 FacetType.categorizer() 方法。这个 whoosh.searching.Searcher 对象传递给 categorizer 方法可以是复合搜索器（即包装多个读取器），但始终运行分类程序。 每段, 与段相关的文档编号。

收集器将调用分类程序 set_searcher method as it searches each segment to let the cateogorizer set up whatever segment- specific data it needs.

Collector.allow_overlap 应该是 True 如果呼叫者可以使用 keys_for 方法而不是 key_for 将文档分组为可能重叠的组。默认值为 False .

如果分类程序子类只能使用文档编号对文档进行分类，则应设置 Collector.needs_current 到 False （这是默认值）并且在 key_for 或 keys_for 方法，因为在这种情况下 segment_docnum 不保证与给定的匹配者一致。如果分类程序子类需要访问匹配器上的信息，则应设置 needs_current 到 True . 这将防止调用方使用可能使匹配器处于不一致状态的优化。

key_for(matcher, segment_docnum)

返回当前匹配项的键。

参数

  • matcher -- 一 whoosh.matching.Matcher 对象。如果 self.needs_current 是 False ，不要使用此对象，因为它可能不一致。使用给定的 segment_docnum 相反。

  • segment_docnum -- 当前匹配的段相对文档编号。

key_to_name(key)

返回在方面中用作字典键的键的表示形式。例如，日期字段的排序键是一个大整数；此方法将其转换为 datetime 对象使分组更清晰。

keys_for(matcher, segment_docnum)

为当前匹配生成一系列键。

将调用此方法而不是 key_for 如果 self.allow_overlap 是 True .

参数

  • matcher -- 一 whoosh.matching.Matcher 对象。如果 self.needs_current 是 False ，不要使用此对象，因为它可能不一致。使用给定的 segment_docnum 相反。

  • segment_docnum -- 当前匹配的段相对文档编号。

set_searcher(segment_searcher, docoffset)

当收集器移动到新段时由收集器调用。这个 segment_searcher 将是原子的。这个 docoffset 是段的文档编号相对于整个索引的偏移量。您可以使用偏移量来获取绝对索引docnum，方法是将偏移量添加到段相对docnum。

刻面类型

class whoosh.sorting.FieldFacet(fieldname, reverse=False, allow_overlap=False, maptype=None)

按字段内容排序/面。

例如，要按“路径”字段的内容的相反顺序进行排序，以及按“标记”字段的内容进行方面排序：

paths = FieldFacet("path", reverse=True)
tags = FieldFacet("tag")
results = searcher.search(myquery, sortedby=paths, groupedby=tags)

此方面根据字段类型返回不同的分类程序。

参数

  • fieldname -- 要排序/创建方面的字段的名称。

  • reverse -- 如果为真，排序时，请反转此方面的排序顺序。

  • allow_overlap -- 如果为真，则分组时，允许文档在字段中有多个术语时出现在多个组中。

class whoosh.sorting.QueryFacet(querydict, other=None, allow_overlap=False, maptype=None)

基于一系列查询的结果排序/面。

参数

  • querydict -- 将键映射到的字典 whoosh.query.Query 物体。

  • other -- 用于与任何查询都不匹配的文档的键。

class whoosh.sorting.RangeFacet(fieldname, start, end, gap, hardend=False, maptype=None)

基于数字范围排序/面。对于文本范围，请使用 QueryFacet .

例如，要将“price”字段分为100美元的存储桶，最多1000美元：

prices = RangeFacet("price", 0, 1000, 100)
results = searcher.search(myquery, groupedby=prices)

范围/桶总是 inclusive 在开始和 exclusive 最后。

参数

  • fieldname -- 要排序/创建方面的数字字段。

  • start -- 整个范围的开始。

  • end -- 整个范围的结尾。

  • gap -- 范围内每个“桶”的大小。这可以是一系列尺寸。例如， gap=[1,5,10] 将使用1作为第一个桶的大小，5作为第二个桶的大小，10作为所有后续桶的大小。

  • hardend -- 如果为真，则最后一个桶的末端将被夹持为 end . 如果为false（默认值），则最后一个bucket始终为 gap 大小，即使这意味着最后一个桶的末端在后面 end .

class whoosh.sorting.DateRangeFacet(fieldname, start, end, gap, hardend=False, maptype=None)

基于日期范围排序/面。这与RangeFacet相同，只是需要使用 daterange 对象作为范围的起点和终点，以及 timedelta 或 relativedelta 对象作为间隙，并生成 DateRange 查询而不是 TermRange 查询。

例如，要将"birthday"范围划分为5年的存储桶：

from datetime import datetime
from whoosh.support.relativedelta import relativedelta

startdate = datetime(1920, 0, 0)
enddate = datetime.now()
gap = relativedelta(years=5)
bdays = DateRangeFacet("birthday", startdate, enddate, gap)
results = searcher.search(myquery, groupedby=bdays)

范围/桶总是 inclusive 在开始和 exclusive 最后。

参数

  • fieldname -- 要排序/创建方面的数字字段。

  • start -- 整个范围的开始。

  • end -- 整个范围的结尾。

  • gap -- 范围内每个“桶”的大小。这可以是一系列尺寸。例如， gap=[1,5,10] 将使用1作为第一个桶的大小，5作为第二个桶的大小，10作为所有后续桶的大小。

  • hardend -- 如果为真，则最后一个桶的末端将被夹持为 end . 如果为false（默认值），则最后一个bucket始终为 gap 大小，即使这意味着最后一个桶的末端在后面 end .

class whoosh.sorting.ScoreFacet

使用文档的分数作为排序标准。

For example, to sort by the tag 字段，然后在该字段内按相对分数：

tag_score = MultiFacet(["tag", ScoreFacet()])
results = searcher.search(myquery, sortedby=tag_score)
class whoosh.sorting.FunctionFacet(fn, maptype=None)

这个方面类型是低级的。在大多数情况下，您应该使用 TranslateFacet 相反。

这个方面类型让你传递一个任意的函数来计算键。这可能比子类化facetype和分类程序更容易设置所需的行为。

使用参数调用函数 (searcher, docid) 那里 searcher may be a composite searcher, and the docid is an absolute index document number (not segment-relative).

例如，要使用文档“内容”字段中的字数作为排序/分面键：

fn = lambda s, docid: s.doc_field_length(docid, "content")
lengths = FunctionFacet(fn)
class whoosh.sorting.MultiFacet(items=None, maptype=None)

按多个“子面”的组合对/面进行排序。

例如，按“标记”字段的值排序，然后（对于标记相同的文档）按“路径”字段的值排序：

facet = MultiFacet([FieldFacet("tag"), FieldFacet("path")])
results = searcher.search(myquery, sortedby=facet)

作为快捷方式，可以使用字符串引用字段名，它们将被假定为字段名并转换为FieldFacet对象：：

facet = MultiFacet(["tag", "path"])

您也可以使用 add_* 向多方面添加条件的方法：

facet = MultiFacet()
facet.add_field("tag")
facet.add_field("path", reverse=True)
facet.add_query({"a-m": TermRange("name", "a", "m"),
                 "n-z": TermRange("name", "n", "z")})
class whoosh.sorting.StoredFieldFacet(fieldname, allow_overlap=False, split_fn=None, maptype=None)

允许您使用非索引存储字段（例如 whoosh.fields.STORED ）这通常比使用索引字段慢。

对于存储值是以空格分隔的关键字列表的字段（例如 "tag1 tag2 tag3" ）可以使用 allow_overlap 关键字参数，以允许在调用 split() 字段值的方法（如果提供了自定义拆分函数，则调用自定义拆分函数）。

参数

  • fieldname -- 存储字段的名称。

  • allow_overlap -- 如果为真，则分组时，允许文档在字段中有多个术语时出现在多个组中。分类程序使用 string.split() 或习俗 split_fn 将存储的值转换为方面值列表。

  • split_fn -- 一个自定义函数，当 allow_overlap 是True。如果没有提供，分类程序只调用值的 split() 方法。

刻面对象

class whoosh.sorting.Facets(x=None)

将面名称映射到 FacetType 对象，用于创建多组文档。

例如，按标记分组，以及 also 按价格范围分组：

facets = Facets()
facets.add_field("tag")
facets.add_facet("price", RangeFacet("price", 0, 1000, 100))
results = searcher.search(myquery, groupedby=facets)

tag_groups = results.groups("tag")
price_groups = results.groups("price")

（要按多个方面的组合进行分组，请使用 MultiFacet ）

add_facet(name, facet)

添加一个 FacetType 给定对象下的对象 name .

add_facets(facets, replace=True)

添加给定内容 Facets 或 dict 对象。

add_field(fieldname, **kwargs)

添加一个 FieldFacet 对于给定的字段名（字段名自动用作方面名）。

add_query(name, querydict, **kwargs)

添加一个 QueryFacet 在给定条件下 name .

参数

  • name -- 方面的名称。

  • querydict -- 将键映射到的字典 whoosh.query.Query 物体。

items()

返回此对象中方面的（facetname，facetobject）元组列表。

names()

返回此对象中方面名称的迭代器。

FacetType对象

class whoosh.sorting.FacetMap

包含按方面对搜索结果分组结果的对象的基类。使用对象 as_dict() 方法访问结果。

您可以将此子类传递给 maptype 创建时的关键字参数 FacetType object to specify what information the facet should record about the group. 例如：：

# Record each document in each group in its sorted order
myfacet = FieldFacet("size", maptype=OrderedList)

# Record only the count of documents in each group
myfacet = FieldFacet("size", maptype=Count)
add(groupname, docid, sortkey)

将文档添加到方面结果。

参数

  • groupname -- 要将此文档添加到的组的名称。

  • docid -- 要添加的文档的文档编号。

  • sortkey -- 表示文档在完整结果中的排序位置的值。

as_dict()

返回将组名映射到实现特定值的字典对象。例如，该值可以是文档编号列表，也可以是表示组中文档数的整数。

class whoosh.sorting.OrderedList

存储每个组的文档编号列表，其顺序与在搜索结果中显示的顺序相同。

这个 as_dict 方法返回将组名映射到文档编号列表的字典。

class whoosh.sorting.UnorderedList

以任意顺序存储每个组的文档编号列表。这比 OrderedListResult 如果您不关心组内文档的排序。

这个 as_dict 方法返回将组名映射到文档编号列表的字典。

class whoosh.sorting.Count

存储每个组中的文档数。

这个 as_dict 方法返回将组名映射为整数的字典。

class whoosh.sorting.Best

存储每个组中的“最佳”文档（即具有最高排序键的文档）。

这个 as_dict 方法返回将组名映射到文档编号的字典。