为在数据集中查找匹配文档而编写和查询（python）

我试图构造一个名为“and_query”的函数，该函数将一个字符串作为输入，该字符串由一个或多个单词组成，这样该函数就可以为文档摘要中的单词返回匹配文档的列表

首先，我将所有单词放在一个倒排索引中，id是文档的id，摘要是纯文本

inverted_index = defaultdict(set)

for (id, abstract) in Abstracts.items():
for term in preprocess(tokenize(abstract)):
    inverted_index[term].add(id)

然后，我编写了一个查询函数，其中final是所有匹配文档的列表

因为它应该只返回函数参数的每个单词在文档中都匹配的文档，所以我使用了set操作“intersecton”

def and_query(tokens):
    documents=set()
    finals = []
    terms = preprocess(tokenize(tokens))

    for term in terms:
        for i in inverted_index[term]:
            documents.add(i)

    for term in terms:
        temporary_set= set()
        for i in inverted_index[term]:
            temporary_set.add(i)
        finals.extend(documents.intersection(temporary_set))
    return finals

def finals_print(finals):
    for final in finals:
        display_summary(final)        

finals_print(and_query("netherlands vaccine trial"))

但是，函数似乎仍然返回文档摘要中只有一个单词的文档

有人知道我在set操作方面做错了什么吗

（我认为错误应该在代码的这一部分的任何地方）：

提前谢谢

简而言之，基本上就是我想做的：

for word in words:
    id_set_for_one_word= set()
    for  i  in  get_id_of that_word[word]:
        id_set_for_one_word.add(i)
pseudo:
            id_set_for_one_word intersection (id_set_of_other_words)

finals.extend( set of all intersections for all words)

---

然后我需要所有这些单词的id集的交集，返回一个集合，其中每个单词的id都存在。

要详细说明我的代码注释，这里是我以前解决此类问题所做的工作的大致草案

def tokenize(abstract):
    #return <set of words in abstract>
    set_ = .....
    return set_

candidates = (id, abstract, tokenize(abstract)) for abstract in Abstracts.items():


all_criterias = "netherlands vaccine trial".split()


def searcher(candidates, criteria, match_on_found=True):

    search_results = []
    for cand in candidates:
        #cand[2] has a set of tokens or somesuch...  abstract.
        if criteria in cand[2]:
            if match_on_found:
                search_results.append(cand)
            else:
                #that's a AND NOT if you wanted that
                search_results.append(cand)
    return search_results


for criteria in all_criterias:
    #pass in the full list every time, but it gets progressively shrunk
    candidates = searcher(candidates, criteria)

#whats left is what you want
answer = [(abs[0],abs[1]) for abs in candidates] 

def标记化（摘要）：
#返回
集合=。。。。。
返回集_
Abstracts.items（）中的摘要的候选项=（id，abstract，tokenize（abstract））：
all_criterias=“荷兰疫苗试验”。split（）
def搜索器（候选项、标准、匹配项上的匹配项=真）：
搜索结果=[]
对于cand in候选人：
#cand[2]有一套代币或类似的东西。。。摘要
如果cand[2]中的标准：
如果找到匹配的\u，请执行以下操作：
搜索结果追加（cand）
其他：
#这是一个好主意，如果你想要的话就不需要了
搜索结果追加（cand）
返回搜索结果
对于所有标准中的标准：
#每次都传入完整列表，但它会逐渐缩小
候选人=搜索者（候选人、标准）
#剩下的就是你想要的
答案=[（abs[0]，abs[1]），适用于候选人中的abs]

问题：返回文档摘要中单词的匹配文档列表

术语

和

最小值

文档数，始终保持

结果

如果

反向索引

中不存在

项

，则不提供任何匹配项

为简单起见，预定义数据：

Abstracts = {1: 'Lorem ipsum dolor sit amet,',
             2: 'consetetur sadipscing elitr,',
             3: 'sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat,',
             4: 'sed diam voluptua.',
             5: 'At vero eos et accusam et justo duo dolores et ea rebum.',
             6: 'Stet clita kasd gubergren,',
             7: 'no sea takimata sanctus est Lorem ipsum dolor sit amet.',
            }


inverted_index = {'Stet': {6}, 'ipsum': {1, 7}, 'erat,': {3}, 'ut': {3}, 'dolores': {5}, 'gubergren,': {6}, 'kasd': {6}, 'ea': {5}, 'consetetur': {2}, 'sit': {1, 7}, 'nonumy': {3}, 'voluptua.': {4}, 'est': {7}, 'elitr,': {2}, 'At': {5}, 'rebum.': {5}, 'magna': {3}, 'sadipscing': {2}, 'diam': {3, 4}, 'dolore': {3}, 'sanctus': {7}, 'labore': {3}, 'sed': {3, 4}, 'takimata': {7}, 'Lorem': {1, 7}, 'invidunt': {3}, 'aliquyam': {3}, 'accusam': {5}, 'duo': {5}, 'amet.': {7}, 'et': {3, 5}, 'sea': {7}, 'dolor': {1, 7}, 'vero': {5}, 'no': {7}, 'eos': {5}, 'tempor': {3}, 'amet,': {1}, 'clita': {6}, 'justo': {5}, 'eirmod': {3}}

def and_query(tokens):
    print("tokens:{}".format(tokens))
    #terms = preprocess(tokenize(tokens))
    terms = tokens.split()

    term_min = None
    for term in terms:
        if term in inverted_index:
            # Find min
            if not term_min or term_min[0] > len(inverted_index[term]):
                term_min = (len(inverted_index[term]), term)
        else:
            # Break early, if a term is not in inverted_index
            return set()

    finals = inverted_index[term_min[1]]
    print("term_min:{} inverted_index:{}".format(term_min, finals))
    return finals


def finals_print(finals):
    if finals:
        for final in finals:
            print("Document [{}]:{}".format(final, Abstracts[final]))
    else:
        print("No matching Document found")

if __name__ == "__main__":
    for tokens in ['sed diam voluptua.', 'Lorem ipsum dolor', 'Lorem ipsum dolor test']:
        finals_print(and_query(tokens))
        print()

输出：

tokens:sed diam voluptua.
term_min:(1, 'voluptua.') inverted_index:{4}
Document [4]:sed diam voluptua.

tokens:Lorem ipsum dolor
term_min:(2, 'Lorem') inverted_index:{1, 7}
Document [1]:Lorem ipsum dolor sit amet,
Document [7]:no sea takimata sanctus est Lorem ipsum dolor sit amet.

tokens:Lorem ipsum dolor test
No matching Document found

---

使用Python:3.4.2进行测试

最终我自己找到了解决方案。 替换

    finals.extend(documents.intersection(id_set_for_one_word))
return finals 

与

似乎在这里工作

---

不过，谢谢大家的努力。

您能提供一些输入数据来测试代码吗？实际上不是。在实际使用数据进行查询之前，会执行许多预处理和其他操作。此外，还必须导入许多模块才能使其正常工作。这里需要做大量的工作。我用一种伪代码更新了我的问题，使我想做的更加清楚，但是如果你想“和”几个标准，只有匹配的摘要返回，那么我会1。提前准备，外面的对手。2.按顺序调用匹配器，传入摘要列表。3.删减每个简单匹配器函数中的不匹配摘要。对我来说，“扩展”是代码的味道。

    finals.extend(documents.intersection(id_set_for_one_word))
return finals 

    documents = (documents.intersection(id_set_for_one_word))
return documents