用于模糊字符串比较的好的 Python 模块？[关闭]-IT科技

摘要：问题描述：我正在寻找一个可以进行简单模糊字符串比较的 Python 模块。具体来说，我想要字符串相似度的百分比。我知道这可能是主观的，所以我希望找到一个可以进行位置比较以及最长相似字符串匹配等的库。基本上，我希望找到一个足够简单的东西来产生一个百分比，同时仍然具有足够的可配置性，以便我可以指定要进行哪种类型的...

问题描述：

我正在寻找一个可以进行简单模糊字符串比较的 Python 模块。具体来说，我想要字符串相似度的百分比。我知道这可能是主观的，所以我希望找到一个可以进行位置比较以及最长相似字符串匹配等的库。

基本上，我希望找到一个足够简单的东西来产生一个百分比，同时仍然具有足够的可配置性，以便我可以指定要进行哪种类型的比较。

解决方案 1：

difflib可以做到这一点。

来自文档的示例：

>>> get_close_matches('appel', ['ape', 'apple', 'peach', 'puppy'])
['apple', 'ape']
>>> import keyword
>>> get_close_matches('wheel', keyword.kwlist)
['while']
>>> get_close_matches('apple', keyword.kwlist)
[]
>>> get_close_matches('accept', keyword.kwlist)
['except']

看看吧。它还有其他功能可以帮助您构建自定义内容。

解决方案 2：

Levenshtein Python 扩展和 C 库。

https://github.com/ztane/python-Levenshtein/

Levenshtein Python C 扩展模块包含用于快速计算的函数 - Levenshtein（编辑）距离和编辑操作 - 字符串相似度 - 近似中值字符串，以及一般字符串平均 - 字符串序列和集合相似度它支持普通字符串和 Unicode 字符串。

$ pip install python-levenshtein
...
$ python
>>> import Levenshtein
>>> help(Levenshtein.ratio)
ratio(...)
    Compute similarity of two strings.

    ratio(string1, string2)

    The similarity is a number between 0 and 1, it's usually equal or
    somewhat higher than difflib.SequenceMatcher.ratio(), becuase it's
    based on real minimal edit distance.

    Examples:
    >>> ratio('Hello world!', 'Holly grail!')
    0.58333333333333337
    >>> ratio('Brian', 'Jesus')
    0.0

>>> help(Levenshtein.distance)
distance(...)
    Compute absolute Levenshtein distance of two strings.

    distance(string1, string2)

    Examples (it's hard to spell Levenshtein correctly):
    >>> distance('Levenshtein', 'Lenvinsten')
    4
    >>> distance('Levenshtein', 'Levensthein')
    2
    >>> distance('Levenshtein', 'Levenshten')
    1
    >>> distance('Levenshtein', 'Levenshtein')
    0

解决方案 3：

正如nosklo所说，使用Python 标准库中的 difflib模块。

difflib 模块可以使用SequenceMatcher()ratio()对象的方法返回序列相似度的度量。相似度以 0.0 到 1.0 范围内的浮点数返回。

>>> import difflib

>>> difflib.SequenceMatcher(None, 'abcde', 'abcde').ratio()
1.0

>>> difflib.SequenceMatcher(None, 'abcde', 'zbcde').ratio()
0.80000000000000004

>>> difflib.SequenceMatcher(None, 'abcde', 'zyzzy').ratio()
0.0

解决方案 4：

Jellyfish是一个 Python 模块，支持许多字符串比较指标，包括语音匹配。与 Jellyfish 的实现相比，Levenstein 编辑距离的纯 Python 实现速度相当慢。

用法示例：

import jellyfish

>>> jellyfish.levenshtein_distance('jellyfish', 'smellyfish')
2 
>>> jellyfish.jaro_distance('jellyfish', 'smellyfish')
0.89629629629629637
>>> jellyfish.damerau_levenshtein_distance('jellyfish', 'jellyfihs')
1
>>> jellyfish.metaphone('Jellyfish')
'JLFX'
>>> jellyfish.soundex('Jellyfish')
'J412'
>>> jellyfish.nysiis('Jellyfish')
'JALYF'
>>> jellyfish.match_rating_codex('Jellyfish')
'JLLFSH'`

解决方案 5：

我喜欢nosklo 的回答；另一种方法是Damerau-Levenshtein 距离：

“在信息论和计算机科学中，Damerau-Levenshtein 距离是两个字符串（即有限的符号序列）之间的‘距离’（字符串度量），通过计算将一个字符串转换为另一个字符串所需的最少操作数来给出，其中操作定义为插入、删除或替换单个字符，或两个字符的转置。”

Wikibooks中的 Python 实现：

def lev(a, b):
    if not a: return len(b)
    if not b: return len(a)
    return min(lev(a[1:], b[1:])+(a[0] != b[0]), \n    lev(a[1:], b)+1, lev(a, b[1:])+1)

更多来自 Wikibooks 的内容，这给出了最长公共子串 (LCS)的长度：

def LCSubstr_len(S, T):
    m = len(S); n = len(T)
    L = [[0] * (n+1) for i in xrange(m+1)]
    lcs = 0
    for i in xrange(m):
        for j in xrange(n):
            if S[i] == T[j]:
                L[i+1][j+1] = L[i][j] + 1
                lcs = max(lcs, L[i+1][j+1])
    return lcs

解决方案 6：

还有 Google 自己的google-diff-match-patch（“目前可用于 Java、JavaScript、C++ 和 Python”）。

（无法对此发表评论，因为我自己只使用过 python 的 difflib）

解决方案 7：

另一个选择是使用最近发布的FuzzyWuzzy软件包。此博文还介绍了该软件包支持的各种功能。

解决方案 8：

我正在使用双变音法，效果非常好。

举个例子：

>>> dm(u'aubrey')
('APR', '')
>>> dm(u'richard')
('RXRT', 'RKRT')
>>> dm(u'katherine') == dm(u'catherine')
True

更新：Jellyfish 也有这个功能。属于语音编码。

解决方案 9：

我一直在使用 Seat Geek 的 Fuzzy Wuzzy，效果非常好。

https://github.com/seatgeek/fuzzywuzzy

具体来说就是 token 集合比率函数……

他们还对模糊字符串匹配的过程进行了出色的描述：

http://seatgeek.com/blog/dev/fuzzywuzzy-fuzzy-string-matching-in-python

解决方案 10：

以下是使用 Charicar 的 simhash 实现的方法，这也适用于长文档，即使您更改文档中的单词顺序，它也会检测到 100% 的相似度

http://blog.simpliplant.eu/calculate-similarity- Between-text-strings-in-python/

解决方案 11：

下面是一个用于计算两个单词的最长公共子字符串的 Python 脚本（可能需要进行调整才能适用于多词短语）：

def lcs(word1, word2):

    w1 = set(word1[i:j] for i in range(0, len(word1))
             for j in range(1, len(word1) + 1))

    w2 = set(word2[i:j] for i in range(0, len(word2))
             for j in range(1, len(word2) + 1))

    common_subs = w1.intersection(w2)

    sorted_cmn_subs = sorted([
        (len(str), str) for str in list(common_subs)
        ])

    return sorted_cmn_subs.pop()[1]