Unpack List in Python: A Beginner-Friendly Tutorial

Knowing how to unpack a list in Python can make your code cleaner and more concise. In this tutorial, you will learn to use unpacking in your Python programs.

When you unpack a list in Python you assign the elements of a list to multiple variables in a single statement. Ideally, the number of variables on the left side of the statement would match the number of elements in the list. If that’s not the case, the asterisk operator (*) can be used as a solution.

List unpacking in Python is a concept that improves value extraction from records while increasing code readability.

Let’s learn how to unpack a list in Python!

What is the Meaning of Unpacking a List in Python?

List unpacking is the most common way of extracting individual items from a list and assigning them to other variables in Python, without removing them from the list itself.

This smart solution improves access to list items while also making the code more logical and easier to read.

Imagine a list as a container holding various elements. Unpacking this list means opening the container and taking out its contents one by one. Each element extracted can then be assigned to a distinct variable, enabling you to process, manipulate, or display them.

Consider the following example:

fruits = ['apple', 'banana', 'orange', 'grapes']

Without list unpacking, you might access elements using indexing:

first_fruit = fruits[0]
second_fruit = fruits[1]
third_fruit = fruits[2]
fourth_fruit = fruits[3]
print(f"{first_fruit} - {second_fruit} - {third_fruit} - {fourth_fruit}")

The output of this code is:

apple - banana - orange - grapes

With list unpacking, you can achieve the same result more efficiently with a single line of code:

first_fruit, second_fruit, third_fruit, fourth_fruit = fruits
print(f"{first_fruit} - {second_fruit} - {third_fruit} - {fourth_fruit}")

Execute this code and confirm that the output is the same.

In the latter example, the elements of the fruits list are directly assigned to the variables first_fruit, second_fruit, third_fruit, and fourth_fruit, respectively. This eliminates the need for repetitive indexing and improves the clarity of your code.

Can a List Be Unpacked in Python?

Certainly! Python provides a robust mechanism for unpacking elements of a list. List unpacking is a fundamental tool within Python’s toolkit, contributing to enhanced code quality and organization.

Whether you’re dealing with a simple collection of values or intricate datasets, list unpacking significantly enhances the quality and organization of your code.

Consider a scenario where you have a list of employee records, each containing information such as name, age, and department:

employee_records = [
    ('Alice', 28, 'HR'),
    ('Bob', 32, 'Engineering'),
    ('Carol', 24, 'Marketing')

Without list unpacking, you might access the data using indexing, which can lead to code that is less intuitive and harder to follow:

for record in employee_records:
    name = record[0]
    age = record[1]
    department = record[2]
    print(f"Name: {name}, Age: {age}, Department: {department}")

The output of this code is the following:

Name: Alice, Age: 28, Department: HR
Name: Bob, Age: 32, Department: Engineering
Name: Carol, Age: 24, Department: Marketing

List unpacking allows you to simplify this process and make the code more concise:

for record in employee_records:
    name, age, department = record
    print(f"Name: {name}, Age: {age}, Department: {department}")

If you execute this code you will see that the output doesn’t change. At the same time, we have reduced the number of lines of code in the Python for loop from four to two.

You can even write the code as shown below and obtain the same output:

for name, age, department in employee_records:
    print(f"Name: {name}, Age: {age}, Department: {department}")

By directly unpacking the tuples within the employee_records list, you eliminate the need for explicit indexing and make the code more straightforward and readable.

How Do You Unpack a List in Python?

Let’s have a look at another example of list unpacking.

Unpacking a list in Python is a straightforward process. Consider a basic example with a list of days of the week:

days_of_week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

To unpack this list, you can assign each element to individual variables:

first_day, second_day, third_day, fourth_day, fifth_day = days_of_week

Upon execution, first_day will hold ‘Monday’, second_day will hold ‘Tuesday’, and so on.

This approach eliminates the need for manual indexing, resulting in cleaner and more readable code.

Let’s see what happens if we remove the variable fifth_day from the left side of the statement.

Traceback (most recent call last):
  File "/opt/codefather/tutorials/unpack_list.py", line 2, in <module>
    first_day, second_day, third_day, fourth_day = days_of_week
ValueError: too many values to unpack (expected 4)

The Python interpreter raises a ValueError because there are too many values in the list (five in this case) to be assigned to the variables on the left side of the expression (that are only four).

Also, let’s see what happens if we remove one string from the list and keep five variables on the left side of the statement:

days_of_week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday']
first_day, second_day, third_day, fourth_day, fifth_day = days_of_week

Python still raises a ValueError but this time the error message is different:

Traceback (most recent call last):
  File "/opt/codefather/tutorials/unpack_list.py", line 2, in <module>
    first_day, second_day, third_day, fourth_day, fifth_day = days_of_week
ValueError: not enough values to unpack (expected 5, got 4)

Python is saying that there are not enough values to be assigned to the five variables on the left side of the statement.

How Do You Use the Asterisk Operator (*) When Unpacking a Python List?

So far we have seen examples of code that works as expected when the number of elements in the list matches the number of variables on the left side of the statement.

The asterisk operator (*) in Python is used to unpack elements within lists when the number of elements in the list doesn’t match the number of variables on the left side of the assignment statement.

In this section, we will see two different methods to unpack a list using the asterisk operator (*) in Python.

Method 1: Unpack the First Elements of a List

Imagine you have a sales dataset for an unspecified number of months:

sales_data = [15000, 18000, 22000, 19000, 21000]

Let’s assume that you are only interested in the data for the first two months. With the asterisk operator, you can unpack the list without knowing its exact number of elements.

first_month, second_month, *remaining_months = sales_data

Here, first_month and second_month hold 15000 and 18000 respectively. The asterisk operator combined with the variableremaining_months creates a list containing the remaining values in the list, [22000, 19000, 21000].

This helpful technique allows you to work with lists of variable length.

Method 2: Unpack the First and Last Elements of a List

Using the asterisk operator, you can also unpack a list in Python and retrieve the first and last elements.

Here is how…

Suppose you’re working with temperature data and want to get the first and last temperatures:

temperature_data = [25.5, 28.2, 23.8, 32.1, 19.7, 35.6]

By utilizing the asterisk operator, you can isolate the middle temperatures:

first_temp, *middle_temps, last_temp = temperature_data
print("First temperature:", first_temp)
print("Last temperature:", last_temp)
print("Middle temperatures:", middle_temps)

Here, first_temp holds 25.5, last_temp holds 35.6, and middle_temps becomes a list with [28.2, 23.8, 32.1, 19.7]. This technique enhances code clarity and facilitates the extraction of specific values from a list.

Let’s confirm this by executing the code above:

First temperature: 25.5
Last temperature: 35.6
Middle temperatures: [28.2, 23.8, 32.1, 19.7]

Notice that the variable middle_temps is a list that contains all the elements in the list between the first and the last temperatures.

What Are the Benefits of List Unpacking in Python?

List unpacking provides several advantages that enhance code quality and readability of Python programs:

  • Elimination of manual indexing: Without list unpacking, you would need to access list elements using indices, such as days_of_week[0]. Unpacking eliminates the need for indexing, making your code cleaner and easier to understand.
  • Intuitive and clear code: List unpacking makes your code more intuitive and descriptive. The variable names you choose for unpacked elements convey their purpose, improving the overall readability of your code.
  • Reduced errors: Manually indexing to access elements in a list can lead to errors if you mistakenly use incorrect indices. Unpacking eliminates this risk, as the assignment of elements is direct and less error-prone.


List unpacking is a significant feature in Python that makes it easier to retrieve elements from lists and assign them to other variables. This practice enhances code readability and organization, especially when dealing with large datasets or complex groupings of information.

The asterisk operator (*) enhances list unpacking even further, allowing developers to easily manage variable list lengths and extract specific items from a list of variable length.

Knowing how to use list unpacking and the asterisk operator allows you as a programmer to write code that is not only efficient but easier to maintain.

As you progress in Python programming, embracing these notions will improve your coding abilities, allowing you to write code that is elegant, clear, and efficient.

Related article: in this article, you have seen that occasionally the error “too many values to unpack” can occur when you unpack a list in Python. Go through the following Codefather tutorial that will help you get more familiar with the too many values to unpack error.