XORing long strings opimization?

[Georgy Pruss]

Well, nothing to add actually, but my results:

import string
import array

def xorstring0(s1,s2): # the original method
     # argument tests were here

     # Create lists
     l1 = map(ord, s1)
     l2 = map(ord, s2)

     # Xor it all together
     xorlist = []
     xorlist = [chr(x ^ y) for (x, y) in zip(l1, l2)]
     return string.join(xorlist,"") # Backward compatible

def xorstring1(s1,s2):
     xorlist = [chr(ord(x) ^ ord(y)) for (x, y) in zip(s1, s2)]
     return string.join(xorlist,"") # Backward compatible

def xorstring2(s1,s2):
     xorlist = [chr(ord(s1[i]) ^ ord(s2[i])) for i in range(len(s1))] # range
     return string.join(xorlist,"") # Backward compatible

def xorstring3(s1,s2):
     xorlist = [chr(ord(s1[i]) ^ ord(s2[i])) for i in xrange(len(s1))] # xrange
     return string.join(xorlist,"") # Backward compatible

def xorstring4(s1,s2):
     a1 = array.array("B", s1)
     a2 = array.array("B", s2)
     for i in xrange(len(a1)):
        a1[i] ^= a2[i]
     return a1.tostring()

s1 = 'abcew'*200000
s2 = 'xyzqa'*200000

fns = [ xorstring0, xorstring1, xorstring2, xorstring3, xorstring4 ]

# check if all works OK for some short data --
# protection from some rough error or typo
sx = fns[0]( s1[:100], s2[:100] )
for fn in fns:
   assert sx == fn( s1[:100], s2[:100] )

import time

tms = [60] * len(fns) # assume some unreal big times

for n in range(30): # loop 30 times

  for i in range(len(fns)):

    tb = time.time()
    sx = fns[i]( s1, s2 ) # do it!
    tm = time.time() - tb
    tms[i] = min( tms[i], tm )

for i in range(len(fns)):
  print "fn%d -- %.3f sec -- %.2f" % (i,tms[i],tms[i]/tms[-1])

# fn0 -- 5.578 sec -- 6.37
# fn1 -- 4.593 sec -- 5.25
# fn2 -- 2.609 sec -- 2.98
# fn3 -- 2.531 sec -- 2.89
# fn4 -- 0.875 sec -- 1.00


BTW, for the same million char strings, a C function runs 0.0035 sec, or 250 times faster!


G-: