快速获取字符串中不同索引的方法

fast ways needed to get number of different indices in string

本文关键字：索引 方法 获取 字符串      更新时间：2023-10-16

我想获得两个字符串中不相同的索引数。

固定的内容:

字符串数据在任何索引上只能有0或1。即字符串是数字的二进制表示。

两个字符串长度相同。

对于上面的问题，我用python写了下面的函数 
def foo(a,b):
    result = 0
    for x,y in zip(a,b):
        if x != y:
            result += 1
    return result

但问题是这些字符串非常大。非常大。所以上面的函数花了太多时间。我该怎么做才能让它超级快呢

这是我在c++中做同样的事情，它现在相当快，但仍然不能理解如何在短整数中打包和@Yves Daoust所说的:

size_t diff(long long int n1, long long int n2)
{
long long int c = n1 ^ n2;
bitset<sizeof(int) * CHAR_BIT> bits(c);
string s = bits.to_string();
return std::count(s.begin(), s.end(), '1');
}

我将在这里详细介绍这些选项，但基本上您是在计算两个数字之间的汉明距离。有专门的库可以让这个非常非常快，但让我们先关注纯Python选项。

你的方法，压缩

zip()首先生成一个大列表，然后让您循环。您可以使用itertools.izip()，并使其成为生成器表达式:

from itertools import izip
def foo(a, b):
    return sum(x != y for x, y in izip(a, b))

这一次只产生一对元组，避免了必须先创建一个大的元组列表。

Python布尔类型是int的子类，其中True == 1和False == 0，让您将它们相加:

>>> True + True
2

使用整数代替

但是，您可能需要重新考虑您的输入数据。用整数来表示二进制数据要高效得多;整数可以直接操作。内联进行转换，然后计算异或结果上的1的个数:

def foo(a, b):
    return format(int(a, 2) ^ int(b, 2), 'b').count('1')

，但不需要将a和b转换为整数，这样会更有效。

时间比较:

>>> from itertools import izip
>>> import timeit
>>> s1 = "0100010010"
>>> s2 = "0011100010"
>>> def foo_zipped(a, b): return sum(x != y for x, y in izip(a, b))
... 
>>> def foo_xor(a, b): return format(int(a, 2) ^ int(b, 2), 'b').count('1')
... 
>>> timeit.timeit('f(s1, s2)', 'from __main__ import s1, s2, foo_zipped as f')
1.7872788906097412
>>> timeit.timeit('f(s1, s2)', 'from __main__ import s1, s2, foo_xor as f')
1.3399651050567627
>>> s1 = s1 * 1000
>>> s2 = s2 * 1000
>>> timeit.timeit('f(s1, s2)', 'from __main__ import s1, s2, foo_zipped as f', number=1000)
1.0649528503417969
>>> timeit.timeit('f(s1, s2)', 'from __main__ import s1, s2, foo_xor as f', number=1000)
0.0779869556427002

如果输入变大，异或方法的速度会快几个数量级，这是， 首先将输入转换为int。

位计数专用库

位计数(format(integer, 'b').count(1))非常快，但如果您安装gmpy扩展库(围绕GMP库的Python包装器)并使用gmpy.popcount()函数，则可以更快:

def foo(a, b):
    return gmpy.popcount(int(a, 2) ^ int(b, 2))

gmpy.popcount()在我的机器上比str.count()方法快20倍。同样，一开始不需要将a和b转换为整数将消除另一个瓶颈，但即使这样，每次调用的性能几乎翻了一番:

>>> import gmpy
>>> def foo_xor_gmpy(a, b): return gmpy.popcount(int(a, 2) ^ int(b, 2))
... 
>>> timeit.timeit('f(s1, s2)', 'from __main__ import s1, s2, foo_xor as f', number=10000)
0.7225301265716553
>>> timeit.timeit('f(s1, s2)', 'from __main__ import s1, s2, foo_xor_gmpy as f', number=10000)
0.47731995582580566

说明a和b以整数开头的区别:

>>> si1, si2 = int(s1, 2), int(s2, 2)
>>> def foo_xor_int(a, b): return format(a ^ b, 'b').count('1')
... 
>>> def foo_xor_gmpy_int(a, b): return gmpy.popcount(a ^ b)
... 
>>> timeit.timeit('f(si1, si2)', 'from __main__ import si1, si2, foo_xor_int as f', number=100000)
3.0529568195343018
>>> timeit.timeit('f(si1, si2)', 'from __main__ import si1, si2, foo_xor_gmpy_int as f', number=100000)
0.15820622444152832

汉明距离专用库

gmpy库实际上包含一个gmpy.hamdist()函数，它直接计算这个确切的数字(整数的异或结果中1位的个数):

def foo_gmpy_hamdist(a, b):
    return gmpy.hamdist(int(a, 2), int(b, 2))

会让你大吃一惊完全如果你用整数开头:

def foo_gmpy_hamdist_int(a, b):
    return gmpy.hamdist(a, b)

比较:

>>> def foo_gmpy_hamdist(a, b):
...     return gmpy.hamdist(int(a, 2), int(b, 2))
... 
>>> def foo_gmpy_hamdist_int(a, b):
...     return gmpy.hamdist(a, b)
... 
>>> timeit.timeit('f(s1, s2)', 'from __main__ import s1, s2, foo_xor as f', number=100000)
7.479684114456177
>>> timeit.timeit('f(s1, s2)', 'from __main__ import s1, s2, foo_gmpy_hamdist as f', number=100000)
4.340585947036743
>>> timeit.timeit('f(si1, si2)', 'from __main__ import si1, si2, foo_gmpy_hamdist_int as f', number=100000)
0.22896099090576172

这是两个3k+数字之间汉明距离的10万倍。

另一个可以计算距离的包是Distance，它支持直接计算字符串之间的汉明距离。

确保你使用--with-c开关来编译C优化;当使用pip安装时，以bin/pip install Distance --install-option --with-c为例。

再次将其与XOR-with-bitcount方法进行基准测试:

>>> import distance
>>> def foo_distance_hamming(a, b):
...     return distance.hamming(a, b)
... 
>>> timeit.timeit('f(s1, s2)', 'from __main__ import s1, s2, foo_xor as f', number=100000)
7.229060173034668
>>> timeit.timeit('f(s1, s2)', 'from __main__ import s1, s2, foo_distance_hamming as f', number=100000)
0.7701470851898193

它使用朴素方法;压缩两个输入字符串并计算差异的数量，但由于它是在C中完成的，它仍然快得多，大约快10倍。但是，当您使用整数时，gmpy.hamdist()函数仍然优于它。

未测试，但如何执行:

sum(x!=y for x,y in zip(a,b))

如果字符串表示二进制数，则可以将其转换为整数并使用位运算符:

def foo(s1, s2):
    # return sum(map(int, format(int(a, 2) ^ int(b, 2), 'b'))) # one-liner
    a = int(s1, 2) # convert string to integer 
    b = int(s2, 2)
    c = a ^ b # use xor to get differences
    s = format(c, 'b') # convert back to string of zeroes and ones
    return sum(map(int, s)) # sum all ones (count of differences)
s1 = "0100010010"
s2 = "0011100010"
     # 12345
assert foo(s1, s2) == 5

将字符串打包为短整数(16位)。xoring之后，传递给一个预先计算的包含65536个条目的查找表，该表给出了每个短1的个数。

如果预打包不是一个选项，那么切换到带有内联AVX2 intrinsic的c++。它们将允许您在单个指令中加载32个字符，执行比较，然后将32个结果打包为32位(如果我是对的)。

相关文章：