**π‘ Problem Formulation:** In Python, it’s common to need to combine multiple subarrays into a single, contiguous array. Consider an array `A`

containing subarrays, and the goal is to create a new array `B`

which is the result of concatenating these subarrays. For example, given `A = [[1, 2], [3, 4], [5]]`

, the desired output is `B = [1, 2, 3, 4, 5]`

.

## Method 1: Concatenation Using a Loop

One straightforward approach to concatenate subarrays is using a loop to iterate over each subarray and extend the new array. This method is simple to understand and easily customizable.

Here’s an example:

array = [[1, 2], [3, 4], [5]] result = [] for subarray in array: result.extend(subarray)

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

This code declares an empty list `result`

and uses a `for`

loop to go through each subarray in the original array `array`

, extending `result`

with the elements of each subarray using the `extend()`

method.

## Method 2: Using List Comprehension

List comprehension offers a more concise and Pythonic way to flatten a list of lists. This method is both efficient and compact, making it a favorite for Python enthusiasts.

Here’s an example:

array = [[1, 2], [3, 4], [5]] result = [item for subarray in array for item in subarray]

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

The list comprehension iterates over each subarray in `array`

, then iterates over each item in each subarray, sequentially adding the items to the new list `result`

.

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

Function

The `itertools`

library has a function called `chain()`

, which is designed to handle iterable flattening operations efficiently. This method is both effective and Pythonic for more complex iterable concatenations.

Here’s an example:

from itertools import chain array = [[1, 2], [3, 4], [5]] result = list(chain.from_iterable(array))

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

The `chain.from_iterable()`

method takes an iterable of iterables (in this case, our list of lists) and returns a chain object that can be converted into a list, giving us the flattened result.

## Method 4: Using the `numpy.concatenate()`

Function

For numerical arrays, the `numpy`

library provides a powerful function called `concatenate()`

. This approach is highly efficient and is best suited for numerical computing.

Here’s an example:

import numpy as np array = np.array([[1, 2], [3, 4], [5]]) result = np.concatenate(array)

Output: `array([1, 2, 3, 4, 5])`

The `concatenate()`

function merges the array along the existing axis since our subarrays are all vectors (1D arrays). The result is a flat NumPy array.

## Bonus One-Liner Method 5: Using the `sum()`

Function

You can use the `sum()`

function with a starting list to flatten a list of lists. This one-liner is both clever and uncommon, suitable for quick and simple concatenations.

Here’s an example:

array = [[1, 2], [3, 4], [5]] result = sum(array, [])

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

This code snippet uses the built-in `sum()`

function, typically used for adding numbers, by specifying an empty list as the start value. It effectively concatenates all the sublists in `array`

together.

## Summary/Discussion

**Method 1: Loop and Extend.**Straightforward and easy to understand. Can become inefficient with very large lists.**Method 2: List Comprehension.**Compact and Pythonic. Requires understanding of list comprehensions. Efficient for smaller to medium-sized lists.**Method 3:**Clean and very Pythonic. Well-suited for more complex operations. External library (itertools) is required.`itertools.chain()`

.**Method 4:**Extremely fast for numerical data. Requires NumPy library. Overhead for converting regular lists into NumPy arrays.`numpy.concatenate()`

.**Method 5:**Clever one-liner for combining lists. Not intuitive and can be slow for large lists, as each concatenation creates a new list.`sum()`

Function.