# Efficiently Flattening Lists of Lists in Python: Two Approaches

## Using a List Comprehension and a For Loop

Are you looking for a way to flatten a list of lists in Python? If so, you’ve come to the right place! In this article, we’ll cover two different approaches to flatten a list of lists in Python: using a list comprehension and using a for loop.

We’ll also provide you with an example of how to flatten a list of numeric lists using a list comprehension.

## Using a List Comprehension

A list comprehension is a concise way to create a new list by iterating over an existing iterable object, such as a list. In the case of flattening a list of lists, we can use a nested list comprehension to achieve our goal.

Here’s the basic syntax for a nested list comprehension to flatten a list of lists:

``flat_list = [item for sublist in original_list for item in sublist]``

Let’s break down this code:

• `flat_list`: This is the new list that we’ll create by flattening the original list of lists.
• `item`: This is the individual element from the sublists that we want to include in our flat list.
• `sublist`: This is the sublist from the original list of lists that we want to iterate over.
• `original_list`: This is the list of lists that we want to flatten.

So, using this code, we can create a new list that contains all the elements from the original list of lists, without any nesting. Let’s see an example of this in action.

### Suppose we have the following list of lists:

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

To flatten this list of lists using a list comprehension, we can use the following code:

``flat_list = [item for sublist in original_list for item in sublist]``

### This will create a new flat list that looks like this:

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

## Using a For Loop

If you prefer to use a for loop instead of a list comprehension, you can still flatten a list of lists in Python. Here’s some example code for doing this:

``````flat_list = []
for sublist in original_list:
for item in sublist:
flat_list.append(item)``````

Let’s break down this code:

• `flat_list`: This is the new list that we’ll create by flattening the original list of lists.
• `sublist`: This is the sublist from the original list of lists that we want to iterate over.
• `original_list`: This is the list of lists that we want to flatten.
• `item`: This is the individual element from the sublists that we want to include in our flat list.
• `flat_list.append(item)`: This adds the item to our flat list.

So, using this code, we can create a new list that contains all the elements from the original list of lists, without any nesting. Example 1: Flattening a List of Numeric Lists

### Using a List Comprehension

Let’s say we have a list of lists that contains only numeric data:

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

To flatten this list of numeric lists using a list comprehension, we can use the following code:

``flat_list = [item for sublist in original_list for item in sublist]``

### This will create a new flat list that contains all the numeric data from the original list of lists:

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

## Conclusion

Flattening a list of lists in Python can be achieved using a list comprehension or a for loop. Both approaches yield the same result, but the choice between them comes down to personal preference and coding style.

We hope this article has helped you understand how to flatten a list of lists in Python and provided you with an example of how to do it using a list comprehension. Flattening a list of lists is a common task in Python and it can be accomplished using different approaches.

In this article, we will expand on the previous topic of flattening a list of numeric lists using a for loop, and we will introduce an example of flattening a list of string lists using a for loop. Example 2: Flattening a List of Numeric Lists

### Using a For Loop

As previously mentioned, we can use a for loop to flatten a list of lists in Python.

To flatten a list of numeric lists, we can use the following code:

``````original_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = []
for sublist in original_list:
for item in sublist:
flat_list.append(item)
print(flat_list)``````

In this code, we first define the original list of numeric lists. Then, we create an empty list called `flat_list` where we will store all the elements from the original list of lists without nesting.

Next, we use a for loop to iterate over each sublist in the original list of lists. For each sublist, we use another for loop to iterate over each item in the sublist.

We append each item to the `flat_list` using the `append()` method. When we print the `flat_list` using the `print()` function, we get the following output:

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

This is the same output that we obtained using the list comprehension approach.

Example 3: Flattening a List of String Lists

### Using a For Loop

Similar to flattening a list of numeric lists, we can also flatten a list of string lists using a for loop. To illustrate this, let’s consider the following example:

``````original_list = [['apple', 'banana'], ['orange', 'grape', 'lemon'], ['strawberry']]
flat_list = []
for sublist in original_list:
for item in sublist:
flat_list.append(item)
print(flat_list)``````

In this code, we define the original list of string lists. We create an empty list called `flat_list` where we will store all the elements from the original list of lists without nesting.

We use a for loop to iterate over each sublist in the original list of lists. For each sublist, we use another for loop to iterate over each item in the sublist.

We append each item to the `flat_list` using the `append()` method. When we print the `flat_list` using the `print()` function, we get the following output:

``['apple', 'banana', 'orange', 'grape', 'lemon', 'strawberry']``

As we can see, the `flat_list` contains all the string elements from the original list of string lists without any nesting.

## Conclusion

In this article, we expanded on the topic of flattening a list of lists in Python by introducing an example of flattening a list of string lists using a for loop. We saw how we can use the same approach of nested for loops and the `append()` method to flatten any list of lists, regardless of the data type.

Flattening a list of lists can be an important step in many data processing tasks, and having multiple approaches for achieving this goal can be very useful to have in our programming toolbox. In this article, we discussed how to flatten a list of lists in Python using two approaches: a list comprehension and a for loop.

We provided examples of flattening a list of numeric lists using both methods and introduced an example of flattening a list of string lists using a for loop. Flattening a list of lists is a common task in many data processing tasks, and being able to do so efficiently can save time and make code more readable.

By having multiple approaches available, we can choose the one that best fits our coding style and the specific requirements of our task. Remember: use a list comprehension for a concise and readable solution and a for loop for greater flexibility and control.