For Loop Enumerate vs dict on enumerate

Question

Let me preface this question by stating that I am a novice both in Python and programming in general. That said, I was wondering whether there is any difference between the following two ways of creating a dictionary based on an existing list:

index = {}
seq = ['a', 'b', 'c']
for a,b in enumerate(seq): 
    index[a]= b
print(index)
print(dict(enumerate(seq)))

Output:

>>> print(index)
{0: 'a', 1: 'b', 2: 'c'}
>>> print(dict(enumerate(seq)))
{0: 'a', 1: 'b', 2: 'c'}

Both "print (index)" and "print (dict (enumerate (seq)" yield an equivalent result and I was wondering which one is better to perform in this context. I stumbled upon the latter by just practicing some coding and it made me question why one would need to perform a for loop if a one-line code such as the dict() gives the same result.

Answer 1

I've seen a lot of one line loops. It's just used as maybe a more compiled way of defining something but a for loop is just as good in most situations.

Answer 2

There is no semantic difference. This

dict(enumerate(seq))

will execute faster.

Update: well, it seems that faster might not be as clear cut as I expected.. (or correct, except maybe for 3.9b1 - see @Bharel's answer).

Update2: I've added measurements for the dict comprehension solution from @ShadowRanger for completeness.

Py2.7:

(dev) c:\srv> python -m timeit -s "seq = ['a', 'b', 'c']" "dict(enumerate(seq))"
1000000 loops, best of 3: 1.06 usec per loop

(dev) c:\srv> python -m timeit -s "seq = ['a', 'b', 'c']" "index = {}" "for a,b in enumerate(seq):" "  index[a]= b"
1000000 loops, best of 3: 0.686 usec per loop

(dev) c:\srv> python -m timeit -s "seq = ['a', 'b', 'c']" "{a: b for a,b in enumerate(seq)}"
1000000 loops, best of 3: 0.807 usec per loop

Py3.5:

(dev35) c:\srv> python -m timeit -s "seq = ['a', 'b', 'c']" "dict(enumerate(seq))"
1000000 loops, best of 3: 1.19 usec per loop

(dev35) c:\srv> python -m timeit -s "seq = ['a', 'b', 'c']" "index = {}" "for a,b in enumerate(seq):" "  index[a]= b"
1000000 loops, best of 3: 0.813 usec per loop

(dev35) c:\srv> python -m timeit -s "seq = ['a', 'b', 'c']" "{a: b for a,b in enumerate(seq)}"
1000000 loops, best of 3: 0.917 usec per loop

Py3.8:

(dev38) c:\srv> python -m timeit -s "seq = ['a', 'b', 'c']" "dict(enumerate(seq))"
500000 loops, best of 5: 755 nsec per loop

(dev38) c:\srv> python -m timeit -s "seq = ['a', 'b', 'c']" "index = {}" "for a,b in enumerate(seq):" "  index[a]= b"
500000 loops, best of 5: 703 nsec per loop

(dev38) c:\srv> python -m timeit -s "seq = ['a', 'b', 'c']" "{a: b for a,b in enumerate(seq)}"
500000 loops, best of 5: 879 nsec per loop

Update 3: @Bharel and @ShadowRanger has pointed out, the length of the list is important. With lists of ~10 items, the dict(enumerate(..)) version becomes more performant.

code:

call workon dev
python -m timeit -s "seq = 'abcdefghij'" "dict(enumerate(seq))"
python -m timeit -s "seq = 'abcdefghij'" "index = {}" "for a,b in enumerate(seq):" "  index[a]= b"

call workon dev35
python -m timeit -s "seq = 'abcdefghij'" "dict(enumerate(seq))"
python -m timeit -s "seq = 'abcdefghij'" "index = {}" "for a,b in enumerate(seq):" "  index[a]= b"

call workon dev38
python -m timeit -s "seq = 'abcdefghij'" "dict(enumerate(seq))"
python -m timeit -s "seq = 'abcdefghij'" "index = {}" "for a,b in enumerate(seq):" "  index[a]= b"

output:

100000 loops, best of 3: 1.94 usec per loop
1000000 loops, best of 3: 1.9 usec per loop

1000000 loops, best of 3: 1.7 usec per loop
1000000 loops, best of 3: 1.6 usec per loop

200000 loops, best of 5: 1.29 usec per loop
200000 loops, best of 5: 1.66 usec per loop

Answer 3

There's no difference at all in the output.

Regarding timing, you may use the timeit module to test for speed.

The second option, of one lining will necessarily be faster, and is also more readable in my opinion.

Timing results, Python 3.9:

python -m timeit -s "seq = ['a', 'b', 'c']" "index = {}" "for a,b in enumerate(seq):" "  index[a]= b"
500000 loops, best of 5: 803 nsec per loop

python -m timeit -s "seq = ['a', 'b', 'c']" "dict(enumerate(seq))"
500000 loops, best of 5: 786 nsec per loop

You might not see the difference in here, because the dict() operation for dict creation is longer than {} , and it's a fixed "setup cost".

If you'll increase the numbers to offset this "setup cost", you'll see the huge difference:

python -m timeit -s "seq = ['a', 'b', 'c']*1000" "dict(enumerate(seq))"
500 loops, best of 5: 395 usec per loop

python -m timeit -s "seq = ['a', 'b', 'c']*1000" "index = {}" "for a,b in enumerate(seq):" "  index[a]= b"
500 loops, best of 5: 509 usec per loop

Answer 4

dict(enumerate(seq)) is strictly better on performance and simplicity, it's just less flexible. For more flexibility, you'd go with dict comprehensions typically, eg:

index = {i: x * 2 for i, x in enumerate(seq)}  # Repeats each value

only going to your original for loop when the conversion code is too complicated for a comprehension.