How do I make a flat list out of a list of lists
Published: 2024-03-31 10:35:41

To [flatten a list of lists in Python](https://pythonkb.com/how-do-i-make-a-flat-list-out-of-a-list-of-lists/), you can use several methods, each with its own approach. Let's explore these methods, including the one you've mentioned, by breaking them down with examples and detailed explanations. We'll also consider their performance implications, particularly for data science applications where efficiency can be crucial.

### Method 1: Flattening a List Using a List Comprehension

The list comprehension method is concise and usually the fastest way to flatten a list of lists. Here's how it works, step by step:

```python
# Original list of lists
xss = [[1,2,3],[4,5,6],[7,8,9]]

# Flattening the list of lists
flat_list = [x for xs in xss for x in xs]
```

- `xss` is your list of lists.
- The outer loop `for xs in xss` iterates through each sublist (`xs`) in the list of lists (`xss`).
- The inner loop `for x in xs` iterates through each element (`x`) in the current sublist (`xs`).
- Each element `x` found by the inner loop is collected into a new, flat list called `flat_list`.

**Output:**

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

### Method 2: Using a For Loop Explicitly

If you prefer a more explicit method than a comprehension, you can use nested `for` loops:

```python
xss = [[1,2,3],[4,5,6],[7,8,9]]  # Original list of lists
flat_list = []

for xs in xss:  # Iterate through each sublist
    for x in xs:  # Iterate through each element in the current sublist
        flat_list.append(x)  # Append each element to the flat_list
```

**Output:**

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

### Method 3: Using `itertools.chain()`

The `itertools.chain()` function is designed for chaining iterables together, making it useful for flattening lists:

```python
from itertools import chain

xss = [[1,2,3],[4,5,6],[7,8,9]]
flat_list = list(chain.from_iterable(xss))
```

- `chain.from_iterable(xss)` chains the sublists in `xss` together.
- `list(chain.from_iterable(xss))` converts the chained iterable into a list.

### Method 4: Using `functools.reduce()`

This method applies a function of two arguments cumulatively to the items of an iterable:

```python
from functools import reduce

xss = [[1,2,3],[4,5,6],[7,8,9]]
flat_list = reduce(lambda x, y: x+y, xss)
```

- The lambda function `lambda x, y: x+y` concatenates two lists.
- `reduce()` applies this concatenation cumulatively, flattening `xss`.

### Method 5: Using `sum()`

Though not recommended due to its inefficiency for this purpose, `sum()` can concatenate lists:

```python
xss = [[1,2,3],[4,5,6],[7,8,9]]
flat_list = sum(xss, [])
```

- `sum(xss, [])` starts with an empty list `[]` and adds (concatenates) each sublist in `xss`.

### Performance Considerations

When flattening lists, especially in data science applications, performance can vary significantly between methods:

- **List Comprehension:** Fastest for most cases due to Python's optimization of list comprehensions.
- **`itertools.chain()`:** Highly efficient, especially for very large or deeply nested lists.
- **`functools.reduce()`:** Generally less efficient than list comprehension or `itertools.chain()`.
- **`sum()`:** Least efficient, especially as the size of the input grows, due to the overhead of repeatedly creating new lists during concatenation.

### Flattening Lists with NumPy

For data science applications, NumPy provides efficient array operations that can be used for flattening:

```python
import numpy as np

xss = [[1,2,3],[4,5,6],[7,8,9]]
flat_array = np.concatenate(xss).flatten()
```

- `np.concatenate(xss)` combines the sublists into a NumPy array.
- `.flatten()` then flattens the array into a single dimension.

NumPy is particularly efficient for numeric data and can handle very large datasets more effectively than pure Python lists.

### Summary

Each method has its use cases, with list

 comprehensions and `itertools.chain()` generally being the most efficient for flattening lists in Python. For data science applications, leveraging NumPy can provide significant performance benefits, especially with large or complex datasets.