How to Fix: ValueError: setting an array element with a sequence

This is a classic NumPy error. One common example is the ValueError setting array element that often occurs when working with arrays of different shapes. NumPy arrays are strict grids. They expect every row to be exactly the same length (a perfect rectangle).

If you try to feed it “ragged” data (rows of different lengths), it crashes.

import numpy as np

# Fix 1 — Pad short rows with zeros to match the longest row
data = [
    [1, 2, 3],
    [4, 5, 0]  # Padded to length 3
]
array = np.array(data)  # Works — shape (2, 3)

# Fix 2 — Storage only (no math): allow object dtype
array = np.array([[1, 2, 3], [4, 5]], dtype=object)
# Output: array([list([1, 2, 3]), list([4, 5])], dtype=object)

The Cause

You passed a list of lists where the inner lists don’t match.

Problem Code:

import numpy as np

data = [
    [1, 2, 3],   # Length 3
    [4, 5]       # Length 2 (Oops!)
]

# CRASH!
array = np.array(data)
# ValueError: setting an array element with a sequence.

NumPy is trying to interpret [4, 5] as a single number to fit into the grid, but it’s a sequence, hence the error message.

Fix 1: Make the Rows Equal (Padding)

The best fix for math is to “pad” the short rows with zeros or NaN.

data = [
    [1, 2, 3],
    [4, 5, 0]  # Pad with 0 to match length 3
]
array = np.array(data) # Works!

Fix 2: Use dtype=object (If you just want storage)

If you don’t need to do matrix math and just want to store the lists in an array, allow Python objects.

# This creates an array of LIST objects, not a matrix of numbers
array = np.array(data, dtype=object)
print(array)
# Output: array([list([1, 2, 3]), list([4, 5])], dtype=object)

Warning: This is much slower and loses most of NumPy’s speed benefits. Use lists or Polars if your data is jagged.

What This Error Exposes About NumPy’s Memory Layout Contract

ValueError: setting an array element with a sequence is NumPy’s array constructor failing to resolve a consistent shape for your data. NumPy stores all array data in a single contiguous block of memory — every element occupies a fixed number of bytes at a predictable offset from the start. That memory model requires a uniform shape: identical row lengths, identical data types, no gaps. When the constructor encounters [4, 5] where it expects three elements, it cannot calculate a valid memory layout and raises the error before allocating anything.

The padding fix restores the rectangular contract by making every row the same length before the array is constructed. Zero-padding is correct for most numerical workloads — matrix operations, dot products, and statistical functions all treat zero as a neutral value that does not distort results. NaN-padding is the better choice when zeros carry semantic meaning in your dataset and you need downstream operations to explicitly handle or ignore missing values via np.nanmean(), np.nansum(), or similar NaN-aware functions.

The dtype=object workaround exits NumPy’s typed memory model entirely. Each element in an object array holds a Python reference rather than a raw numeric value — the array becomes a container of pointers, not a contiguous block of numbers. That eliminates the shape constraint but also eliminates vectorized arithmetic, SIMD acceleration, and most of NumPy’s performance characteristics. For genuinely jagged data that will not undergo matrix operations, a plain Python list of lists or a Polars Series with List dtype is the correct data structure — it carries no pretense of rectangular shape and handles variable-length rows natively without the overhead of an object array.