NumPy Arrays in Python: Create Arrays with np.array()

To convert a Python list into a NumPy array, call np.array() and pass dtype=np.float32 when you need that type. I ran this under NumPy 2.5.3: a two-row list produced shape (2, 3), and unequal rows raised ValueError.

One Stack Overflow question puts the request plainly: “I would now like to convert it to a numpy.ndarray format with float32 datatype.” I compared np.array() with np.asarray() on an existing array. With a matching dtype, np.asarray() reused the same array object. np.array() made an independent copy.

What np.array() creates from a Python sequence

np.array() builds a NumPy ndarray from a Python list, tuple, another array, or a nested sequence. A regular numeric ndarray has one dtype and a rectangular shape. Each level of a nested sequence becomes another axis.

A flat list such as [10, 20, 30] has shape (3,). Two rows with three values each have shape (2, 3). Shape gives the axis lengths, and dtype names how NumPy represents each value.

Those attributes affect indexing, arithmetic, and memory use. The NumPy beginner guide explains the array model. The numpy.array reference documents the constructor options.

Check the values and shape you expect

Before converting, check that each row has the same length and decide which dtype the next calculation needs. NumPy infers a common dtype when values differ. My mixed integer and decimal example returned float64.

• Use a flat list for one axis, such as measurements from one sensor.
• Use equally sized nested lists when each row has the same fields.
• Pass dtype=np.float32 when a downstream tool needs single-precision values.

Setting a dtype converts values during construction, so check the range and precision your data needs. Choose an integer dtype for counts. For measurements, choose a floating-point dtype that matches the next library or file format.

Create and inspect a NumPy array

For nested input, check the returned shape before indexing so each list level lands on the axis you expect.

Convert a flat list

Pass the list directly to np.array(). Then inspect shape, ndim, and dtype before using the array in another calculation.

import numpy as np

values = [10, 20, 30]
flat = np.array(values)
print(flat)
print(flat.shape, flat.ndim, flat.dtype)

The output is [10 20 30] with shape (3,) and one dimension. On the Python 3.14.7 environment used for this example, NumPy inferred int64. The exact integer dtype can depend on the input and platform, so read flat.dtype instead of assuming a fixed type.

Build a two-dimensional array from rows

When each inner list has the same length, NumPy maps the outer list to rows and the inner values to columns. Choose the dtype in the constructor when the result needs a particular representation.

rows = [[1, 2, 3], [4, 5, 6]]
grid = np.array(rows, dtype=np.float32)
print(grid)
print(grid.shape, grid.size, grid.dtype)

This array has shape (2, 3), size 6, and dtype float32. The first number in the shape counts rows and the second counts columns. The size attribute is the product of the dimensions.

Choose a dtype deliberately

Without a specified dtype, NumPy chooses a common type for the values it receives. A list containing an integer and a decimal becomes floating point so both values fit. Check array.dtype when a library expects a particular precision.

Use np.zeros(), np.ones(), or np.arange() when you need an array with generated values rather than conversion from an existing sequence. The NumPy array-creation guide compares those constructors.

Reuse an existing array with np.asarray

np.array() copies input data by default. If you already have an ndarray and only need its array interpretation, np.asarray() can reuse the same object when its dtype and layout match. I checked both behaviors with the same three values.

source = np.array([10, 20, 30], dtype=np.float32)
reused = np.asarray(source, dtype=np.float32)
independent = np.array(source)
print(reused is source)
print(np.shares_memory(independent, source))

The output is True for np.asarray() and False for the memory-sharing check on the np.array() result. If np.asarray() must change the dtype or layout, NumPy creates a converted array instead. See the numpy.asarray reference for the copy rules.

Reshape only when the element count matches

reshape() returns an array with the requested dimensions when the new shape contains the same number of elements. It does not change the original array’s shape in place.

Reshape can return a view or a copy. In my contiguous example, the reshaped array shared memory with the original.

sequence = np.arange(6)
reshaped = sequence.reshape(2, 3)
print(sequence.shape, reshaped.shape)
print(np.shares_memory(sequence, reshaped))

The result has shapes (6,) and (2, 3), and the arrays share memory in this case. Basic slicing also returns a view, so changing a slice can change the original array.

Call .copy() when you need independent numeric storage. The NumPy indexing guide explains which operations return views and which return copies. For a fuller walkthrough, see AskPython’s guide to copying a NumPy array.

To see the tested shape, dtype, and memory cases together, save the examples as numpy_array_examples.py in a project with NumPy installed. Run the file from that project directory.

./.venv/bin/python numpy_array_examples.py

When np.array() changes or rejects your input

Uneven rows need a different container or an explicit object dtype. Choose based on whether you want numeric matrix operations or independently growing Python lists.

A nested list with uneven row lengths is not a rectangular numeric array. In NumPy 2.5.3, np.array([[1, 2], [3]]) raises ValueError for unequal row lengths. Make the rows equal before building a matrix.

A reader on Stack Overflow asked, “I want to create a numpy array in which each element must be a list, so later I can append new elements to each.” If each row grows independently, a Python list of lists is usually a better container. NumPy arrays keep a fixed shape for vectorized operations, so use lists when rows need to grow one at a time.

If another API specifically requires an array of Python objects, pass dtype=object. I tested that with unequal rows: the result had shape (2,), and each element remained a Python list. The result is a one-dimensional object array of lists, so numeric functions may not treat it as a two-column matrix.

For a padded numeric matrix, choose the padding value and build equal-length rows before conversion. For separate variable-length groups, keep lists or use a format designed for ragged data. Do not rely on dtype=object to make irregular rows behave like a dense ndarray.

Choose the constructor from your input

Choose a constructor based on whether you need a new copy or want to reuse a compatible array. Check shape and dtype before passing the result to the next calculation.

values = [10, 20, 30]
fresh = np.array(values)
same = np.asarray(fresh)
print(fresh is same)

NumPy array questions