Question

有谁知道为什么这两个会返回不同的比率。

>>> import difflib
>>> difflib.SequenceMatcher(None, '10101789', '11426089').ratio()
0.5
>>> difflib.SequenceMatcher(None, '11426089', '10101789').ratio()
0.625

Answer 1

This提供了一些匹配工作的想法。

>>> import difflib
>>> 
>>> def print_matches(a, b):
...     s =  difflib.SequenceMatcher(None, a, b)
...     for block in s.get_matching_blocks():
...         print "a[%d] and b[%d] match for %d elements" % block
...     print s.ratio()
... 
>>> print_matches('01017', '14260')
a[0] and b[4] match for 1 elements
a[5] and b[5] match for 0 elements
0.2
>>> print_matches('14260', '01017')
a[0] and b[1] match for 1 elements
a[4] and b[2] match for 1 elements
a[5] and b[5] match for 0 elements
0.4

看起来它在第一个序列上与第二个序列相匹配，并且从匹配开始继续。在这种情况下（'01017'，'14260'），右手匹配在0，即最后一个字符，因此右边没有其他匹配是可能的。在这种情况下（'14260'，'01017'），1s匹配，0仍然可以在右边匹配，因此找到两个匹配。

我认为匹配算法对于排序序列是可交换的。

Answer 2

我最近和difflib合作，虽然这个答案很晚，但我认为它可能会为hughdbrown提供的答案增添一些趣味，因为它会直观地显示出来的情况。

在我转到代码段之前，让我引用documentation

这个想法是找到最长的连续匹配子序列不包含“垃圾”元素;这些“垃圾”元素就是那些在某种意义上无趣，如空行或空格。（处理垃圾是Ratcliff和Obershelp的延伸算法。）然后相同的想法递归地应用于匹配的左侧和右侧的序列子。 这不会产生最少的编辑序列，但确实倾向于产生对人们“看起来正确”的匹配。

我认为比较第一个字符串与第二个字符串，然后找到匹配正确足够给人们。这在hughdbrown的答案中得到了很好的解释。

现在尝试运行此代码段：

def show_matching_blocks(a, b):
    s = SequenceMatcher(None, a, b)
    m = s.get_matching_blocks()
    seqs = [a, b]

    new_seqs = []
    for select, seq in enumerate(seqs):
        i, n = 0, 0
        new_seq = ''
        while i < len(seq):
            if i == m[n][select]:
                new_seq += '{' + seq[m[n][select]:m[n][select] + m[n].size] + '}'
                i += m[n].size
                n += 1
            elif i < m[n][select]:
                new_seq += seq[i:m[n][select]]
                i = m[n][select]
        new_seqs.append(new_seq)
    for seq, n in zip(seqs, new_seqs):
        print('{} --> {}'.format(seq, n))
    print('')

a, b = '10101789', '11426089'
show_matching_blocks(a, b)
show_matching_blocks(b, a)

输出：

10101789 --> {1}{0}1017{89}
11426089 --> {1}1426{0}{89}

11426089 --> {1}{1}426{0}{89}
10101789 --> {1}0{1}{0}17{89}

大括号内的部分（{}）是匹配的部分。我只是使用SequenceMatcher.get_matching_blocks()将匹配的块放在大括号中以获得更好的可见性。订单反转时，您可以清楚地看到差异。对于第一个订单，有4个匹配，因此比率为2*4/16=0.5。但是当订单反转时，现在有5个匹配，因此比率变为2*5/16=0.625。该比率按给定here in the documentation

计算

difflib根据序列的顺序返回不同的比率

2 个答案: