Iteration style

[Abdullah Khaidar]

Is there any iteration style we must use to get faster processing
time? I've tried with some style to concat number in list. But I still
don't know which one is the recommended style.

def useListIteratio n(): list = [str(element) for element in range(5)]
result = ""
for item in list:
result += item
return result
def useNormalIterat ion(): list = [str(element) for element in range(5)]
result = ""
for index in range(len(list) ):
result += list[index]
return result
def useJoin(): list = [str(element) for element in range(5)]
return "".join(lis t)
useListIteratio n() '01234' useNormalIterat ion() '01234' useJoin() '01234' def getTimer(): from timeit import Timer
t1 = Timer("useListI teration", "from __main__ import
useListIteratio n")
t2 = Timer("useNorma lIteration", "from __main__ import
useNormalIterat ion")
t3 = Timer("useJoin" , "from __main__ import useJoin")
print "Using list iteration: ", min(t1.repeat() )
print "Using normal iteration: ", min(t2.repeat() )
print "Using join: " , min(t3.repeat() )

getTimer() Using list iteration: 0.0700158819068
Using normal iteration: 0.0701589168456
Using join: 0.0685698880724 getTimer() Using list iteration: 0.070928567737
Using normal iteration: 0.0698613929983
Using join: 0.0693454056312 getTimer() Using list iteration: 0.0683511451874
Using normal iteration: 0.0698585993471
Using join: 0.0708022947051

[Michael Hoffman]

Abdullah Khaidar wrote:

Is there any iteration style we must use to get faster processing
time?
Yes, definitely this one:

def useJoin():
list = [str(element) for element in range(5)]
return "".join(lis t)

You aren't going to get the right results from your getTimer() function
because you are just timing putting the function object on the stack,
rather than actually calling it.

def getTimer():
from timeit import Timer
t1 = Timer("useListI teration", "from __main__ import
useListIteratio n")

should be t1 = Timer("useListI teration()", "from __main__ import
useListIteratio n")
print "Using list iteration: ", min(t1.repeat() )

Of course now that you are actually calling a function, it should take a
lot longer, so repeating it 3 * 1,000,000 times is way too many. I would
change the number of integers you are concatenating from 5 to 1000 and
run Timer.timeit(nu mber=100) (repeats 3 * 100 times) instead.

getTimer()

Using list iteration: 0.751999855042
Using normal iteration: 0.766999959946
Using join: 0.446000099182

HTH,
--
Michael Hoffman

[Abdullah Khaidar]

Thanks for your correction. Now I've found that using join (list
methods) is better than others.

--M.Abdullah Khaidar
http://khaidarmak.blogspot.com
Michael Hoffman <m.************ *************** ******@example. com> wrote in message news:<ci******* ***@pegasus.csx .cam.ac.uk>...

Abdullah Khaidar wrote:

Is there any iteration style we must use to get faster processing
time?

Yes, definitely this one:

>def useJoin():

list = [str(element) for element in range(5)]
return "".join(lis t)

You aren't going to get the right results from your getTimer() function
because you are just timing putting the function object on the stack,
rather than actually calling it.

>def getTimer():

from timeit import Timer
t1 = Timer("useListI teration", "from __main__ import
useListIteratio n")

should be t1 = Timer("useListI teration()", "from __main__ import
useListIteratio n")

print "Using list iteration: ", min(t1.repeat() )

Of course now that you are actually calling a function, it should take a
lot longer, so repeating it 3 * 1,000,000 times is way too many. I would
change the number of integers you are concatenating from 5 to 1000 and
run Timer.timeit(nu mber=100) (repeats 3 * 100 times) instead.

>>> getTimer()

Using list iteration: 0.751999855042
Using normal iteration: 0.766999959946
Using join: 0.446000099182

HTH,