python如何计算两个字符串的相似度
- User
python如何计算两个字符串的相似度
Assistant
Python中有多种方法计算字符串相似度,以下是几种常用的方法:
1. 编辑距离(Levenshtein距离)
def levenshtein_distance(s1, s2): if len(s1) < len(s2): return levenshtein_distance(s2, s1) if len(s2) == 0: return len(s1) previous_row = list(range(len(s2) + 1)) for i, c1 in enumerate(s1): current_row = [i + 1] for j, c2 in enumerate(s2): insertions = previous_row[j + 1] + 1 deletions = current_row[j] + 1 substitutions = previous_row[j] + (c1 != c2) current_row.append(min(insertions, deletions, substitutions)) previous_row = current_row return previous_row[-1] # 计算相似度(0-1之间,1表示完全相同) def similarity_ratio(s1, s2): distance = levenshtein_distance(s1, s2) max_len = max(len(s1), len(s2)) return 1 - distance / max_len if max_len > 0 else 1 # 示例 s1 = "hello" s2 = "hallo" print(f"相似度: {similarity_ratio(s1, s2):.2f}")2. 使用difflib库
from difflib import SequenceMatcher def string_similarity(s1, s2): return SequenceMatcher(None, s1, s2).ratio() # 示例 s1 = "hello world" s2 = "hello word" print(f"相似度: {string_similarity(s1, s2):.2f}")3. 使用第三方库
安装fuzzywuzzy
pip install fuzzywuzzy python-levenshteinfrom fuzzywuzzy import fuzz s1 = "hello world" s2 = "hello word" # 简单比率 print(f"简单比率: {fuzz.ratio(s1, s2)}") # 部分比率 print(f"部分比率: {fuzz.partial_ratio(s1, s2)}") # Token排序比率 print(f"Token排序比率: {fuzz.token_sort_ratio(s1, s2)}") # Token集合比率 print(f"Token集合比率: {fuzz.token_set_ratio(s1, s2)}")4. Jaccard相似度
def jaccard_similarity(s1, s2): set1 = set(s1) set2 = set(s2) intersection = set1.intersection(set2) union = set1.union(set2) return len(intersection) / len(union) if len(union) > 0 else 0 # 示例 s1 = "hello" s2 = "hallo" print(f"Jaccard相似度: {jaccard_similarity(s1, s2):.2f}")5. 余弦相似度
from collections import Counter import math def cosine_similarity(s1, s2): # 将字符串转换为字符频率向量 vec1 = Counter(s1) vec2 = Counter(s2) # 计算所有唯一字符 all_chars = set(vec1.keys()) | set(vec2.keys()) # 创建向量 v1 = [vec1.get(char, 0) for char in all_chars] v2 = [vec2.get(char, 0) for char in all_chars] # 计算余弦相似度 dot_product = sum(a * b for a, b in zip(v1, v2)) magnitude1 = math.sqrt(sum(a * a for a in v1)) magnitude2 = math.sqrt(sum(a * a for a in v2)) if magnitude1 == 0 or magnitude2 == 0: return 0 return dot_product / (magnitude1 * magnitude2) # 示例 s1 = "hello" s2 = "hallo" print(f"余弦相似度: {cosine_similarity(s1, s2):.2f}")不同方法适用于不同场景:
- 编辑距离:适合检测拼写错误或小幅修改
- difflib:Python内置,适合一般用途
- fuzzywuzzy:功能强大,适合模糊匹配
- Jaccard相似度:适合比较字符集合的重叠程度
- 余弦相似度:适合比较字符频率分布
选择哪种方法取决于你的具体需求和数据特点。
- User
使用python-Levenshtein库实现吧
Assistant
使用python-Levenshtein库是计算字符串相似度的高效方法,这个库是用C实现的,速度很快。
安装库
pip install python-Levenshtein基本用法
import Levenshtein # 示例字符串 s1 = "hello world" s2 = "hallo word" # 1. 计算编辑距离(需要多少次操作才能从s1变成s2) distance = Levenshtein.distance(s1, s2) print(f"编辑距离: {distance}") # 2. 计算相似度比率(0-1之间,1表示完全相同) ratio = Levenshtein.ratio(s1, s2) print(f"相似度比率: {ratio:.3f}") # 3. 计算Jaro相似度 jaro = Levenshtein.jaro(s1, s2) print(f"Jaro相似度: {jaro:.3f}") # 4. 计算Jaro-Winkler相似度(对前缀匹配给予更高权重) jaro_winkler = Levenshtein.jaro_winkler(s1, s2) print(f"Jaro-Winkler相似度: {jaro_winkler:.3f}")实用函数封装
import Levenshtein class StringSimilarity: @staticmethod def levenshtein_similarity(s1, s2): """基于编辑距离的相似度,返回0-1之间的值""" distance = Levenshtein.distance(s1, s2) max_len = max(len(s1), len(s2)) return 1 - distance / max_len if max_len > 0 else 1.0 @staticmethod def ratio_similarity(s1, s2): """直接使用ratio方法""" return Levenshtein.ratio(s1, s2) @staticmethod def jaro_similarity(s1, s2): """Jaro相似度""" return Levenshtein.jaro(s1, s2) @staticmethod def jaro_winkler_similarity(s1, s2): """Jaro-Winkler相似度""" return Levenshtein.jaro_winkler(s1, s2) @staticmethod def find_best_match(target, candidates, method='ratio', threshold=0.6): """在候选列表中找到最佳匹配""" similarity_func = { 'ratio': Levenshtein.ratio, 'jaro': Levenshtein.jaro, 'jaro_winkler': Levenshtein.jaro_winkler } func = similarity_func.get(method, Levenshtein.ratio) best_match = None best_score = 0 for candidate in candidates: score = func(target, candidate) if score > best_score and score >= threshold: best_score = score best_match = candidate return best_match, best_score # 使用示例 if __name__ == "__main__": # 基本相似度计算 s1 = "python编程" s2 = "python程序设计" print("=== 相似度计算 ===") print(f"字符串1: {s1}") print(f"字符串2: {s2}") print(f"编辑距离: {Levenshtein.distance(s1, s2)}") print(f"Ratio相似度: {StringSimilarity.ratio_similarity(s1, s2):.3f}") print(f"Jaro相似度: {StringSimilarity.jaro_similarity(s1, s2):.3f}") print(f"Jaro-Winkler相似度: {StringSimilarity.jaro_winkler_similarity(s1, s2):.3f}") # 模糊匹配示例 print("\n=== 模糊匹配 ===") target = "机器学习" candidates = ["机器学习算法", "深度学习", "机械学习", "人工智能", "机器学习入门"] best_match, score = StringSimilarity.find_best_match(target, candidates) print(f"目标字符串: {target}") print(f"候选列表: {candidates}") print(f"最佳匹配: {best_match} (相似度: {score:.3f})") # 批量相似度计算 print("\n=== 批量计算 ===") for candidate in candidates: similarity = Levenshtein.ratio(target, candidate) print(f"{target} vs {candidate}: {similarity:.3f}")性能比较和选择建议
import time import Levenshtein def performance_test(): # 测试数据 s1 = "这是一个用于测试字符串相似度计算性能的长字符串示例" * 10 s2 = "这是一个用于测试字符串相似度计算性能的长字符串样例" * 10 # 测试不同方法的性能 methods = [ ("Levenshtein.ratio", lambda: Levenshtein.ratio(s1, s2)), ("Levenshtein.jaro", lambda: Levenshtein.jaro(s1, s2)), ("Levenshtein.jaro_winkler", lambda: Levenshtein.jaro_winkler(s1, s2)), ] for name, func in methods: start_time = time.time() for _ in range(1000): result = func() end_time = time.time() print(f"{name}: {result:.3f} (耗时: {(end_time - start_time)*1000:.2f}ms)") # performance_test()实际应用场景
def fuzzy_search(query, database, threshold=0.7): """模糊搜索功能""" results = [] for item in database: similarity = Levenshtein.ratio(query.lower(), item.lower()) if similarity >= threshold: results.append((item, similarity)) # 按相似度排序 results.sort(key=lambda x: x[1], reverse=True) return results def spell_checker(word, dictionary, max_suggestions=5): """拼写检查器""" suggestions = [] for dict_word in dictionary: distance = Levenshtein.distance(word.lower(), dict_word.lower()) if distance <= 2: # 最多2个字符差异 similarity = Levenshtein.ratio(word.lower(), dict_word.lower()) suggestions.append((dict_word, similarity)) suggestions.sort(key=lambda x: x[1], reverse=True) return suggestions[:max_suggestions] # 示例使用 database = ["Python编程", "Java开发", "机器学习", "深度学习", "数据分析", "Web开发"] query = "python程序" print("模糊搜索结果:") results = fuzzy_search(query, database, threshold=0.3) for item, score in results: print(f"{item}: {score:.3f}")python-Levenshtein库的主要优势:
- 高性能:C语言实现,比纯Python实现快很多
- 多种算法:支持编辑距离、Jaro、Jaro-Winkler等多种相似度算法
- 简单易用:API简洁,直接调用即可
- 准确性高:算法实现标准,结果可靠
根据不同需求选择合适的方法:
- ratio(): 一般用途,平衡准确性和性能
- jaro(): 适合短字符串比较
- jaro_winkler(): 对前缀匹配敏感的场景
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.