What is the difference between Numpy’s `array()`

and `asarray()`

functions? When should you use one rather than the other? They seem to generate identical output for all the inputs I can think of.

# python – What is the difference between Numpy’s array() and asarray() functions?

## The Question :

*332 people think this question is useful*

*The Question Comments :*

## The Answer 1

*140 people think this answer is useful*

Since other questions are being redirected to this one which ask about `asanyarray`

or other array creation routines, it’s probably worth having a brief summary of what each of them does.

The differences are mainly about when to return the input unchanged, as opposed to making a new array as a copy.

`array`

offers a wide variety of options (most of the other functions are thin wrappers around it), including flags to determine when to copy. A full explanation would take just as long as the docs (see Array Creation, but briefly, here are some examples:

Assume `a`

is an `ndarray`

, and `m`

is a `matrix`

, and they both have a `dtype`

of `float32`

:

`np.array(a)`

and`np.array(m)`

will copy both, because that’s the default behavior.`np.array(a, copy=False)`

and`np.array(m, copy=False)`

will copy`m`

but not`a`

, because`m`

is not an`ndarray`

.`np.array(a, copy=False, subok=True)`

and`np.array(m, copy=False, subok=True)`

will copy neither, because`m`

is a`matrix`

, which is a subclass of`ndarray`

.`np.array(a, dtype=int, copy=False, subok=True)`

will copy both, because the`dtype`

is not compatible.

Most of the other functions are thin wrappers around `array`

that control when copying happens:

`asarray`

: The input will be returned uncopied iff it’s a compatible`ndarray`

(`copy=False`

).`asanyarray`

: The input will be returned uncopied iff it’s a compatible`ndarray`

or subclass like`matrix`

(`copy=False`

,`subok=True`

).`ascontiguousarray`

: The input will be returned uncopied iff it’s a compatible`ndarray`

in contiguous C order (`copy=False`

,`order='C')`

.`asfortranarray`

: The input will be returned uncopied iff it’s a compatible`ndarray`

in contiguous Fortran order (`copy=False`

,`order='F'`

).`require`

: The input will be returned uncopied iff it’s compatible with the specified requirements string.`copy`

: The input is always copied.`fromiter`

: The input is treated as an iterable (so, e.g., you can construct an array from an iterator’s elements, instead of an`object`

array with the iterator); always copied.

There are also convenience functions, like `asarray_chkfinite`

(same copying rules as `asarray`

, but raises `ValueError`

if there are any `nan`

or `inf`

values), and constructors for subclasses like `matrix`

or for special cases like record arrays, and of course the actual `ndarray`

constructor (which lets you create an array directly out of strides over a buffer).

## The Answer 2

*248 people think this answer is useful*

The definition of `asarray`

is:

def asarray(a, dtype=None, order=None): return array(a, dtype, copy=False, order=order)

So it is like `array`

, except it has fewer options, and `copy=False`

. `array`

has `copy=True`

by default.

The main difference is that `array`

(by default) will make a copy of the object, while `asarray`

will not unless necessary.

## The Answer 3

*125 people think this answer is useful*

The difference can be demonstrated by this example:

generate a matrix

>>> A = numpy.matrix(numpy.ones((3,3))) >>> A matrix([[ 1., 1., 1.], [ 1., 1., 1.], [ 1., 1., 1.]])

use

`numpy.array`

to modify`A`

. Doesn’t work because you are modifying a copy>>> numpy.array(A)[2]=2 >>> A matrix([[ 1., 1., 1.], [ 1., 1., 1.], [ 1., 1., 1.]])

use

`numpy.asarray`

to modify`A`

. It worked because you are modifying`A`

itself>>> numpy.asarray(A)[2]=2 >>> A matrix([[ 1., 1., 1.], [ 1., 1., 1.], [ 2., 2., 2.]])

Hope this helps!

## The Answer 4

*13 people think this answer is useful*

The differences are mentioned quite clearly in the documentation of `array`

and `asarray`

. The differences lie in the argument list and hence the action of the function depending on those parameters.

The function definitions are :

numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)

and

numpy.asarray(a, dtype=None, order=None)

The following arguments are those that may be passed to `array`

and **not** `asarray`

as mentioned in the documentation :

copy : bool, optional

If true (default), then the object is copied. Otherwise, a copy will only be made if`__array__`

returns a copy, if obj is a nested sequence, or if a copy is needed to satisfy any of the other requirements (dtype, order, etc.).subok : bool, optional

If True, then sub-classes will be passed-through, otherwise the returned array will be forced to be a base-class array (default).ndmin : int, optional Specifies the

minimum number of dimensions that the resulting arrayshould have. Ones will be pre-pended to the shape as needed to meet this requirement.

## The Answer 5

*1 people think this answer is useful*

Here’s a simple example that can demonstrate the difference.

The main difference is that array will make a copy of the original data and using different object we can modify the data in the original array.

import numpy as np a = np.arange(0.0, 10.2, 0.12) int_cvr = np.asarray(a, dtype = np.int64)

The contents in array (a), remain untouched, and still, we can perform any operation on the data using another object without modifying the content in original array.

## The Answer 6

*1 people think this answer is useful*

`asarray(x)`

is like `array(x, copy=False)`

Use `asarray(x)`

when you want to ensure that `x`

will be an array before any other operations are done. If `x`

is already an array then no copy would be done. It would not cause a redundant performance hit.

Here is an example of a function that ensure `x`

is converted into an array first.

def mysum(x): return np.asarray(x).sum()