Imagine, you iterate through a collection, which contains some other collections.

Like so: list of lists

In [32]: L = [ [i] for i in range(10) ]

In [33]: L
Out[33]: [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]]

One obvious way to iterate over inner values is to use indexing:

In [24]: [ i[0] for i in L ]
Out[24]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Well, there is another way to do so. Almost so :)

In [24]: [ i for i, in L ]
Out[24]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In fact, it is single element unpacking. It works, because in python commas, not brackets, “construct” tuples.

In [29]: 5,
Out[29]: (5,)

In [30]: (5)
Out[30]: 5

Are there any differences?

Yeap.

This unpacking seems to be faster than reading by index. Not much, by ~10%.

In [24]: L = [ [i] for i in range(1000) ]

In [25]: %timeit [ i for i, in L  ]
19.7 µs ± 31.4 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

In [26]: %timeit [ i[0] for i in L  ]
22.1 µs ± 150 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Also, there is logical difference.

If we take a list of empty lists as input, both statements will fall with different exceptions:

In [30]: [ i[0] for i in L+[[]] ]
# IndexError: list index out of range

In [31]: [ i for i, in L+[[]] ]
# ValueError: not enough values to unpack (expected 1, got 0)

However, if we have more than 1 element in any of inner lists, then:

  • unpacking will fall with ValueError: too many values to unpack (expected 1)
  • and reading by index will silently return first elements of lists

“Explicit is better than implicit” - they say, huh?

Hope you enjoyed! :)

Anything else to read?

Sure.

Python docs on unpacking - click, click и click

Comments to this article on my DEV.to - consider subscribing, by the way :)