Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

numpy: formal definition of "array_like" objects?

Tags:

python

numpy

In numpy, the constructors of many objects accept an "array_like" as first argument. Is there a definition of a such object, either as an abstract meta class, or documentation of the methods is should contain??

like image 751
blue_note Avatar asked Nov 02 '16 11:11

blue_note


People also ask

What does Array_like mean in Python?

array_like. Any scalar or sequence that can be interpreted as an ndarray. In addition to ndarrays and scalars this category includes lists (possibly nested and with different element types) and tuples. Any argument accepted by numpy.

What is array object in NumPy called?

The array object in NumPy is called ndarray . We can create a NumPy ndarray object by using the array() function.

What is the meaning of shape in NumPy?

The shape of an array is the number of elements in each dimension.

Can NumPy array store objects?

NumPy arrays are typed arrays of fixed size. Python lists are heterogeneous and thus elements of a list may contain any object type, while NumPy arrays are homogenous and can contain object of only one type.


2 Answers

It turns out almost anything is technically an array-like. "Array-like" is more of a statement of how the input will be interpreted than a restriction on what the input can be; if a parameter is documented as array-like, NumPy will try to interpret it as an array.

There is no formal definition of array-like beyond the nearly tautological one -- an array-like is any Python object that np.array can convert to an ndarray. To go beyond this, you'd need to study the source code.

NPY_NO_EXPORT PyObject * PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth,                 int max_depth, int flags, PyObject *context) {     /*      * This is the main code to make a NumPy array from a Python      * Object.  It is called from many different places.      */     PyArrayObject *arr = NULL, *ret;     PyArray_Descr *dtype = NULL;     int ndim = 0;     npy_intp dims[NPY_MAXDIMS];      /* Get either the array or its parameters if it isn't an array */     if (PyArray_GetArrayParamsFromObject(op, newtype,                         0, &dtype,                         &ndim, dims, &arr, context) < 0) {         Py_XDECREF(newtype);         return NULL;     }     ... 

Particularly interesting is PyArray_GetArrayParamsFromObject, whose comments enumerate the types of objects np.array expects:

NPY_NO_EXPORT int PyArray_GetArrayParamsFromObject(PyObject *op,                         PyArray_Descr *requested_dtype,                         npy_bool writeable,                         PyArray_Descr **out_dtype,                         int *out_ndim, npy_intp *out_dims,                         PyArrayObject **out_arr, PyObject *context) {     PyObject *tmp;      /* If op is an array */      /* If op is a NumPy scalar */      /* If op is a Python scalar */      /* If op supports the PEP 3118 buffer interface */      /* If op supports the __array_struct__ or __array_interface__ interface */      /*      * If op supplies the __array__ function.      * The documentation says this should produce a copy, so      * we skip this method if writeable is true, because the intent      * of writeable is to modify the operand.      * XXX: If the implementation is wrong, and/or if actual      *      usage requires this behave differently,      *      this should be changed!      */      /* Try to treat op as a list of lists */      /* Anything can be viewed as an object, unless it needs to be writeable */  } 

So by studying the source code we can conclude an array-like is

  • a NumPy array, or
  • a NumPy scalar, or
  • a Python scalar, or
  • any object which supports the PEP 3118 buffer interface, or
  • any object that supports the __array_struct__ or __array_interface__ interface, or
  • any object that supplies the __array__ function, or
  • any object that can be treated as a list of lists, or
  • anything! If it doesn't fall under one of the other cases, it'll be treated as a 0-dimensional array of object dtype.
like image 181
unutbu Avatar answered Oct 13 '22 05:10

unutbu


The term "array-like" is used in NumPy, referring to anything that can be passed as first parameter to numpy.array() to create an array ().

As per the Numpy document:

In general, numerical data arranged in an array-like structure in Python can be converted to arrays through the use of the array() function. The most obvious examples are lists and tuples. See the documentation for array() for details for its use. Some objects may support the array-protocol and allow conversion to arrays this way. A simple way to find out if the object can be converted to a numpy array using array() is simply to try it interactively and see if it works! (The Python Way).

For more information, read:

  • Numpy: Array Creation
  • Terminology: Python and Numpy - iterable versus array_like
like image 20
Moinuddin Quadri Avatar answered Oct 13 '22 04:10

Moinuddin Quadri