5 Best Ways to Concatenate Subarrays into an Array in Python

by

💡 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: itertools.chain(). Clean and very Pythonic. Well-suited for more complex operations. External library (itertools) is required.
  • Method 4: numpy.concatenate(). Extremely fast for numerical data. Requires NumPy library. Overhead for converting regular lists into NumPy arrays.
  • Method 5: sum() Function. Clever one-liner for combining lists. Not intuitive and can be slow for large lists, as each concatenation creates a new list.