Encuentra la métrica de similitud entre dos cadenas

¿Cómo obtengo la probabilidad de que una cadena sea similar a otra cadena en Python?

Quiero obtener un valor decimal como 0.9 (lo que significa 90%), etc. Preferiblemente con Python y biblioteca estándar.

p.ej

similar("Apple","Appel") #would have a high prob. similar("Apple","Mango") #would have a lower prob. 

    Hay un construido en.

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

    Usándolo:

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

    Creo que tal vez estás buscando un algoritmo que describa la distancia entre las cadenas. Aquí hay algunos a los que puede referirse:

    1. Distancia de Hamming
    2. Levenshtein distancia
    3. Damerau – Levenshtein distancia
    4. Jaro-Winkler distancia

    Solución # 1: Python builtin

    usa SequenceMatcher desde difflib

    ventajas : biblioteca nativa de python, sin necesidad de paquete adicional.
    contras : demasiado limitado, hay muchos otros buenos algoritmos para la similitud de cadenas que hay.

    ejemplo :

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

    Solución # 2: biblioteca de medusas

    Es una muy buena biblioteca con buena cobertura y pocos problemas. es compatible con:
    – Levenshtein Distancia
    – Damerau-Levenshtein Distancia
    – Jaro Distancia
    – Jaro-Winkler Distancia
    – Comparación de Enfoque de Clasificación de Partidos
    – Distancia de Hamming

    ventajas : fácil de usar, gama de algoritmos compatibles, probado.
    contras : no biblioteca nativa.

    ejemplo :

     >>> 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 es un paquete que implementa la distancia Levenshtein en python, con algunas funciones de ayuda para ayudar en ciertas situaciones en las que es posible que desee que dos cadenas distintas se consideren idénticas. Por ejemplo:

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

    Puedes crear una función como:

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

    La distancia del paquete incluye la distancia Levenshtein:

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

    El SequenceMatcher integrado es muy lento en entradas de gran tamaño, así es como se puede hacer con 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