Python：找到最接近的字符串（从列表中）到另一个字符串

Question

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

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

如何找到最接近"Hello" 并出现在列表words 中的n words？

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

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

我想过这样的事情

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

但在大型列表中非常慢。

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

Answer 1

使用difflib.get_close_matches。

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

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

Answer 2

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)

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

Peter 的文章非常值得一读。

Answer 3

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

Answer 4

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

difflib.get_close_matches

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

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))

Answer 5

也许heap 可以帮助你。

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

当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)