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** "construct" tuples, not *brackets*

```
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! :)

## Top comments (0)