for a in sorted(arr):
doSomething()
vs
sArr = sorted(arr)
for a in sArr:
doSomething()
are those 2 are the same exactly, or will one consume more cpu cycles then the other?
meaning, will sorted(arr) gets called every loop in the first example?
thanks
They're pretty much the same.
The documentation says:
The expression list is evaluated once; it should yield an iterable object.
So, there's no risk of the sorted() call happening more than once, in the above code.
The first form is still better, since it's shorter and more concise, and might make it possible to optimize better (since the intepreter could figure out that the sorted list goes totally out of scope after the loop finishes).
The are not the same exactly, but the difference is minimal. When in doubt, use the dis module to find out:
>>> import dis
>>> def f():
... for a in sorted(arr):
... doSomething()
...
>>> def g():
... sArr = sorted(arr)
... for a in sArr:
... doSomething()
...
>>> dis.dis(f)
2 0 SETUP_LOOP 27 (to 30)
3 LOAD_GLOBAL 0 (sorted)
6 LOAD_GLOBAL 1 (arr)
9 CALL_FUNCTION 1
12 GET_ITER
>> 13 FOR_ITER 13 (to 29)
16 STORE_FAST 0 (a)
3 19 LOAD_GLOBAL 2 (doSomething)
22 CALL_FUNCTION 0
25 POP_TOP
26 JUMP_ABSOLUTE 13
>> 29 POP_BLOCK
>> 30 LOAD_CONST 0 (None)
33 RETURN_VALUE
>>> dis.dis(g)
2 0 LOAD_GLOBAL 0 (sorted)
3 LOAD_GLOBAL 1 (arr)
6 CALL_FUNCTION 1
9 STORE_FAST 0 (sArr)
3 12 SETUP_LOOP 21 (to 36)
15 LOAD_FAST 0 (sArr)
18 GET_ITER
>> 19 FOR_ITER 13 (to 35)
22 STORE_FAST 1 (a)
4 25 LOAD_GLOBAL 2 (doSomething)
28 CALL_FUNCTION 0
31 POP_TOP
32 JUMP_ABSOLUTE 19
>> 35 POP_BLOCK
>> 36 LOAD_CONST 0 (None)
39 RETURN_VALUE
As you can see, the g() function adds a STORE_FAST and LOAD_FAST operation. You also use a little more memory, as the sorted results are kept around until the sArr variable is cleaned up, while in f() the sorted results can be cleaned up immediately following the conclusion of the loop.
The CALL_FUNCTION executes the sorted() function; it is only executed once.
sorted() returns an object which is subsequently iterated over. It is only called once.
Its the same as others have said. Remember when in doubt (though trivial and obvious in this case) always run the disassemble over the source. Alternatively, you can run it through cProfile, even when the disassemble be different, cProfile would give a fair idea about the performance
>>> def foo():
total = 0
arr = range(10000000,1,-1)
for a in sorted(arr):
total += a
>>> def bar():
total = 0
for a in sorted(range(10000000,1,-1)):
total += a
>>> cProfile.run("bar()")
5 function calls in 2.614 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 1.914 1.914 2.614 2.614 <pyshell#88>:1(bar)
1 0.000 0.000 2.614 2.614 <string>:1(<module>)
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
1 0.266 0.266 0.266 0.266 {range}
1 0.434 0.434 0.434 0.434 {sorted}
>>> cProfile.run("foo()")
5 function calls in 2.477 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 1.779 1.779 2.346 2.346 <pyshell#86>:1(foo)
1 0.130 0.130 2.477 2.477 <string>:1(<module>)
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
1 0.152 0.152 0.152 0.152 {range}
1 0.415 0.415 0.415 0.415 {sorted}
>>>
As you would observe here
timeit instead to eliminate variations in OS scheduling.
cProfile is to show the functions calls and the ncalls