Skip to main content

Python NumPy: How to Fix "ValueError: zero-dimensional arrays cannot be concatenated"

The numpy.concatenate() function is a fundamental tool for joining multiple NumPy arrays into a single larger array along a specified axis. A common pitfall, especially for those new to NumPy, is to incorrectly pass arguments to this function, leading to ValueError: zero-dimensional arrays cannot be concatenated. This error typically arises when you provide a single array directly as an argument where np.concatenate() expects a sequence (like a list or tuple) of arrays to join. Even if you intend to "concatenate" a single array with nothing (effectively wanting a copy or to ensure it's an array), np.concatenate() requires its primary input to be an iterable collection of arrays.

This guide will clearly explain why this ValueError occurs due to improper argument formatting for np.concatenate(), demonstrate the common mistake of passing a single array directly, and provide the straightforward solution: always wrap the array(s) you intend to concatenate in a list or tuple, even if it's just a single array.

Understanding the Error: np.concatenate() Expects a Sequence of Arrays​

The signature of numpy.concatenate(a, axis=0, out=None, dtype=None, casting="same_kind") is key here.

  • a (first argument): This must be a sequence of array_like objects. This means you need to pass a Python list (e.g., [array1, array2]) or a tuple (e.g., (array1, array2)) containing the NumPy arrays you want to join.
  • axis (optional): The axis along which the arrays will be joined. Defaults to 0 (row-wise stacking for 2D arrays).

The error "ValueError: zero-dimensional arrays cannot be concatenated" (or sometimes a more direct TypeError if the input is completely misconstrued) occurs because if you pass a single N-dimensional array my_array directly as np.concatenate(my_array), NumPy attempts to iterate over the elements of the first axis of my_array as if those elements themselves were the arrays to be concatenated. If my_array is 1D, its elements are scalars (0-dimensional from NumPy's array perspective for this operation), and NumPy can not concatenate these 0D scalars.

Reproducing the Error: Passing a Single Array Directly​

import numpy as np

# A single 1D NumPy array
my_single_array = np.array([10, 20, 30])
print(f"Original array: {my_single_array}")

try:
    # ⛔️ Incorrect: Passing the 1D array directly, not as an element of a list/tuple.
    # NumPy tries to treat each element of my_single_array (10, 20, 30) as an array to concatenate.
    # Since these are scalars (0D), the error occurs.
    concatenated_error = np.concatenate(my_single_array)
    print(concatenated_error)
except ValueError as e:
    print(f"Error: {e}")

Output:

Original array: [10 20 30]
Error: zero-dimensional arrays cannot be concatenated

The Solution: Wrap the Array(s) in a List or Tuple​

To fix this, ensure the first argument to np.concatenate() is always a list or tuple, even if it contains only one array.

Concatenating a Single Array (by wrapping it in a list)​

If you truly intend to "concatenate" a single array (which effectively just returns the array itself, or a copy depending on internal details, but it's a valid operation if you want to ensure it's processed by concatenate), wrap it in a list.

import numpy as np

my_single_array = np.array([10, 20, 30])

# ✅ Correct: Wrap the single array in a list
concatenated_single_correct = np.concatenate([my_single_array])
# The list [my_single_array] is a sequence containing one array.

print("Concatenating a single array (wrapped in a list):")
print(concatenated_single_correct)

# Example with an inline list containing one array:
concatenated_inline_single = np.concatenate([[100, 200, 300]]) # Note the double brackets
print("Concatenating an inline list containing one array-like:")
print(concatenated_inline_single)

Output:

Concatenating a single array (wrapped in a list):
[10 20 30]
Concatenating an inline list containing one array-like:
[100 200 300]

Concatenating Multiple Arrays​

This is the more common use case for np.concatenate(). Ensure all arrays to be joined are elements of a single list or tuple.

import numpy as np

array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
array3 = np.array([7, 8, 9])

# ✅ Correct: Pass a list of arrays
concatenated_multiple_list = np.concatenate([array1, array2, array3])
print("Concatenating multiple arrays (passed as a list):")
print(concatenated_multiple_list)

# ✅ Correct: Pass a tuple of arrays
concatenated_multiple_tuple = np.concatenate((array1, array2, array3))
print("Concatenating multiple arrays (passed as a tuple):")
print(concatenated_multiple_tuple)

Output:

Concatenating multiple arrays (passed as a list):
[1 2 3 4 5 6 7 8 9]
Concatenating multiple arrays (passed as a tuple):
[1 2 3 4 5 6 7 8 9]

Concatenating Multi-dimensional Arrays (Illustrating Correct Syntax)​

The same principle applies when concatenating multi-dimensional arrays. The arrays themselves must be elements of a list or tuple.

import numpy as np

matrix_A = np.array([
    [1, 2],
    [3, 4]
])
matrix_B = np.array([
    [5, 6],
    [7, 8]
])

# ✅ Concatenate along axis 0 (rows - default)
concatenated_rows_2d = np.concatenate((matrix_A, matrix_B), axis=0)
print("2D arrays concatenated along axis 0 (rows):")
print(concatenated_rows_2d)

# ✅ Concatenate along axis 1 (columns)
# Shapes must be compatible along other axes (here, number of rows must match)
concatenated_cols_2d = np.concatenate((matrix_A, matrix_B), axis=1)
print("2D arrays concatenated along axis 1 (columns):")
print(concatenated_cols_2d)

Output:

2D arrays concatenated along axis 0 (rows):
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
2D arrays concatenated along axis 1 (columns):
[[1 2 5 6]
 [3 4 7 8]]
note

In both cases, (matrix_A, matrix_B) is a tuple containing the arrays to be joined.

Key Takeaway: np.concatenate() Needs a Sequence​

The fundamental rule for the first argument of numpy.concatenate() is that it must be a sequence (list or tuple) of arrays. It does not accept individual arrays as separate arguments, nor does it iterate through the elements of a single array passed directly if that array's elements are scalars.

Conclusion​

The NumPy ValueError: zero-dimensional arrays cannot be concatenated is a direct consequence of providing a single array to numpy.concatenate() where it expects a sequence (like a list or tuple) of arrays. The solution is consistently to: Wrap the array or arrays you intend to concatenate within a list or a tuple before passing them as the first argument to np.concatenate().

  • For a single array arr: use np.concatenate([arr]).
  • For multiple arrays arr1, arr2: use np.concatenate([arr1, arr2]) or np.concatenate((arr1, arr2)).

By adhering to this input requirement, you ensure that np.concatenate() receives its arguments in the expected format, allowing it to correctly join your NumPy arrays.

Table of Contents