# 5 Best Ways to Append a Python List of Lists into One List

π‘ Problem Formulation: Python developers often encounter situations where they have a list of lists, and they need to flatten it into a single list. For example, if the input is `[[1, 2], [3, 4], [5, 6]]`, the desired output is a single list: `[1, 2, 3, 4, 5, 6]`. Appending lists of lists into one list is a common operation that can be accomplished in multiple ways in Python.

## Method 1: Using a For Loop

This method involves iterating over each sublist within the list of lists and appending the elements of each sublist to a new list. It’s simple, easy to understand, and does not require any additional functions or methods from Python’s standard library.

Here’s an example:

```result = []
list_of_lists = [[1, 2], [3, 4], [5, 6]]
for sublist in list_of_lists:
result.extend(sublist)
```

Output: `[1, 2, 3, 4, 5, 6]`

This code snippet declares an empty list named `result` and iterates over each sublist in the `list_of_lists`. The `extend()` method then appends each element of the sublist to the `result`, producing a flattened list.

## Method 2: List Comprehension

List comprehension offers a more concise and Pythonic way to flatten a list of lists. It’s often considered more readable for those who are familiar with Python’s syntactic sugar.

Here’s an example:

```list_of_lists = [[1, 2], [3, 4], [5, 6]]
flattened_list = [element for sublist in list_of_lists for element in sublist]
```

Output: `[1, 2, 3, 4, 5, 6]`

In the example above, we create `flattened_list` by looping through each element of each sublist in a single line of code. The list comprehension iterates through each sublist, and then each element in that sublist, adding the element to the new list.

## Method 3: Using itertools.chain

The `itertools.chain` function is part of Python’s standard library, which is used for treating consecutive sequences as a single sequence. It’s useful for efficient and fast iteration over the elements.

Here’s an example:

```from itertools import chain
list_of_lists = [[1, 2], [3, 4], [5, 6]]
flattened_list = list(chain.from_iterable(list_of_lists))
```

Output: `[1, 2, 3, 4, 5, 6]`

The given code snippet imports `chain` from the `itertools` module and then uses its `from_iterable` method to iterate over each element of the provided list of lists. This is converted to a single list with the `list()` function.

## Method 4: Using NumPy

For larger datasets or for applications involving numerical computing, the NumPy library provides efficient array operations. The `numpy.concatenate()` method can be used to flatten a list of lists.

Here’s an example:

```import numpy as np
list_of_lists = [[1, 2], [3, 4], [5, 6]]
flattened_list = list(np.concatenate(list_of_lists))
```

Output: `[1, 2, 3, 4, 5, 6]`

After importing the NumPy package, the example utilizes `np.concatenate()` to merge the sublists into one array and then converts the resultant array back into a list with the `list()` function.

## Bonus One-Liner Method 5: Using sum

The built-in `sum()` function can be used in a creative way to flatten a list of lists. This method uses `sum()` to concatenate lists, with an initial empty list as the starting value.

Here’s an example:

```list_of_lists = [[1, 2], [3, 4], [5, 6]]
flattened_list = sum(list_of_lists, [])
```

Output: `[1, 2, 3, 4, 5, 6]`

This code snippet passes two arguments to the `sum()` function: our list of lists and an empty list. The second argument acts as the initializer, and `sum()` effectively appends each sublist to this initializer to produce a single flattened list.

## Summary/Discussion

• Method 1: Using a For Loop. Straightforward. Ideal for beginners. Supports complex nesting. May be slower for large datasets.
• Method 2: List Comprehension. Pythonic and concise. Readable for those familiar with the construct. Potentially less efficient for very large lists.
• Method 3: Using itertools.chain. Part of the standard library. Efficient and suitable for large or complex iterables. Requires importing a module.
• Method 4: Using NumPy. Fast performance for large numeric datasets. Requires NumPy installation. May not be necessary for simple/small lists.
• Method 5: Using sum. One-liner. Straightforward, but may be less intuitive that it can be used for lists. Not recommended for very large lists as it can be less efficient.