Есть встроенный.

from difflib import SequenceMatcher

def similar(a, b):
    return SequenceMatcher(None, a, b).ratio()

Используй это:

>>> similar("Apple","Appel")
0.8
>>> similar("Apple","Mango")
0.0

Думаю, может быть, вы ищете алгоритм, описывающий расстояние между строками. Вот некоторые из них, на которые вы можете сослаться:

1. Расстояние Хэмминга
2. Расстояние Левенштейна
3. Расстояние Дамерау – Левенштейна
4. Расстояние Яро – Винклера

Решение # 1: встроенный Python

используйте SequenceMatcher из difflib

плюсы: собственная библиотека Python, дополнительный пакет не требуется.
минусы: слишком ограничен, существует множество других хороших алгоритмов для определения схожести строк.

>>> from difflib import SequenceMatcher
>>> s = SequenceMatcher(None, "abcd", "bcde")
>>> s.ratio()
0.75

Решение №2: библиотека jellyfish

это очень хорошая библиотека с хорошим освещением и несколькими выпусками. он поддерживает:
- Расстояние Левенштейна
- Расстояние Дамерау-Левенштейна
- Расстояние Яро
- Расстояние Яро-Винклера
- Сравнение рейтингового подхода
- Расстояние Хэмминга

плюсы: простота использования, широкий спектр поддерживаемых алгоритмов, протестировано.
минусы: не встроенная библиотека.

пример:

>>> import jellyfish
>>> jellyfish.levenshtein_distance(u'jellyfish', u'smellyfish')
2
>>> jellyfish.jaro_distance(u'jellyfish', u'smellyfish')
0.89629629629629637
>>> jellyfish.damerau_levenshtein_distance(u'jellyfish', u'jellyfihs')
1

Fuzzy Wuzzy - это пакет, который реализует расстояние Левенштейна в Python с некоторыми вспомогательными функциями, которые могут помочь в определенных ситуациях, когда вы можете хотите, чтобы две разные строки считались идентичными. Например:

>>> fuzz.ratio("fuzzy wuzzy was a bear", "wuzzy fuzzy was a bear")
    91
>>> fuzz.token_sort_ratio("fuzzy wuzzy was a bear", "wuzzy fuzzy was a bear")
    100

Вы можете создать такую ​​функцию, как:

def similar(w1, w2):
    w1 = w1 + ' ' * (len(w2) - len(w1))
    w2 = w2 + ' ' * (len(w1) - len(w2))
    return sum(1 if i == j else 0 for i, j in zip(w1, w2)) / float(len(w1))

Пакет distance включает расстояние Левенштейна:

import distance
distance.levenshtein("lenvestein", "levenshtein")
# 3

Обратите внимание: difflib.SequenceMatcher только находит самую длинную непрерывную совпадающую подпоследовательность, часто это не то, что нужно, например:

>>> a1 = "Apple"
>>> a2 = "Appel"
>>> a1 *= 50
>>> a2 *= 50
>>> SequenceMatcher(None, a1, a2).ratio()
0.012  # very low
>>> SequenceMatcher(None, a1, a2).get_matching_blocks()
[Match(a=0, b=0, size=3), Match(a=250, b=250, size=0)]  # only the first block is recorded

Обнаружение сходства между двумя строками тесно связано с концепцией попарного выравнивания последовательностей в биоинформатике. Для этого существует множество специализированных библиотек, включая biopython. В этом примере реализуется алгоритм Нидлмана Вунша:

>>> from Bio.Align import PairwiseAligner
>>> aligner = PairwiseAligner()
>>> aligner.score(a1, a2)
200.0
>>> aligner.algorithm
'Needleman-Wunsch'

Использование biopython или другого пакета биоинформатики более гибкое, чем любая часть стандартной библиотеки python, поскольку доступно множество различных схем и алгоритмов оценки. Кроме того, вы можете получить соответствующие последовательности для визуализации происходящего:

>>> alignment = next(aligner.align(a1, a2))
>>> alignment.score
200.0
>>> print(alignment)
Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-Apple-
|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-|||-|-
App-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-elApp-el

Встроенная функция SequenceMatcher очень медленная при вводе большого объема, вот как это можно сделать с помощью diff-match-patch:

from diff_match_patch import diff_match_patch

def compute_similarity_and_diff(text1, text2):
    dmp = diff_match_patch()
    dmp.Diff_Timeout = 0.0
    diff = dmp.diff_main(text1, text2, False)

    # similarity
    common_text = sum([len(txt) for op, txt in diff if op == 0])
    text_length = max(len(text1), len(text2))
    sim = common_text / text_length

    return sim, diff

Вы можете найти большинство методов схожести текста и способы их расчета по этой ссылке: https://github.com/luozhouyang/python-string-similarity#python-string-similarity Вот несколько примеров;

• Нормализованный, метрический, подобие и расстояние

• (Нормализованное) сходство и расстояние

• Метрические расстояния

• Опоясывающий лишай (н-грамм) на основе сходства и расстояния
• Левенштейн
• Нормализованный Левенштейн
• Взвешенный Левенштейн
• Дамерау-Левенштейн
• Оптимальное выравнивание струн
• Яро-Винклер
• Самая длинная общая подпоследовательность
• Метрическая самая длинная общая подпоследовательность
• N-грамм
• Алгоритмы на основе Shingle (n-грамм)
• Q-грамм
• Косинусное сходство
• Индекс Жаккара
• Коэффициент Соренсена-Дайса
• Коэффициент перекрытия (например, Шимкевича-Симпсона)

BLEUscore

BLEU, или Bilingual Evaluation Understudy, - это оценка для сравнения предполагаемого перевода текста с одним или несколькими справочными переводами.

Идеальное совпадение дает оценку 1,0, тогда как полное несоответствие дает оценку 0,0.

Хотя он разработан для перевода, его можно использовать для оценки текста, созданного для набора задач обработки естественного языка.

Код:

import nltk
from nltk.translate import bleu
from nltk.translate.bleu_score import SmoothingFunction
smoothie = SmoothingFunction().method4

C1='Text'
C2='Best'

print('BLEUscore:',bleu([C1], C2, smoothing_function=smoothie))

Примеры: путем обновления C1 и C2.

C1='Test' C2='Test'

BLEUscore: 1.0

C1='Test' C2='Best'

BLEUscore: 0.2326589746035907

C1='Test' C2='Text'

BLEUscore: 0.2866227639866161

Вы также можете сравнить схожесть предложений:

C1='It is tough.' C2='It is rough.'

BLEUscore: 0.7348889200874658

C1='It is tough.' C2='It is tough.'

BLEUscore: 1.0

Как упоминалось выше, существует множество показателей для определения сходства и расстояния между строками. Я дам свои 5 центов, показав пример Jaccard similarity с Q-Grams и пример с edit distance.

Библиотеки

from nltk.metrics.distance import jaccard_distance
from nltk.util import ngrams
from nltk.metrics.distance  import edit_distance

Сходство по Жаккару

1-jaccard_distance(set(ngrams('Apple', 2)), set(ngrams('Appel', 2)))

и получаем:

0.33333333333333337

А для Apple и Mango

1-jaccard_distance(set(ngrams('Apple', 2)), set(ngrams('Mango', 2)))

и получаем:

0.0

Изменить расстояние

edit_distance('Apple', 'Appel')

и получаем:

2

И наконец,

edit_distance('Apple', 'Mango')

и получаем:

5

Косинусное сходство на Q-граммах (q = 2)

Другое решение - работать с библиотекой textdistance. Приведу пример Cosine Similarity

import textdistance
1-textdistance.Cosine(qval=2).distance('Apple', 'Appel')

и получаем:

0.5

Расстояние по тексту:

TextDistance - библиотека Python для сравнения расстояний между двумя и более последовательностями по многим алгоритмам. У него есть Textdistance.

• 30+ алгоритмов
• Реализация на чистом питоне
• Простое использование
• Сравнение более двух последовательностей
• Некоторые алгоритмы имеют более одной реализации в одном классе.
• Дополнительное использование numpy для максимальной скорости.

Пример1:

import textdistance
textdistance.hamming('test', 'text')

Вывод:

1

Пример2:

import textdistance

textdistance.hamming.normalized_similarity('test', 'text')

Вывод:

0.75

Спасибо и ура !!!

Вот что я подумал:

import string

def match(a,b):
    a,b = a.lower(), b.lower()
    error = 0
    for i in string.ascii_lowercase:
            error += abs(a.count(i) - b.count(i))
    total = len(a) + len(b)
    return (total-error)/total

if __name__ == "__main__":
    print(match("pple inc", "Apple Inc."))