77

假设我有一个string "Hello"和一个列表

words = ['hello', 'Hallo', 'hi', 'house', 'key', 'screen', 'hallo','question', 'Hallo', 'format']

我怎样才能找到n words最接近"Hello"并出现在列表中的那些words？

在这种情况下，我们会有['hello', 'hallo', 'Hallo', 'hi', 'format'...]

所以策略是从最近的单词到最远的单词​​对列表单词进行排序。

我想过这样的事情

word = 'Hello'
for i, item in enumerate(words):
    if lower(item) > lower(word):
      ...

但在大型列表中它非常慢。

UPDATE difflib有效，但也很慢。（words list里面有 630000 多个单词（已排序，每行一个））。因此，每次搜索最接近的单词时，检查列表需要 5 到 7 秒！

4

5 回答 5

132

使用difflib.get_close_matches.

>>> words = ['hello', 'Hallo', 'hi', 'house', 'key', 'screen', 'hallo', 'question', 'format']
>>> difflib.get_close_matches('Hello', words)
['hello', 'Hallo', 'hallo']

请查看文档，因为该函数默认返回 3 个或更少的最接近匹配项。

于 2012-04-04T20:27:09.537 回答
29

Peter Norvig 提供了一篇很棒的文章，其中包含完整的源代码（21 行），关于拼写更正。

http://norvig.com/spell-correct.html

这个想法是建立你的词的所有可能的编辑，

hello - helo   - deletes    
hello - helol  - transpose    
hello - hallo  - replaces    
hello - heallo - inserts    


def edits1(word):
   splits     = [(word[:i], word[i:]) for i in range(len(word) + 1)]
   deletes    = [a + b[1:] for a, b in splits if b]
   transposes = [a + b[1] + b[0] + b[2:] for a, b in splits if len(b)>1]
   replaces   = [a + c + b[1:] for a, b in splits for c in alphabet if b]
   inserts    = [a + c + b     for a, b in splits for c in alphabet]
   return set(deletes + transposes + replaces + inserts)

现在，在您的列表中查找这些编辑中的每一个。

彼得的文章很值得一读，值得一读。

于 2012-04-04T22:34:31.710 回答
1

创建您的单词的排序列表，并使用bisect 模块根据排序顺序识别排序列表中适合您的单词的点。根据该位置，您可以给出上方和下方的 k 个最近邻，以找到 2k 个最接近的单词。

于 2012-04-04T20:34:40.797 回答
1

我正在查看此答案以从列表或可能的替代方案中获得最接近的匹配

difflib.get_close_matches

我根据 Peter Norwig 的帖子找到了 Amjith 的答案，并认为它可能是一个很好的替代品。在我意识到它可能不太适合我的用例之前，我已经用它做了一个类。所以这是一个拼写版本，您可以将它用于不同的单词集。也许最好的用途是人口名称匹配。

import re
from collections import Counter

def words(text): return re.findall(r'\w+', text.lower())

# WORDS = Counter(words(open('big.txt').read()))


class WordMatcher:

    def __init__(self, big_text):
        self.WORDS=Counter(words(big_text))
        self.N = sum(self.WORDS.values())

    def P(self, word):
        "Probability of `word`."
        return self.WORDS[word] / self.N

    def correction(self, word):
        "Most probable spelling correction for word."
        return max(self.candidates(word), key=self.P)

    def candidates(self, word):
        "Generate possible spelling corrections for word."
        return (self.known([word]) or self.known(self.edits1(word)) or self.known(self.edits2(word)) or [word])

    def known(self, words):
        "The subset of `words` that appear in the dictionary of WORDS."
        return set(w for w in words if w in self.WORDS)

    def edits1(self, word):
        "All edits that are one edit away from `word`."
        letters    = 'abcdefghijklmnopqrstuvwxyz'
        splits     = [(word[:i], word[i:])    for i in range(len(word) + 1)]
        deletes    = [L + R[1:]               for L, R in splits if R]
        transposes = [L + R[1] + R[0] + R[2:] for L, R in splits if len(R)>1]
        replaces   = [L + c + R[1:]           for L, R in splits if R for c in letters]
        inserts    = [L + c + R               for L, R in splits for c in letters]
        return set(deletes + transposes + replaces + inserts)

    def edits2(self, word):
        "All edits that are two edits away from `word`."
        return (e2 for e1 in self.edits1(word) for e2 in self.edits1(e1))
于 2020-09-18T20:27:53.317 回答
-3

也许堆可以帮助你。

你有一个名为的堆Heap，直到它的大小小于n，你将单词插入到Heapusing 函数close中 [显示这个字符串是否比另一个字符串更接近] 。

这个方法可以在你n很小的时候帮助你:)

Heap = []
for word in words:
    if len(Heap)<n:
       Heap.insert(word)
    else
       if close(word,Heap[0]): # it means Heap[0] is the nth farthest word until now
             Heap.pop():
             Heap.insert(word)
于 2012-04-05T08:38:12.660 回答