# Python: Flatten Lists of Lists (4 Ways) In this tutorial, you’ll learn how to use Python to flatten lists of lists! You’ll learn how to do this in a number of different ways, including with for-loops, list comprehensions, the `itertools` library, and how to flatten multi-level lists of lists using, wait for it, recursion! Let’s take a look at what you’ll learn in this tutorial!

The Quick Answer: Use a Python List Comprehension to Flatten Lists of Lists

## What is a Python List of Lists?

In Python, a list of a lists is simply a list that contains other lists. In fact, lists of lists in Python can even contain other lists of lists! We can say that a list that contains only one other layer of lists is called a 2-dimensional list of lists. When one or more of these lists contain another list, we say they’re called 3-dimensional. This continues onwards, as we add more and more layers.

When you convert a list of lists, or a 2-dimensional array, into a one-dimensional array, you are flattening a list of lists. Learn four different ways to do this in this tutorial!

Let’s take a look at a simple list of lists in Python, so that you can have a visual depiction of what they actually look like:

`list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]`

When we try to access the third item, index position `2`, we can print out what it contains:

```list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(list_of_lists)

# Returns: [4, 5, 6]```

We can see here that the third item of our list `list_of_lists` is actually another list. This is what we mean by lists of lists – they are lists that contain other lists.

In the next section, you’ll learn how to use a naive method, a for-loop, to flatten a list of lists.

## How to Use a Python For Loop to Flatten Lists of Lists?

Now that you know what a Python list of lists is, let’s see how we can use a Python for-loop to flatten them!

In our for-loop, we’ll loop over each item in the list and add each item to a new list.

Let’s see how we can accomplish this with Python:

```# Use a for-loop to flatten a list of lists
list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

flat_list = list()

for sub_list in list_of_lists:
flat_list += sub_list

print(flat_list)

# Returns: [1, 2, 3, 4, 5, 6, 7, 8, 9]```

Let’s break down what we’ve done here step-by-step:

1. We loaded our `list_of_lists`
2. We generated a new list, called `flat_list`
3. We looped over each item, or list, in the list of lists and added each item’s values to our `flat_list`

Now that you’ve used a for-loop to flatten a list of lists, let’s learn how you can use list comprehensions to flatten them!

Want to learn more? Check out my in-depth tutorial on Python for-loops here!

## How to Use a List Comprehension in Python to Flatten Lists of Lists?

Python list comprehensions are elegant, Pythonic replacements for Python for-loops. In fact, any list comprehension can actually be expressed as a for-loop (though the reverse isn’t necessarily true).

So why write a list comprehension when a for-loop might do? There are a number of benefits to using list comprehensions – let’s take a quick look at them here:

1. You don’t need to instantiate a new empty list
2. You can write it over one line, rather than needing to split it out over multiple lines
3. They’re more Pythonic than for-loops

Want to learn more? Check out my in-depth tutorial on Python list comprehensions here!

Let’s take a look at how Python list comprehension look:

Now, let’s see how we can use list comprehensions to flatten Python lists of lists:

``` # Use a List Comprehension to Flatten a List of Lists
list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

flat_list = [item for sublist in list_of_lists for item in sublist]

print(flat_list)

# Returns: [1, 2, 3, 4, 5, 6, 7, 8, 9]```

Keep in mind that this does exactly what the for-loop is doing. The syntax can take a bit of getting used to, but once you master it, it becomes second nature and saves you a good amount of time!

## How to Use Itertools to Flatten Python Lists of Lists

Both of the methods we’ve covered off so far don’t require you to import a different library. Now, let’s take a look at how we can use the `itertools` library to flatten Python lists of lists.

In particular, we’ll use the `chain` function to to loop over each individual item in the larger list and add it to the larger list. Finally, since the `chain` function would return an `itertools.chain` object, we need to convert it back to a list.

Let’ see how we can do this here:

```from itertools import chain
list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

flat_list = list(chain(*list_of_lists))

print(flat_list)

# Returns: [1, 2, 3, 4, 5, 6, 7, 8, 9]```

Since we rely on variable unpacking, it’s not immediately clear what’s happening in the code (as some other custom functions might). Because of this, make sure you document your code well!

Check out some other Python tutorials on datagy, including our complete guide to styling Pandas and our comprehensive overview of Pivot Tables in Pandas!

## How to Flatten Multi-level Lists of Lists in Python?

Now, there may be times that you encounter more complex lists, such as the one shown below. Using one of these methods shown above won’t work, as they require you to have similar levels within their lists.

`list_of_lists = [1, [2, 3], [4, [5, 6]], [7, 8], 9]`

We can see that in our lists, we have some items at the root level, and some lists embedded in other lists.

In order to flatten this list of lists, we will need to think a bit more creatively. In particular, we can develop a function that calls itself recursively to unpack lists of lists.

Let’s see how we can do this in Python:

```# Flatten a multi-level list of lists with recursion
list_of_lists = [1, [2, 3], [4, [5, 6]], [7, 8], 9]

flat_list = list()

def flatten_list(list_of_lists):
for item in list_of_lists:
if type(item) == list:
flatten_list(item)
else:
flat_list.append(item)

return flat_list

flatten_list(list_of_lists)

print(flat_list)

# Returns: [1, 2, 3, 4, 5, 6, 7, 8, 9]```

This example is a bit more complex, so let’s see what we’ve done here:

1. We instantiate an empty list, `flat_list`. It’s important to do this outside of the function definition, since we’ll be calling it recursively.
2. We generate a new function `flatten_list` that takes an list of lists as an input
3. We then loop over each item in the list
4. We check if the type of the item is a list:
1. If it is a list, then we call the function again
2. If it isn’t, we append the item to our `flat_list`

We can see here that this works quite simply and is actually adaptable to any number of nesting!

## Conclusion

In this post, you learned how to use Python to flatten lists of lists. You also learned what lists of lists in Python actually are. In addition to this, you learned how to use for-loops and list comprehensions to flatten lists of lists in Python. You also learned how to use the `itertools` library to flatten lists of lists. Finally, you learned how to use recursion to multi-level lists of lists.

To learn more about the `itertools` library, check out the official documentation here.