Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-sonnet-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

python如何计算两个字符串的相似度

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Coherecommand-a-03-2025’s answer.
  1. User

    python如何计算两个字符串的相似度

  2. Claude 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-levenshtein
    
    from 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相似度:适合比较字符集合的重叠程度
    • 余弦相似度:适合比较字符频率分布

    选择哪种方法取决于你的具体需求和数据特点。

  3. User

    使用python-Levenshtein库实现吧

  4. Claude 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(): 对前缀匹配敏感的场景

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.