Skip to main content

Python NumPy: How to Fix "ValueError: all the input arrays must have same number of dimensions (for concatenate)"

The numpy.concatenate() function is a fundamental tool for joining NumPy arrays along an existing axis. However, a strict requirement for this function is that all input arrays must have the same number of dimensions (i.e., the same ndim value). If you attempt to concatenate arrays with differing numbers of dimensions (e.g., a 1D array with a 2D array), NumPy will raise a ValueError: all the input arrays must have same number of dimensions, but the array at index 0 has X dimension(s) and the array at index 1 has Y dimension(s).

This guide will clearly explain why this dimensionality consistency is required for np.concatenate(), demonstrate common scenarios that trigger the error, and provide several robust solutions, including reshaping arrays to match dimensions, or using alternative stacking functions like np.column_stack(), np.row_stack(), or the np.c_ and np.r_ helpers which are more flexible with input dimensions.

Understanding the Error: Dimensionality Requirement for np.concatenate()​

The numpy.concatenate((a1, a2, ...), axis=0) function joins a sequence of arrays along a specified axis. For this operation to be well-defined, all input arrays in the sequence (a1, a2, ...) must possess the same number of dimensions (ndim).

  • You can concatenate two 2D arrays.
  • You can concatenate two 1D arrays.
  • You can not directly concatenate a 1D array with a 2D array using np.concatenate() without first making their number of dimensions match.

The error message clearly states this: "all the input arrays must have same number of dimensions, but the array at index 0 has X dimension(s) and the array at index 1 has Y dimension(s)".

Reproducing the Error: Concatenating Arrays with Different ndim​

Let's try to concatenate a 1D array with a 2D array.

import numpy as np

array_1d = np.array([10, 20]) # Shape: (2,), ndim: 1
array_2d = np.array([
    [30, 40],
    [50, 60]
]) # Shape: (2, 2), ndim: 2

print(f"array_1d (shape {array_1d.shape}, ndim {array_1d.ndim}):\n{array_1d}")
print(f"array_2d (shape {array_2d.shape}, ndim {array_2d.ndim}):\n{array_2d}")

try:
    # ⛔️ Incorrect: Concatenating a 1D array (ndim=1) with a 2D array (ndim=2)
    concatenated_error = np.concatenate((array_1d, array_2d), axis=0) # Default axis=0
    print(concatenated_error)
except ValueError as e:
    print(f"Error: {e}")

Output:

array_1d (shape (2,), ndim 1):
[10 20]
array_2d (shape (2, 2), ndim 2):
[[30 40]
 [50 60]]
Error: all the input arrays must have same number of dimensions, but the array at index 0 has 1 dimension(s) and the array at index 1 has 2 dimension(s)

Solution 1: Reshaping Arrays to Match Dimensions Before np.concatenate()​

Before calling np.concatenate(), you must ensure all arrays have the same number of dimensions. This usually involves reshaping one of the arrays.

Extending a 1D Array to 2D (e.g., using np.newaxis or reshape)**​

If you want to treat the 1D array as a single row or a single column to concatenate with a 2D array:

  • Treat 1D array as a single row (to concatenate along axis=0 - row-wise):

    import numpy as np

    # array_1d, array_2d defined as above
    array_1d = np.array([10, 20]) # Shape: (2,), ndim: 1
    array_2d = np.array([
        [30, 40],
        [50, 60]
    ]) # Shape: (2, 2), ndim: 2

    # Reshape array_1d to be a 2D array with 1 row: (1, 2)
    array_1d_as_row = array_1d.reshape(1, -1) # -1 infers the number of columns
    # Or: array_1d_as_row = array_1d[np.newaxis, :]
    print(f"array_1d_as_row (shape {array_1d_as_row.shape}):\n{array_1d_as_row}")

    # ✅ Now both are 2D, concatenate along axis=0 (rows)
    concatenated_rows = np.concatenate((array_1d_as_row, array_2d), axis=0)
    print("Concatenated row-wise (1D array reshaped to row):")
    print(concatenated_rows)

    Output:

    array_1d_as_row (shape (1, 2)):
    [[10 20]]
    Concatenated row-wise (1D array reshaped to row):
    [[10 20]
     [30 40]
     [50 60]]

  • Treat 1D array as a single column (to concatenate along axis=1 - column-wise):

    import numpy as np

    # array_1d, array_2d defined as above
    array_1d = np.array([10, 20]) # Shape: (2,), ndim: 1
    array_2d = np.array([
        [30, 40],
        [50, 60]
    ]) # Shape: (2, 2), ndim: 2

    # Reshape array_1d to be a 2D array with 1 column: (2, 1)
    array_1d_as_col = array_1d.reshape(-1, 1) # -1 infers the number of rows
    # Or: array_1d_as_col = array_1d[:, np.newaxis]
    print(f"array_1d_as_col (shape {array_1d_as_col.shape}):\n{array_1d_as_col}")

    # ✅ Now both are 2D, concatenate along axis=1 (columns)
    # Note: For this to make sense dimensionally with array_2d,
    # array_2d should also have 2 rows if array_1d_as_col has 2 rows.
    concatenated_cols = np.concatenate((array_1d_as_col, array_2d), axis=1)
    print("Concatenated column-wise (1D array reshaped to column):")
    print(concatenated_cols)

    Output:

    array_1d_as_col (shape (2, 1)):
    [[10]
     [20]]
    Concatenated column-wise (1D array reshaped to column):
    [[10 30 40]
     [20 50 60]]

Flattening a 2D Array to 1D (e.g., using .flatten() or reshape(-1))​

If you intend to combine all elements into a single 1D array:

import numpy as np

# array_1d, array_2d defined as above
array_1d = np.array([10, 20]) # Shape: (2,), ndim: 1
array_2d = np.array([
    [30, 40],
    [50, 60]
]) # Shape: (2, 2), ndim: 2

# Flatten array_2d to make it 1D
array_2d_flattened = array_2d.flatten() # Or array_2d.reshape(-1) or array_2d.ravel()
print(f"array_2d_flattened (shape {array_2d_flattened.shape}):\n{array_2d_flattened}")

# ✅ Now both are 1D, concatenate them
concatenated_flat = np.concatenate((array_1d, array_2d_flattened))
print("Concatenated 1D arrays (2D array was flattened):")
print(concatenated_flat)

Output:

array_2d_flattened (shape (4,)):
[30 40 50 60]
Concatenated 1D arrays (2D array was flattened):
[10 20 30 40 50 60]

Solution 2: Using Stacking Functions (More Flexible with Dimensions)​

NumPy provides stacking functions that are often more convenient than np.concatenate when dealing with arrays of potentially different (but compatible for stacking) dimensions.

numpy.column_stack(): Stacking 1D arrays as columns or 2D arrays as is​

np.column_stack() treats 1D arrays as columns to be stacked horizontally. 2D arrays are stacked as-is. All arrays must have the same first dimension (number of rows).

import numpy as np

# array_1d, array_2d defined as above
array_1d = np.array([10, 20]) # Shape: (2,), ndim: 1
array_2d = np.array([
    [30, 40],
    [50, 60]
]) # Shape: (2, 2), ndim: 2

# ✅ Using np.column_stack()
# array_1d (1D) is treated as a column. array_2d (2D) is appended.
# Both need to have 2 elements in their first dimension (which they do).
stacked_cols = np.column_stack((array_1d, array_2d))
print("Arrays stacked as columns using np.column_stack():")
print(stacked_cols)
print(f"Shape: {stacked_cols.shape}")

Output:

Arrays stacked as columns using np.column_stack():
[[10 30 40]
 [20 50 60]]
Shape: (2, 3)

numpy.row_stack() (or np.vstack()): Stacking arrays row-wise​

np.row_stack() (aliased as np.vstack) stacks arrays vertically. 1D arrays are first converted to 2D row vectors. All arrays must have the same number of columns after this conversion.

import numpy as np

# array_1d, array_2d defined as above
array_1d = np.array([10, 20]) # Shape: (2,), ndim: 1
array_2d = np.array([
    [30, 40],
    [50, 60]
]) # Shape: (2, 2), ndim: 2

# ✅ Using np.row_stack()
# array_1d (1D with 2 elements) is treated as a row [10, 20].
# array_2d (2D with 2 columns) is stacked below it.
# Both need to effectively have 2 columns for this to align.
stacked_rows = np.row_stack((array_1d, array_2d))
print("Arrays stacked as rows using np.row_stack():")
print(stacked_rows)
print(f"Shape: {stacked_rows.shape}")

Output:

Arrays stacked as rows using np.row_stack():
[[10 20]
 [30 40]
 [50 60]]
Shape: (3, 2)

Using numpy.c_ and numpy.r_ (Concise Indexing Tricks for Stacking)​

These are special objects that allow for concise array concatenation using slice notation.

  • np.c_: Translates slice objects to concatenation along the second axis (column-wise).
  • np.r_: Translates slice objects to concatenation along the first axis (row-wise).
import numpy as np

# array_1d, array_2d defined as above
array_1d = np.array([10, 20]) # Shape: (2,), ndim: 1
array_2d = np.array([
    [30, 40],
    [50, 60]
]) # Shape: (2, 2), ndim: 2

# ✅ Using np.c_ for column-wise concatenation
stacked_c_ = np.c_[array_1d, array_2d]
print("Arrays stacked column-wise using np.c_:")
print(stacked_c_) # Same output as np.column_stack() example

# ✅ Using np.r_ for row-wise concatenation
# For r_ to stack array_1d as a row with array_2d, array_1d needs to be 2D first
array_1d_as_row_for_r = array_1d.reshape(1, -1)
stacked_r_ = np.r_[array_1d_as_row_for_r, array_2d]
print("Arrays stacked row-wise using np.r_:")
print(stacked_r_) # Same output as np.row_stack() example

Output:

Arrays stacked column-wise using np.c_:
[[10 30 40]
 [20 50 60]]
Arrays stacked row-wise using np.r_:
[[10 20]
 [30 40]
 [50 60]]

These helpers can be very convenient but might be less readable for beginners compared to explicit stack functions.

Choosing the Right Approach​

  • If you intend to use np.concatenate(): You must first reshape one or more of your arrays so that all arrays in the input tuple have the same number of dimensions (ndim). The choice of new shape depends on whether you want to add the 1D array as a row or effectively as a column.
  • If you want more flexible stacking that handles 1D arrays gracefully:
    • Use np.column_stack() if you intend to treat 1D arrays as new columns to be added alongside existing 2D arrays.
    • Use np.row_stack() (or np.vstack()) if you intend to treat 1D arrays as new rows to be stacked under existing 2D arrays.
    • np.c_ and np.r_ are concise alternatives to column and row stacking, respectively.

Conclusion​

The NumPy ValueError: all the input arrays must have same number of dimensions... when using np.concatenate() is a strict reminder of its dimensionality requirement. To resolve it:

  1. Pre-process with reshape(): Modify your arrays (e.g., arr.reshape(1, -1) to make a 1D array a row vector, or arr.reshape(-1, 1) for a column vector, or arr.flatten() to make a 2D array 1D) so all inputs to np.concatenate() share the same ndim.
  2. Use Stacking Alternatives: Functions like np.column_stack(), np.row_stack(), np.vstack(), np.hstack(), or the np.c_/np.r_ helpers are often more convenient as they can intelligently handle arrays of differing dimensions (like 1D and 2D) for common stacking operations.

Choose the method that best reflects your intended array combination logic while respecting the dimensional constraints of the chosen NumPy function.

Table of Contents