Geekly Articles each Day
📜 ⬆️ ⬇️

Why itertools rocks

zip vs izip or “well, who else can explain the iterator chip?”



Task is simple: [0,1,2,3, ..., 99999] -> [(0,1), (2,3), ..., (99998, 99999)], i.e. select items in pairs. 100 thousand is not so much - therefore we will do it 150 times for each option.
')
Because the test is the sampling rate, and not putting the results in the list - we will return only the last element (everything is calculated all the same) - only to compare with the reference one.

Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  1. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  2. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  3. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  4. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  6. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  7. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  9. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  10. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  11. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  12. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  13. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  14. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  15. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  16. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  17. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  18. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  19. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  21. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  22. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  23. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  24. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  26. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  27. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  28. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  29. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  31. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  32. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  33. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  34. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  36. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  37. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  38. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  39. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  41. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  42. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  43. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  44. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  46. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  47. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  48. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  49. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  51. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  52. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  53. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  54. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  55. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  56. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  58. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  59. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  60. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  61. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  62. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  63. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  65. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  66. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  67. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  68. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  69. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  70. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  71. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )
  72. Copy Source | Copy HTML def bench (): import sys from time import time from itertools import izip, islice iterations = range (150) x = range (100000) def chk (name, func): t = time () for i in iterations: result = func(x) res = 'ok' if tuple (result) == (x[-2], x[-1]) else '!!' print '[%s] %10s: %0.4f' % (res, name, time ()-t) if res == '!!' : print 'auch!' print (x[-2], x[-1]) print result sys .stdout.flush() def test_zip (d): for (val1, val2) in zip (d[::2], d[1::2]): res = val1, val2 return res def test_izip (d): for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)): res = val1, val2 return res def test_for (d): for ix in range (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_slice (d): for ix in range (0, len (x), 2): res = x[ix:ix+2] return res def test_ifor (d): for ix in xrange (0, len (x), 2): res = x[ix], x[ix+1] return res def test_for_enum (d): for idx, val1 in enumerate (x[::2]): res = val1, x[idx*2+1] return res def test_for_count (d): idx = -1 for val1 in x[::2]: idx += 2 res = val1, x[idx] return res def test_for_islice (d): idx = -1 for val1 in islice(x, 0, None, 2): idx += 2 res = val1, x[idx] return res chk ( 'zip' , test_zip ) chk ( 'izip' , test_izip ) chk ( 'for' , test_for ) chk ( 'for+slice' , test_for_slice ) chk ( 'ifor' , test_ifor ) chk ( 'for+enum' , test_for_enum ) chk ( 'for+cnt' , test_for_count ) chk ( 'for+islice' , test_for_islice )


Results (C2Q @ 6700)
 In [780]: bench ()
 [ok] zip: 9.1446
 [ok] izip: 1.1836
 [ok] for: 1.6922
 [ok] for + slice: 2.4799
 [ok] ifor: 1.5846
 [ok] for + enum: 1.9567
 [ok] for + cnt: 1.3093
 [ok] for + islice: 1.3616


In other words, they are almost as effective as a raw counter (for + cnt) in the “nothing extra” mode. Most non-iterated functions (like zip vs izip above) have returning iterator functions that also benefit when lists are much smaller:

 # values ​​for bench () above
 iterations = range (1500000)
 x = range (10)

 [ok] zip: 3.7247
 [ok] izip: 3.2949
 [ok] for: 3.2703
 [ok] for + slice: 3.9095
 [ok] ifor: 2.9077
 [ok] for + enum: 3.9383
 [ok] for + cnt: 2.3443
 [ok] for + islice: 2.3495


But, here already usual for + the counter wins saving on a call of functions.

Source: https://habr.com/ru/post/52474/

More articles:


All Articles