精华内容
下载资源
问答
  • 评价字符串相似度最常见的办法就是:把一个字符串通过插入、删除或替换这样的编辑操作,变成另外一个字符串,所需要的最少编辑次数,这种就是编辑距离(edit distance)度量方法,也称为Levenshtein距离。方法1、...

    字符串相似度应用场景:拼写纠错、文本去重、上下文相似性、不同来源数据对比等。

    评价字符串相似度最常见的办法就是:把一个字符串通过插入、删除或替换这样的编辑操作,变成另外一个字符串,所需要的最少编辑次数,这种就是编辑距离(edit distance)度量方法,也称为Levenshtein距离。

    方法1、difflib模块

    1 # 优点:python自带模块,效率比较高

    2 def similar_diff_ratio(str1, str2):

    3 return difflib.SequenceMatcher(None, str1, str2).ratio()

    4

    5 # quick_ratio()比ratio()计算效率更高,计算结果一致

    6 def similar_diff_qk_ratio(str1, str2):

    7 return difflib.SequenceMatcher(None, str1, str2).quick_ratio()

    8

    9 # None参数是一个函数,用来去掉不需要比较的字符。比如,列表lst_str表示计算相似度时不需要比较的字符

    10 def similar_diff_ratio_filter(lst_str, str1, str2):

    11 return difflib.SequenceMatcher(lambda x: x in lst_str, str1, str2).ratio()

    12

    13 print(similar_diff_ratio("临安区中小企业创业基地", "临安区电子商务科技园"))

    14 print(similar_diff_qk_ratio("临安区中小企业创业基地", "临安区电子商务科技园"))

    15 # 有一点疑问,将不需要比较的字符加入后,相似度计算结果没变化,欢迎大佬留言解惑,谢谢!

    16 lst_str = ['临安区', '创业', '为什么', '忽略', '某些字符之后', '相似度还是一致']

    17 print(similar_diff_ratio_filter(lst_str, "临安区中小企业创业基地", "临安区电子商务科技园"))

    0.2857142857142857

    0.2857142857142857

    0.2857142857142857

    方法2、通过在长度较短的字符串末尾补充空格,将2个字符串处理成等长,然后从左至右比较同位置字符串

    1 def similar_left(str1, str2):

    2 str1 = str1 + ' ' * (len(str2) - len(str1))

    3 str2 = str2 + ' ' * (len(str1) - len(str2))

    4 return sum(1 if i == j else 0 for i, j in zip(str1, str2)) / float(len(str1))

    5

    6 print(similar_left("临安区中小企业创业基地", "临安区电子商务科技园"))

    7 print(similar_left("临安区电子商务科技园", "园技科务商子电区安临"))

    0.2727272727272727

    0.0

    方法3、Levenshtein模块

    3.1、相似度

    1 # 莱文斯坦比

    2 def similar_lvst_ratio(str1, str2):

    3 return Levenshtein.ratio(str1, str2)

    4

    5 # jaro距离

    6 def similar_lvst_jaro(str1, str2):

    7 return Levenshtein.jaro(str1, str2)

    8

    9 # Jaro–Winkler距离

    10 def similar_lvst_winkler(str1, str2):

    11 return Levenshtein.jaro_winkler(str1, str2)

    12

    13 print(similar_lvst_ratio("临安区中小企业创业基地", "临安区电子商务科技园"))

    14 print(similar_lvst_jaro("临安区中小企业创业基地", "临安区电子商务科技园"))

    15 print(similar_lvst_winkler("临安区中小企业创业基地", "临安区电子商务科技园"))

    0.2857142857142857

    0.5242424242424243

    0.666969696969697

    3.2、相似性度量

    1 # distance编辑距离(也称为Levenshtein距离 )。是描述由一个字串转化成另一个字串最少的操作次数,在其中的操作包括插入、删除、替换。

    2 def similar_lvst_distance(str1, str2):

    3 return Levenshtein.distance(str1, str2)

    4

    5 # hamming汉明距离是编辑距离的一种特殊情况。 要求str1和str2必须长度一致,描述两个等长字串之间对应位置上不同字符的个数。

    6 def similar_lvst_hamming(str1, str2):

    7 return Levenshtein.hamming(str1, str2)

    8

    9 print(similar_lvst_distance("临安区中小企业创业基地", "临安区电子商务科技园"))

    10 print(similar_lvst_hamming("临安区中小企业创业基地", "临安区电子商务科技园区"))

    8

    8

    其他常用相似性度量方法还有 Jaccard distance、J-W距离(Jaro–Winkler distance)、余弦相似性(cosine similarity)、欧氏距离(Euclidean distance)等。

    若想对以上方法有更深入研究,可参考大佬博客:https://www.cnblogs.com/wt869054461/p/5777782.html

    标签:ratio,Python,str2,str1,print,相似,临安,字符串,similar

    来源: https://www.cnblogs.com/hforevery0/p/14375286.html

    展开全文
  • “成本”列给出了计算成本的估算值,以分别计算长度为m和n的两个字符串之间的相似度。 归一化? 公制? 类型 成本 典型用法 距离 没有 是 O(米* n) 1 距离相似 是 没有 O(米* n) 1 距离 没有 没有 O(米* n...
  • 计算字符串变换相等的最小操作代价 2020远景智能计算字符串相似度计算字符串变换相等的最小操作代价题目描述:输入描述:输出描述:示例:思路:算法介绍示例代码:代码输出:2020远景智能在线笔试 计算字符串的相似度...
  • 主要方法有:编辑距离、余弦相似度、模糊相似度百分比 1、编辑距离 def levenshtein(first, second): ''' 编辑距离算法(LevD... returns: 两个字符串的编辑距离 int ''' if len(first) > len(se...

    主要方法有:编辑距离、余弦相似度、模糊相似度百分比

    1、编辑距离

    def levenshtein(first, second):
            ''' 编辑距离算法(LevD) 
                Args: 两个字符串
                returns: 两个字符串的编辑距离 int
            '''
            if len(first) > len(second):
                first, second = second, first
            if len(first) == 0:
                return len(second)
            if len(second) == 0:
                return len(first)
            first_length = len(first) + 1
            second_length = len(second) + 1
            distance_matrix = [list(range(second_length)) for x in range(first_length)]
            # print distance_matrix
            for i in range(1, first_length):
                for j in range(1, second_length):
                    deletion = distance_matrix[i - 1][j] + 1
                    insertion = distance_matrix[i][j - 1] + 1
                    substitution = distance_matrix[i - 1][j - 1]
                    if first[i - 1] != second[j - 1]:
                        substitution += 1
                    distance_matrix[i][j] = min(insertion, deletion, substitution)
                    # print distance_matrix
            return distance_matrix[first_length - 1][second_length - 1]
    str1="hello,good moring"
    str2="hi,good moring"
    edit_distance=levenshtein(str1,str2)
    print edit_distance

    2、余弦相似度

    import math
    import re
    import datetime
    import time
    
    text1 = "This game is one of the very best. games ive  played. the  ;pictures? cant descripe the real graphics in the game."
    text2 = "this game have/ is3 one of the very best. games ive  played. the  ;pictures? cant descriPe now the real graphics in the game."
    
    
    def compute_cosine(text_a, text_b):
        # 找单词及词频
        words1 = text_a.split(' ')
        words2 = text_b.split(' ')
        # print(words1)
        words1_dict = {}
        words2_dict = {}
        for word in words1:
            # word = word.strip(",.?!;")
            word = re.sub('[^a-zA-Z]', '', word)
            word = word.lower()
            # print(word)
            if word != '' and word in words1_dict: # 这里改动了
                num = words1_dict[word]
                words1_dict[word] = num + 1
            elif word != '':
                words1_dict[word] = 1
            else:
                continue
        for word in words2:
            # word = word.strip(",.?!;")
            word = re.sub('[^a-zA-Z]', '', word)
            word = word.lower()
            if word != '' and word in words2_dict:
                num = words2_dict[word]
                words2_dict[word] = num + 1
            elif word != '':
                words2_dict[word] = 1
            else:
                continue
        print(words1_dict)
        print(words2_dict)
    
        # 排序
        dic1 = sorted(words1_dict.items(), key=lambda asd: asd[1], reverse=True)
        dic2 = sorted(words2_dict.items(), key=lambda asd: asd[1], reverse=True)
        print(dic1)
        print(dic2)
    
        # 得到词向量
        words_key = []
        for i in range(len(dic1)):
            words_key.append(dic1[i][0])  # 向数组中添加元素
        for i in range(len(dic2)):
            if dic2[i][0] in words_key:
                # print 'has_key', dic2[i][0]
                pass
            else:  # 合并
                words_key.append(dic2[i][0])
        # print(words_key)
        vect1 = []
        vect2 = []
        for word in words_key:
            if word in words1_dict:
                vect1.append(words1_dict[word])
            else:
                vect1.append(0)
            if word in words2_dict:
                vect2.append(words2_dict[word])
            else:
                vect2.append(0)
        print(vect1)
        print(vect2)
    
        # 计算余弦相似度
        sum = 0
        sq1 = 0
        sq2 = 0
        for i in range(len(vect1)):
            sum += vect1[i] * vect2[i]
            sq1 += pow(vect1[i], 2)
            sq2 += pow(vect2[i], 2)
        try:
            result = round(float(sum) / (math.sqrt(sq1) * math.sqrt(sq2)), 2)
        except ZeroDivisionError:
            result = 0.0
        return result
    
    
    if __name__ == '__main__':
        result=compute_cosine(text1, text2)
        print(result)

    3、FuzzyWuzzy

    from fuzzywuzzy import fuzz
    fuzz.ratio("this is a test", "this is a test!")
    展开全文
  • python 字符串相似度计算,距离算法

    千次阅读 2018-09-10 10:39:59
    字符串相似度最常见的办法就是:把一个字符串通过插入、删除或替换为另一个字符串,所需要的最少编辑次数,这种就是编辑距离(edit distance)度量方法,也称为Levenshtein距离。海明距离是编辑...

    字符串的相似性比较应用场合很多,像拼写纠错、文本去重、上下文相似性等,判断2个文字列的相似度的多少,合理使用的话就可以实现Google、百度等搜索引擎中的 ‘你是不是要找‘XX’’ 的功能了。

    字符串相似度最常见的办法就是:把一个字符串通过插入、删除或替换为另一个字符串,所需要的最少编辑次数,这种就是编辑距离(edit distance)度量方法,也称为Levenshtein距离。海明距离是编辑距离的一种特殊情况,只计算等长情况下替换操作的编辑次数,只能应用于两个等长字符串间的距离度量。其他常用的度量方法还有 Jaccard distance、J-W距离(Jaro–Winkler distance)、余弦相似性(cosine similarity)、欧氏距离(Euclidean distance)等

    import difflib
    import Levenshtein
    
    str1 = "未来资金还款来源主要包括上市公司分红"
    str2 = "未来还款资金来源主要包括个人日常收入"
    
    # 1. difflib
    seq = difflib.SequenceMatcher(None, str1, str2)
    ratio = seq.ratio()
    print('difflib similarity1: ', ratio)
    #返回的结果超过0.6就算很相似。目前做近义词词典就是借助相似度自动化来实现。
    
    # difflib 去掉列表中不需要比较的字符
    seq = difflib.SequenceMatcher(lambda x: x in '主要', str1, str2)
    ratio = seq.ratio()
    print('difflib similarity2: ', ratio)
    
    #2. hamming距离,str1和str2长度必须一致,描述两个等长字串之间对应位置上不同字符的个数
    sim = Levenshtein.hamming(str1, str2)
    print('hamming similarity: ', sim)
    
    # 3. 编辑距离,描述由一个字串转化成另一个字串最少的操作次数,在其中的操作包括 插入、删除、替换
    sim = Levenshtein.distance(str1, str2)
    print('Levenshtein similarity: ', sim)
    
    # 4.计算莱文斯坦比
    sim = Levenshtein.ratio(str1, str2)
    print('Levenshtein.ratio similarity: ', sim)
    
    # 5.计算jaro距离
    sim = Levenshtein.jaro(str1, str2)
    print('Levenshtein.jaro similarity: ', sim)
    
    # 6. Jaro–Winkler距离
    sim = Levenshtein.jaro_winkler(str1, str2)
    print('Levenshtein.jaro_winkler similarity: ', sim)

    输出 

    difflib similarity1:  0.5555555555555556
    difflib similarity2:  0.5555555555555556
    hamming similarity:  10
    Levenshtein similarity:  10
    Levenshtein.ratio similarity:  0.5555555555555556
    Levenshtein.jaro similarity:  0.7222222222222222
    Levenshtein.jaro_winkler similarity:  0.7777777777777778

    ref:https://blog.csdn.net/qq_37788558/article/details/78780785

    https://blog.csdn.net/xiaodongxiexie/article/details/78221271

    https://blog.csdn.net/u013055678/article/details/52695280

    https://blog.csdn.net/u010454729/article/details/46559845(推荐)

    https://blog.csdn.net/yixianfeng41/article/details/61917158

    展开全文
  • import difflib s1="饭其家·特色盖浇饭金沙国际店" s2="饭其家·特色盖饭金沙国际店" def get_equal_rate(str1, str2): return difflib.SequenceMatcher(None, str1, str2).quick_ratio() print(get_equal_rate...
    import difflib
    
    s1="饭其家·特色盖浇饭金沙国际店"
    s2="饭其家·特色盖饭金沙国际店"
    def get_equal_rate(str1, str2):
       return difflib.SequenceMatcher(None, str1, str2).quick_ratio()
    
    print(get_equal_rate(s1,s2))

     

    展开全文
  • 利用difflib模块判断相似度 import difflib str1 = '今天天气好' str2 = '今天天气很好' SimilarityDegree = difflib.SequenceMatcher(None, str1, str2).quick_ratio() print(SimilarityDegree,type...
  • Levenshtein Distance 算法,又叫Edit Distance 算法,是指两个字符串之间,由一个转成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符。一般来说,编辑...
  • 如果我的目的地只有一个单词在里面,那么它可以完美地工作,但是如果目的地有两个或更多个单词,这就是出错的地方,程序陷入循环。有谁比我更有办法比较一下名单吗>>>for i in dstdir:>>> print i...
  • Levenshtein算法python也是用的这对比字符串相似度的,还不错
  • python比较字符串相似度

    万次阅读 2018-12-15 17:55:28
    比较两个字符串的模块是difflib.SequenceMatcher,使用起来很简单: import difflibdef string_similar(s1, s2): return difflib.SequenceMatcher(None, s1, s2).quick_ratio() print string_similar('爱尔眼科沪...
  • python 判断两个字符串相似度

    千次阅读 2018-04-25 15:18:35
    import difflibimport Levenshteindef get_equal_rate_1(str1, str2): return difflib.SequenceMatcher(None, str1, str2).quick_ratio()def get_equal_rate_2(str1, str2): return Levenshtein.ratio(str1, str.....
  • python 判断字符串相似度

    万次阅读 2019-01-19 15:27:16
    方法1 import difflib def get_equal_rate(str1, str2): return difflib.SequenceMatcher(None, str1, str2).quick_ratio() 方法2 import Levenshtein def get_equal_rate(str... return Levenshtein.ratio...
  • 1、先对下面两字符串进行分词处理: s1 = "hi,今天温度是12摄氏度。" s2 = "hello,今天温度很高。" 分词结果: ['hi', '今', '天', '温', '度', '是', '12', '摄', '氏', '度'] ['hello', '今', '天', '温', ...
  • Levenshtein:快速计算编辑距离以及字符串相似度
  • 在某种程度上,我不是将两个字符串比较在一起,而是为每个字符串得到一些数字/分数(哈希),以后可以告诉我两个字符串是否相似.两个相似的字符串应该具有相似(接近)的分数/哈希值.我们将这些字符串和分数视为一个例子:...
  • 只是衡量两个字符串之间的相同字符的占比,而未考虑字符的排序导致的两个字符的差异 s1="艾伦图灵传" s2="艾伦图灵传" def jaccard_score(s1,s2): print("s1",set(s1)) print("s2", set(s2)) print("s1&
  • #-*- coding: utf-8 -*-"""基于gensim模块的中文句子相似度计算思路如下:1.文本预处理:中文分词,去除停用词2.计算词频3.创建字典(单词与编号之间的映射)4.将待比较的文档转换为向量(词袋表示方法)5.建立语料库6....
  • import difflib import ...python-Levenshtein 包的名字和import的时候名字不一样 使用Levenshtein.ratio()函数即可 我常使用比较字符串近似值,根据字符串相同或者不同的程度,用来简单分析或者归类字符串或者数据。
  • 字符串余弦相似性算法是通过利用我们初中就学过的三角函数中的余弦定理来计算两个字符串相似度,它是定义在向量空间模型(Vector Space Model)中的。余弦相似度用向量空间中两个向量夹角的余弦值作为衡量两个个体间...
  • 1.首先查看待比较两个字符串的编码格式 ,使用命令 import chardet ...... string_code = chardet.detect(string_word) 比较两个字符串的编码结果,如下图所示 一个编码格式为‘UTF-8-SIG’,另一个编码格式为...
  • 在莱文斯坦距离中,对每一个字符都有三种操作:删除、添加、替换例如有s1和s2两个字符串,a和b是与之对应的保存s1和s2全部字符的数组,i/j是数组下标。莱文斯坦距离的含义,是求将a变成b(或者将b变成a),所需要做的...
  • 是描述两个等长字串之间对应 位置上不同字符的个数。2). Levenshtein.distance(str1, str2)计算编辑距离(也称为 Levenshtein距离)。是描述由一个字串转化成另一个字串最少的操作次数,在其中的操作包括插入、删除、...
  • 评价字符串相似度最常见的办法就是:把一个字符串通过插入、删除或替换这样的编辑操作,变成另外一个字符串,所需要的最少编辑次数,这种就是编辑距离(edit distance)度量方法,也称为Levenshtein距离。海明距离是...
  • Python计算字符串相似度

    万次阅读 2017-02-28 14:20:36
    准备做一个小功能,需要计算字符串的相似度,提前做点...AKA,两个字符串之间的距离。解这样一个问题,可以使用穷举法,也可以使用动态规划,大家可以自行搜索。贪婪法不适合这个问题。 python-Levenshtein 我
  • python 字符串相似度判断详解

    千次阅读 2020-11-27 14:05:45
    如何用python求两个字符串的相似度呢?由于项目中要用到,所以本文将实现两个字符串相似度的求解过程。
  • def get_ord_list(str): return [ord(i) for i in str] def calcu_approx(str1,str2): def dot(A,B): return (sum(a*b for a,b in zip(A,B))) def cosine_similarity(a,b): retur...
  • python对比字符串相似度一. fuzzywuzzy二. difflib 一. fuzzywuzzy 需要安装python-Levenshtein from fuzzywuzzy import fuzz print(fuzz.ratio('a b c', 'a c b')) print(fuzz.token_set_ratio('a b c', 'a c b'))...
  • 所谓编辑距离,指的是从一个单词转换为另一个单词所需要编辑的次数,而单次编辑只有三种操作: 插入 删除 替换 递归实现 现有两个字符串 a 1 a 2 a 3 a 4 a_1a_2a_3a_4 a1​a2​a3​a4​和 b 1 b 2 b 3 b 4 b_1b_2b...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,791
精华内容 1,916
关键字:

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

python 订阅