Python文本相似度计算的方法大全_Python

前言

在自然语言处理、信息检索和数据清洗等领域，计算文本相似度是一个基础而重要的任务。无论是检测重复文档、拼写纠错，还是推荐系统，都需要准确地衡量两个文本之间的相似程度。本文将深入解析多种文本相似度计算方法，帮助您选择最适合的算法。

什么是文本相似度？

文本相似度是指两个文本在内容、结构或语义上的相近程度。通常用0到1之间的数值表示，0表示完全不同，1表示完全相同。

1. levenshtein 距离（编辑距离）

levenshtein 距离是最经典的字符串相似度算法之一，它计算将一个字符串转换为另一个字符串所需的最少编辑操作次数。

核心公式

levenshtein.ratio() = 1 - (distance / max(len(s1), len(s2)))

实现示例

import levenshtein
 
def levenshtein_demo():
    text1 = "abcd"
    text2 = "abcd"
    
    distance = levenshtein.distance(text1, text2)
    ratio = levenshtein.ratio(text1, text2)
    
    print(f"编辑距离: {distance}")  
    print(f"相似度比率: {ratio:.4f}")  
 
levenshtein_demo()

适用场景: 拼写纠错、模糊搜索、dna序列比对

2. jaccard 相似度

jaccard 相似度基于集合论，通过计算两个集合交集与并集的比率来衡量相似度。

实现代码

def jaccard_similarity(s1, s2):
    """
    计算两个字符串的 jaccard 相似度
    """
    set1 = set(s1.lower())
    set2 = set(s2.lower())
    intersection = len(set1.intersection(set2))
    union = len(set1.union(set2))
    return intersection / union if union != 0 else 0
 
# 示例
text1 = "hello world"
text2 = "hello python"
print(f"jaccard 相似度: {jaccard_similarity(text1, text2):.4f}")

适用场景: 文档去重、关键词匹配、集合相似度计算

3. 余弦相似度

余弦相似度通过计算两个向量夹角的余弦值来衡量相似度，常用于文本向量化后的相似度计算。

实现代码

from collections import counter
import math
 
def cosine_similarity(s1, s2):
    """
    基于字符频率的余弦相似度计算
    """
    # 创建字符频率向量
    vec1 = counter(s1.lower())
    vec2 = counter(s2.lower())
    
    # 计算点积
    intersection = set(vec1.keys()) & set(vec2.keys())
    dot_product = sum(vec1[x] * vec2[x] for x in intersection)
    
    # 计算向量模长
    magnitude1 = math.sqrt(sum(v**2 for v in vec1.values()))
    magnitude2 = math.sqrt(sum(v**2 for v in vec2.values()))
    
    if magnitude1 == 0 or magnitude2 == 0:
        return 0
    return dot_product / (magnitude1 * magnitude2)
 
# 示例
text1 = "machine learning"
text2 = "deep learning"
print(f"余弦相似度: {cosine_similarity(text1, text2):.4f}")

适用场景: 文本分类、推荐系统、语义相似度计算

4. 汉明距离

汉明距离只计算相同位置上不同字符的数量，要求两个字符串长度相等。

实现代码

def hamming_distance(s1, s2):
    """
    计算汉明距离
    """
    if len(s1) != len(s2):
        return max(len(s1), len(s2))
    return sum(c1 != c2 for c1, c2 in zip(s1, s2))
 
def hamming_similarity(s1, s2):
    """
    计算汉明相似度
    """
    if len(s1) != len(s2):
        return 0
    max_len = len(s1)
    distance = hamming_distance(s1, s2)
    return 1 - (distance / max_len)
 
# 示例
binary1 = "1011101"
binary2 = "1001001"
print(f"汉明相似度: {hamming_similarity(binary1, binary2):.4f}")

适用场景: 错误检测、编码理论、生物信息学

5. dice 系数

dice 系数基于 n-gram 的交集来计算相似度，对短文本特别有效。

实现代码

def get_bigrams(s):
    """
    获取字符串的二元语法（bigram）
    """
    return set(s[i:i+2] for i in range(len(s)-1))
 
def dice_coefficient(s1, s2):
    """
    计算 dice 系数
    """
    bigrams1 = get_bigrams(s1.lower())
    bigrams2 = get_bigrams(s2.lower())
    
    intersection = len(bigrams1.intersection(bigrams2))
    return 2 * intersection / (len(bigrams1) + len(bigrams2)) if (len(bigrams1) + len(bigrams2)) > 0 else 0
 
# 示例
text1 = "night"
text2 = "nacht"
print(f"dice 系数: {dice_coefficient(text1, text2):.4f}")

适用场景: 短文本匹配、模糊搜索、语言识别

6. python 内置方法

python 标准库提供了 difflib 模块用于序列比较。

实现代码

import difflib
 
def sequence_matcher_similarity(s1, s2):
    """
    使用 difflib 计算相似度
    """
    return difflib.sequencematcher(none, s1, s2).ratio()
 
# 示例
text1 = "quick brown fox"
text2 = "quick brown cat"
print(f"difflib 相似度: {sequence_matcher_similarity(text1, text2):.4f}")

7. 第三方库 fuzzywuzzy

fuzzywuzzy 是一个专门用于模糊字符串匹配的库。

安装和使用

pip install fuzzywuzzy

from fuzzywuzzy import fuzz
 
def fuzzy_similarity_demo():
    text1 = "this is a test"
    text2 = "this is a test!"
    
    print(f"简单比率: {fuzz.ratio(text1, text2)}")
    print(f"部分匹配: {fuzz.partial_ratio(text1, text2)}")
    print(f"词序不敏感: {fuzz.token_sort_ratio(text1, text2)}")
    print(f"集合比率: {fuzz.token_set_ratio(text1, text2)}")
 
fuzzy_similarity_demo()

性能对比和选择建议

方法	时间复杂度	空间复杂度	适用场景	特点
levenshtein	o(mn)	o(mn)	通用文本比较	最经典，计算精确
jaccard	o(m+n)	o(m+n)	集合比较	快速，适合去重
余弦相似度	o(m+n)	o(m+n)	向量化文本	适合长文本语义比较
汉明距离	o(n)	o(1)	等长字符串	最快，限制较多
dice系数	o(m+n)	o(m+n)	短文本匹配	对局部相似敏感

实际应用示例

import levenshtein
import difflib
from fuzzywuzzy import fuzz
 
def comprehensive_similarity(text1, text2):
    """
    综合多种方法计算相似度
    """
    results = {
        'levenshtein': levenshtein.ratio(text1, text2),
        'difflib': difflib.sequencematcher(none, text1, text2).ratio(),
        'fuzzy_ratio': fuzz.ratio(text1, text2) / 100,
        'partial_ratio': fuzz.partial_ratio(text1, text2) / 100
    }
    
    print(f"文本1: {text1}")
    print(f"文本2: {text2}")
    print("-" * 30)
    for method, score in results.items():
        print(f"{method:15}: {score:.4f}")
    print()
 
# 测试不同场景
comprehensive_similarity("hello world", "hello world!")
comprehensive_similarity("quick brown fox", "fast brown fox")
comprehensive_similarity("machine learning", "deep learning")