Why you should use Catch-All Unpacking and not Slicing in Python
Tags: python, django, development, tutorial
Published: 2021-01-31 00:42:13

When it comes to programming, there is the _correct_ way of doing something, and then there is the _right_ way of doing it. There are many cases within the Python language where this is true.

Lists are a fundamental data structure in Python, with a wide variety of use-cases. There are many instances where we require algorithms to split a list into "first" and "rest" pairs. Which is usually done with the use of indexing and slicing. For example:

```python
names = ["Alice", "Bob", "Carol", "Dave", "Elon"]
alice = names[0]
bob = names[1]
everyone_else = names[2:]
```
The above code snippet is _correct_ however not _right_ for a number of reasons:
* we've taken up three lines of code in order to accomplish something so simple
* we need to know the ordering in advance
* **error prone** as it can lead to off-by-one errors

## Why is it error prone? 😔 
What could be the case in the future is that we may want to change the boundaries or the index values, and forget to do so for the others. This of course can lead to errors or unpredictable results.

## Catch-All Unpacking to the rescue 🔥 
To remedy this situation, Python supports catch-all unpacking through the use of a _starred expression_. This will allow us to achieve the same result as above, without having to make use of indexing or slicing.

```python
names = ["Alice", "Bob", "Carol", "Dave", "Elon"]
alice, bob, *everyone_else = names
```
🤯 Now isn't that a thing of beauty! We have now:
* shortened it to one line
* made it easier to read
* no longer have to deal with the error prone brittleness of boundary indexes that must be kept in sync between lines.

### More on starred expressions ⭐️ 
The great thing about starred expressions is that we can place them in any position. This way you can get the benefits of catch-all unpacking anytime you need to extract one slice:
```python
names = ["Alice", "Bob", "Carol", "Dave", "Elon"]
alice, *everyone_else, elon = names
```
### Some Gotchas 🧐
There are two _gotchas_ when using catch-all unpacking. The first one is to remember that you must have at least one required part, otherwise you will face a `SyntaxError`. For example:
```python
*everyone = names
```
Will result in:
```
SyntaxError: starred assignment target must be in a list or tuple
```
The second is that you cannot make use of multiple catch-all expressions in a **single-level** unpacking structure:
```python
alice, *some_people, *other_people, elon = names
```
Which will result in:
```
SyntaxError: multiple starred expressions in assignment
```
## Catch-All Unpacking with a multi-level structure 💪
The second _gotcha_ is true for _single-level_ structures (lists, tuples). However this plays a little differently if we're using _multi-level_ structures.
For example:
```python
classrooms = {
    "classroom 1": ["Alice", "Bob", "Carol"],
    "classroom 2": ["David", "Elon"],
}
(
    (class_1, (best_student_1, *other_students_1)),
    (class_2, (*other_students_2, best_student_2)),
) = classrooms.items()

print(
    f"The best student in {class_1} is {best_student_1} not the other {len(other_students_1)}"
)
print(
    f"The best student in {class_2} is {best_student_2} not the other {len(other_students_2)}"
)
```
With the output being:
```
The best student in classroom 1 is Alice not the other 2
The best student in classroom 2 is Elon not the other 1
```
This may look a bit freakish with the brackets, however it is much more readable and cleaner than if we were to use slicing and indexing.

## Other things to note 📝 
### No more unpacking
Used correctly, _starred_ expressions will always result in lists. However if there are no more items to unpack from a sequence, it will result in an empty list `[]`.
```python
books = ["Harry Potter", "Narnia"]
harry_potter, narnia, *other_books = books
print(harry_potter)
print(narnia)
print(other_books)
```
Output
```
Harry Potter
Narnia
[]
```
### Catch-All Unpacking on Iterators
The other great thing about Catch-All Unpacking is that we can also use them on iterators. For example:
```python
movies = iter(["Star Wars", "The Godfather", "The Matrix", "Goodfellas"])
star_wars, the_godfather, *other_movies = movies
```
Although the above snippet is very basic and should in reality just be replaced with a standard list. The idea however is that you could extend this if you were dealing with a CSV file (for example).

## Final takeaways
This more-or-less sums up why you should prefer Catch-All Unpacking over Slicing and Indexing. The key takeaways here are:
* catch-all is visually cleaner compared to slicing and indexing
* it is a lot less error prone
* _starred expressions_ can appear in any position and will always result in a `list`, containing zero or more elements

---
If you enjoyed this post. Be sure to follow me on Twitter: [@sixfwa](https://twitter.com/sixfwa)
GitHub: [@sixfwa](https://github.com/sixfwa)