python - 两个多字节二进制数据变量之间最快的按位异或

Question

按照以下逻辑，最快的实现方式是什么:

def xor(data, key):
    l = len(key)

    buff = ""
    for i in range(0, len(data)):
        buff += chr(ord(data[i]) ^ ord(key[i % l]))
    return buff

在我的例子中，key 是 20 字节的 sha1 摘要，data 是一些介于 20 字节和几兆字节(1、2、3)之间的二进制数据 p>

更新:

好的伙计们。这是一个快 3.5 倍的实现，它将数据和 key 分成 4、2 或 1 个字节的 block (在我的例子中，大部分时间它是 4 字节长整数):

def xor(data, key):
    index = len(data) % 4
    size = (4, 1, 2, 1)[index]
    type = ('L', 'B', 'H', 'B')[index]
    key_len = len(key)/size
    data_len = len(data)/size
    key_fmt = "<" + str(key_len) + type;
    data_fmt = "<" + str(data_len) + type;

    key_list = struct.unpack(key_fmt, key)
    data_list = struct.unpack(data_fmt, data)

    result = []
    for i in range(data_len):
        result.append (key_list[i % key_len] ^ data_list[i])

    return struct.pack(data_fmt, *result)

使用大量内存，但在我的情况下这不是什么大问题。

有什么想法可以将速度再提高几倍吗？ :-)

最终更新:

好的，好的... numpy 完成了这项工作。这简直太快了:

def xor(data, key):
    import numpy, math

    # key multiplication in order to match the data length
    key = (key*int(math.ceil(float(len(data))/float(len(key)))))[:len(data)]

    # Select the type size in bytes       
    for i in (8,4,2,1):
        if not len(data) % i: break

    if i == 8: dt = numpy.dtype('<Q8');
    elif i == 4: dt = numpy.dtype('<L4');
    elif i == 2: dt = numpy.dtype('<H2');
    else: dt = numpy.dtype('B');

    return numpy.bitwise_xor(numpy.fromstring(key, dtype=dt), numpy.fromstring(data, dtype=dt)).tostring()

初始实现需要 8 分 50 秒来处理 1 GB，第二个 - 大约 2 分 30 秒，最后一个只需...... 0 分 10 秒。

感谢所有贡献想法和代码的人。你们很棒!

Answer 1

未测试

不知道会不会更快

假设 len(mystring) 是 4 的倍数

def xor(hash,mystring):
    s = struct.Struct("<L")

    v1 = memoryview(hash)

    tab1 = []
    for i in range(5):
        tab1.append(s.unpack_from(v1,i*4)

    v2 = memoryview(mystring)
    tab2=[]
    for i in range(len(mystring)/4):
        tab2.append(s.unpack_from(v1,i*4))
    tab3 = []
    try:
        for i in range(len(mystring)/20):
            for j in range(5):
               tab3.append(s.pack(tab1[j]^tab2[5*i+j]))
    expect IndexError:
        pass
    return "".join(tab3)