DataArray¶

class Stoner.core.array.DataArray(input_array, *args, **kwargs)[source]¶

Bases: MaskedArray

A sub class of numpy.ma.MaskedArray with a copy of the setas attribute to allow indexing by name.

column_headers¶

of strings of the column names of the data.

Type:: list

When read, returns the row umbers of the data. When written to, sets the base row index. The base row index is preserved when a DataArray is indexed.

Type:: array of integers

x,y,z

When a column is declared to contain x, y, or z data, then these attributes access the corresponding columns. When written to, the attributes overwrite the existing column’s data.

Type:: 1D DataArray

d,e,f

Where a column is identified as containing uncertainties for x, y or z data, then these attributes provide a quick access to them. When written to, the attributes overwrite the existing column’s data.

Type:: 1D DataArray

u,v,w

Columns may be identieid as containing vectgor field information. These attributes provide quick access to them, assuming that they are defined as cartesian coordinates. When written to, the attributes overwrite the existing column’s data.

Type:: 1D DataArray

p,q,r

These attributes access calculated columns that convert \((x,y,z)\) data or \((u,v,w)\) into \((\phi,\theta,r)\) polar coordinates. If on x and y columns are defined, then 2D polar coordinates are returned for q and r.

Type:: 1D DataArray

setas¶

Actually a proxy to a magic class that handles the assignment of columns to different axes and also tracks the names of columns (so that columns may be accessed as named items).

Type:: list or string

This array type is used to represent numeric data in the Stoner Package - primarily as a 2D matrix in Stoner.Core.DataFile but also when a 1D row is required. In con trast to the parent class, DataArray understands that it came from a DataFile which has a setas attribute and column assignments. This allows the row to be indexed by column name, and also for quick attribute access to work. This makes writing functions to work with a single row of data more attractive.

Attributes Summary

`T`	View of the transposed array.
`base`	Base object if memory is from some other object.
`baseclass`	Class of the underlying data (read-only).
`column_headers`	Pass through to the setas attribute.
`ctypes`	An object to simplify the interaction of the array with the ctypes module.
`data`	Returns the underlying data, as a view of the masked array.
`device`
`dtype`	Data-type of the array's elements.
`fill_value`	The filling value of the masked array is a scalar.
`flags`	Information about the memory layout of the array.
`flat`	Return a flat iterator, or set a flattened version of self to value.
`hardmask`	Specifies whether values can be unmasked through assignments.
`i`	Return the row indices of the DataArray or sets the base index - the row number of the first row.
`imag`	The imaginary part of the masked array.
`isrow`	Define whether this is a single row or a column if 1D.
`itemset`
`itemsize`	Length of one array element in bytes.
`mT`	Return the matrix-transpose of the masked array.
`mask`	Current mask.
`nbytes`	Total bytes consumed by the elements of the array.
`ndim`	Number of array dimensions.
`newbyteorder`
`p`	Calculate the inclination \(\phi\) coordinate for spherical coordinate systems.
`q`	Calculate the azimuthal \(\theta\) coordinate if using spherical or polar coordinates.
`r`	Calculate the radius \(\rho\) coordinate if using spherical or polar coordinate systems.
`real`	The real part of the masked array.
`recordmask`	Get or set the mask of the array if it has no named fields.
`setas`	Return an object for setting column assignments.
`shape`	Tuple of array dimensions.
`sharedmask`	Share status of the mask (read-only).
`size`	Number of elements in the array.
`strides`	Tuple of bytes to step in each dimension when traversing an array.

Methods Summary

`all`([axis, out, keepdims])	Returns True if all elements evaluate to True.
`anom`([axis, dtype])	Compute the anomalies (deviations from the arithmetic mean) along the given axis.
`any`([axis, out, keepdims])	Returns True if any of the elements of a evaluate to True.
`argmax`([axis, fill_value, out, keepdims])	Returns array of indices of the maximum values along the given axis.
`argmin`([axis, fill_value, out, keepdims])	Return array of indices to the minimum values along the given axis.
`argpartition`(kth[, axis, kind, order])	Returns the indices that would partition this array.
`argsort`([axis, kind, order, endwith, ...])	Return an ndarray of indices that sort the array along the specified axis.
`astype`(dtype[, order, casting, subok, copy])	Copy of the array, cast to a specified type.
`byteswap`([inplace])	Swap the bytes of the array elements
`choose`(choices[, out, mode])	Use an index array to construct a new array from a set of choices.
`clip`([min, max, out])	Return an array whose values are limited to `[min, max]`.
`compress`(condition[, axis, out])	Return a where condition is `True`.
`compressed`()	Return all the non-masked data as a 1-D array.
`conj`()	Complex-conjugate all elements.
`conjugate`()	Return the complex conjugate, element-wise.
`copy`([order])	Return a copy of the array.
`count`([axis, keepdims])	Count the non-masked elements of the array along the given axis.
`cumprod`([axis, dtype, out])	Return the cumulative product of the array elements over the given axis.
`cumsum`([axis, dtype, out])	Return the cumulative sum of the array elements over the given axis.
`diagonal`([offset, axis1, axis2])	Return specified diagonals.
`dot`(b[, out])	Masked dot product of two arrays.
`dump`(file)	Dump a pickle of the array to the specified file.
`dumps`()	Returns the pickle of the array as a string.
`fill`(value)	Fill the array with a scalar value.
`filled`([fill_value])	Return a copy of self, with masked values filled with a given value.
`flatten`([order])	Return a copy of the array collapsed into one dimension.
`get_fill_value`()	The filling value of the masked array is a scalar.
`get_imag`()	The imaginary part of the masked array.
`get_real`()	The real part of the masked array.
`getfield`(dtype[, offset])	Returns a field of the given array as a certain type.
`harden_mask`()	Force the mask to hard, preventing unmasking by assignment.
`ids`()	Return the addresses of the data and mask areas.
`iscontiguous`()	Return a boolean indicating whether the data is contiguous.
`item`(*args)	Copy an element of an array to a standard Python scalar and return it.
`keys`()	Return a list of column headers.
`max`([axis, out, fill_value, keepdims])	Return the maximum along a given axis.
`mean`([axis, dtype, out, keepdims])	Returns the average of the array elements along given axis.
`min`([axis, out, fill_value, keepdims])	Return the minimum along a given axis.
`nonzero`()	Return the indices of unmasked elements that are not zero.
`partition`(kth[, axis, kind, order])	Partially sorts the elements in the array in such a way that the value of the element in k-th position is in the position it would be in a sorted array.
`prod`([axis, dtype, out, keepdims])	Return the product of the array elements over the given axis.
`product`([axis, dtype, out, keepdims])	Return the product of the array elements over the given axis.
`ptp`([axis, out, fill_value, keepdims])	Return (maximum - minimum) along the given dimension (i.e. peak-to-peak value).
`put`(indices, values[, mode])	Set storage-indexed locations to corresponding values.
`ravel`([order])	Returns a 1D version of self, as a view.
`repeat`(repeats[, axis])	Repeat elements of an array.
`reshape`(s, *kwargs)	Give a new shape to the array without changing its data.
`resize`(newshape[, refcheck, order])
`round`([decimals, out])	Return each element rounded to the given number of decimals.
`searchsorted`(v[, side, sorter])	Find indices where elements of v should be inserted in a to maintain order.
`set_fill_value`([value])
`setfield`(val, dtype[, offset])	Put a value into a specified place in a field defined by a data-type.
`setflags`([write, align, uic])	Set array flags WRITEABLE, ALIGNED, WRITEBACKIFCOPY, respectively.
`shrink_mask`()	Reduce a mask to nomask when possible.
`soften_mask`()	Force the mask to soft (default), allowing unmasking by assignment.
`sort`([axis, kind, order, endwith, ...])	Sort the array, in-place
`squeeze`([axis])	Remove axes of length one from a.
`std`([axis, dtype, out, ddof, keepdims, mean])	Returns the standard deviation of the array elements along given axis.
`sum`([axis, dtype, out, keepdims])	Return the sum of the array elements over the given axis.
`swap_column`(swp, *kwargs)	Swap pairs of columns in the data.
`swapaxes`(axis1, axis2)	Return a view of the array with axis1 and axis2 interchanged.
`take`(indices[, axis, out, mode])	Take elements from a masked array along an axis.
`to_device`
`tobytes`([fill_value, order])	Return the array data as a string containing the raw bytes in the array.
`tofile`(fid[, sep, format])	Silly pass through.
`toflex`()	Transforms a masked array into a flexible-type array.
`tolist`([fill_value])	Return the data portion of the masked array as a hierarchical Python list.
`torecords`()	Transforms a masked array into a flexible-type array.
`trace`([offset, axis1, axis2, dtype, out])	Return the sum along diagonals of the array.
`transpose`(*axes)	Returns a view of the array with axes transposed.
`unshare_mask`()	Copy the mask and set the sharedmask flag to `False`.
`var`([axis, dtype, out, ddof, keepdims, mean])	Compute the variance along the specified axis.
`view`([dtype, type, fill_value])	Return a view of the MaskedArray data.

Attributes Documentation

T¶

base¶

Base object if memory is from some other object.

Examples¶

The base of an array that owns its memory is None:

>>> import numpy as np
>>> x = np.array([1,2,3,4])
>>> x.base is None
True

Slicing creates a view, whose memory is shared with x:

>>> y = x[2:]
>>> y.base is x
True

baseclass¶: Class of the underlying data (read-only).

column_headers¶: Pass through to the setas attribute.

ctypes¶

An object to simplify the interaction of the array with the ctypes module.

This attribute creates an object that makes it easier to use arrays when calling shared libraries with the ctypes module. The returned object has, among others, data, shape, and strides attributes (see Notes below) which themselves return ctypes objects that can be used as arguments to a shared library.

Parameters¶

None

Returns¶

cPython object: Possessing attributes data, shape, strides, etc.

Notes¶

Below are the public attributes of this object which were documented in “Guide to NumPy” (we have omitted undocumented public attributes, as well as documented private attributes):

_ctypes.data

A pointer to the memory area of the array as a Python integer. This memory area may contain data that is not aligned, or not in correct byte-order. The memory area may not even be writeable. The array flags and data-type of this array should be respected when passing this attribute to arbitrary C-code to avoid trouble that can include Python crashing. User Beware! The value of this attribute is exactly the same as: self._array_interface_['data'][0].

Note that unlike data_as, a reference won’t be kept to the array: code like ctypes.c_void_p((a + b).ctypes.data) will result in a pointer to a deallocated array, and should be spelt (a + b).ctypes.data_as(ctypes.c_void_p)

_ctypes.shape

A ctypes array of length self.ndim where the basetype is the C-integer corresponding to dtype('p') on this platform (see ~numpy.ctypeslib.c_intp). This base-type could be ctypes.c_int, ctypes.c_long, or ctypes.c_longlong depending on the platform. The ctypes array contains the shape of the underlying array.

Type:: (c_intp*self.ndim)

_ctypes.strides

A ctypes array of length self.ndim where the basetype is the same as for the shape attribute. This ctypes array contains the strides information from the underlying array. This strides information is important for showing how many bytes must be jumped to get to the next element in the array.

Type:: (c_intp*self.ndim)

_ctypes.data_as(obj)

Return the data pointer cast to a particular c-types object. For example, calling self._as_parameter_ is equivalent to self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a pointer to a ctypes array of floating-point data: self.data_as(ctypes.POINTER(ctypes.c_double)).

The returned pointer will keep a reference to the array.

_ctypes.shape_as(obj): Return the shape tuple as an array of some other c-types type. For example: self.shape_as(ctypes.c_short).

_ctypes.strides_as(obj): Return the strides tuple as an array of some other c-types type. For example: self.strides_as(ctypes.c_longlong).

If the ctypes module is not available, then the ctypes attribute of array objects still returns something useful, but ctypes objects are not returned and errors may be raised instead. In particular, the object will still have the as_parameter attribute which will return an integer equal to the data attribute.

Examples¶

>>> import numpy as np
>>> import ctypes
>>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
>>> x
array([[0, 1],
       [2, 3]], dtype=int32)
>>> x.ctypes.data
31962608 # may vary
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
<__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
c_uint(0)
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
c_ulong(4294967296)
>>> x.ctypes.shape
<numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
>>> x.ctypes.strides
<numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary

data¶

Returns the underlying data, as a view of the masked array.

If the underlying data is a subclass of numpy.ndarray, it is returned as such.

>>> x = np.ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
>>> x.data
matrix([[1, 2],
        [3, 4]])

The type of the data can be accessed through the baseclass attribute.

device¶

dtype¶

fill_value¶

The filling value of the masked array is a scalar. When setting, None will set to a default based on the data type.

Examples¶

>>> import numpy as np
>>> for dt in [np.int32, np.int64, np.float64, np.complex128]:
...     np.ma.array([0, 1], dtype=dt).get_fill_value()
...
np.int64(999999)
np.int64(999999)
np.float64(1e+20)
np.complex128(1e+20+0j)

>>> x = np.ma.array([0, 1.], fill_value=-np.inf)
>>> x.fill_value
np.float64(-inf)
>>> x.fill_value = np.pi
>>> x.fill_value
np.float64(3.1415926535897931)

Reset to default:

>>> x.fill_value = None
>>> x.fill_value
np.float64(1e+20)

flags¶

Information about the memory layout of the array.

Attributes¶

C_CONTIGUOUS (C): The data is in a single, C-style contiguous segment.
F_CONTIGUOUS (F): The data is in a single, Fortran-style contiguous segment.
OWNDATA (O): The array owns the memory it uses or borrows it from another object.
WRITEABLE (W): The data area can be written to. Setting this to False locks the data, making it read-only. A view (slice, etc.) inherits WRITEABLE from its base array at creation time, but a view of a writeable array may be subsequently locked while the base array remains writeable. (The opposite is not true, in that a view of a locked array may not be made writeable. However, currently, locking a base object does not lock any views that already reference it, so under that circumstance it is possible to alter the contents of a locked array via a previously created writeable view onto it.) Attempting to change a non-writeable array raises a RuntimeError exception.
ALIGNED (A): The data and all elements are aligned appropriately for the hardware.
WRITEBACKIFCOPY (X): This array is a copy of some other array. The C-API function PyArray_ResolveWritebackIfCopy must be called before deallocating to the base array will be updated with the contents of this array.
FNC: F_CONTIGUOUS and not C_CONTIGUOUS.
FORC: F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
BEHAVED (B): ALIGNED and WRITEABLE.
CARRAY (CA): BEHAVED and C_CONTIGUOUS.
FARRAY (FA): BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.

Notes¶

The flags object can be accessed dictionary-like (as in a.flags['WRITEABLE']), or by using lowercased attribute names (as in a.flags.writeable). Short flag names are only supported in dictionary access.

Only the WRITEBACKIFCOPY, WRITEABLE, and ALIGNED flags can be changed by the user, via direct assignment to the attribute or dictionary entry, or by calling ndarray.setflags.

The array flags cannot be set arbitrarily:

WRITEBACKIFCOPY can only be set False.
ALIGNED can only be set True if the data is truly aligned.
WRITEABLE can only be set True if the array owns its own memory or the ultimate owner of the memory exposes a writeable buffer interface or is a string.

Arrays can be both C-style and Fortran-style contiguous simultaneously. This is clear for 1-dimensional arrays, but can also be true for higher dimensional arrays.

Even for contiguous arrays a stride for a given dimension arr.strides[dim] may be arbitrary if arr.shape[dim] == 1 or the array has no elements. It does not generally hold that self.strides[-1] == self.itemsize for C-style contiguous arrays or self.strides[0] == self.itemsize for Fortran-style contiguous arrays is true.

flat¶: Return a flat iterator, or set a flattened version of self to value.

hardmask¶

Specifies whether values can be unmasked through assignments.

By default, assigning definite values to masked array entries will unmask them. When hardmask is True, the mask will not change through assignments.

Examples¶

>>> import numpy as np
>>> x = np.arange(10)
>>> m = np.ma.masked_array(x, x>5)
>>> assert not m.hardmask

Since m has a soft mask, assigning an element value unmasks that element:

>>> m[8] = 42
>>> m
masked_array(data=[0, 1, 2, 3, 4, 5, --, --, 42, --],
             mask=[False, False, False, False, False, False,
                   True, True, False, True],
       fill_value=999999)

After hardening, the mask is not affected by assignments:

>>> hardened = np.ma.harden_mask(m)
>>> assert m.hardmask and hardened is m
>>> m[:] = 23
>>> m
masked_array(data=[23, 23, 23, 23, 23, 23, --, --, 23, --],
             mask=[False, False, False, False, False, False,
                   True, True, False, True],
       fill_value=999999)

i¶: Return the row indices of the DataArray or sets the base index - the row number of the first row.

imag¶

The imaginary part of the masked array.

This property is a view on the imaginary part of this MaskedArray.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False])
>>> x.imag
masked_array(data=[1.0, --, 1.6],
             mask=[False,  True, False],
       fill_value=1e+20)

isrow¶: Define whether this is a single row or a column if 1D.

itemset¶

itemsize¶

Length of one array element in bytes.

Examples¶

>>> import numpy as np
>>> x = np.array([1,2,3], dtype=np.float64)
>>> x.itemsize
8
>>> x = np.array([1,2,3], dtype=np.complex128)
>>> x.itemsize
16

mT¶

Return the matrix-transpose of the masked array.

The matrix transpose is the transpose of the last two dimensions, even if the array is of higher dimension.

Added in version 2.0.

Returns¶

result: MaskedArray: The masked array with the last two dimensions transposed

Raises¶

ValueError: If the array is of dimension less than 2.

Notes¶

Does not include memory consumed by non-element attributes of the array object.

Examples¶

>>> import numpy as np
>>> x = np.zeros((3,5,2), dtype=np.complex128)
>>> x.nbytes
480
>>> np.prod(x.shape) * x.itemsize
480

ndim¶

Number of array dimensions.

Examples¶

>>> import numpy as np
>>> x = np.array([1, 2, 3])
>>> x.ndim
1
>>> y = np.zeros((2, 3, 4))
>>> y.ndim
3

newbyteorder¶

p¶: Calculate the inclination \(\phi\) coordinate for spherical coordinate systems.

q¶: Calculate the azimuthal \(\theta\) coordinate if using spherical or polar coordinates.

r¶: Calculate the radius \(\rho\) coordinate if using spherical or polar coordinate systems.

real¶

The real part of the masked array.

This property is a view on the real part of this MaskedArray.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False])
>>> x.real
masked_array(data=[1.0, --, 3.45],
             mask=[False,  True, False],
       fill_value=1e+20)

recordmask¶

Get or set the mask of the array if it has no named fields. For structured arrays, returns a ndarray of booleans where entries are True if all the fields are masked, False otherwise:

>>> x = np.ma.array([(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)],
...         mask=[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)],
...        dtype=[('a', int), ('b', int)])
>>> x.recordmask
array([False, False,  True, False, False])

setas¶: Return an object for setting column assignments.

shape¶

sharedmask¶: Share status of the mask (read-only).

size¶

Number of elements in the array.

Equal to np.prod(a.shape), i.e., the product of the array’s dimensions.

Notes¶

a.size returns a standard arbitrary precision Python integer. This may not be the case with other methods of obtaining the same value (like the suggested np.prod(a.shape), which returns an instance of np.int_), and may be relevant if the value is used further in calculations that may overflow a fixed size integer type.

Examples¶

>>> import numpy as np
>>> x = np.zeros((3, 5, 2), dtype=np.complex128)
>>> x.size
30
>>> np.prod(x.shape)
30

strides¶

Tuple of bytes to step in each dimension when traversing an array.

The byte offset of element (i[0], i[1], ..., i[n]) in an array a is:

offset = sum(np.array(i) * a.strides)

A more detailed explanation of strides can be found in The N-dimensional array (ndarray).

Warning

Setting arr.strides is discouraged and may be deprecated in the future. numpy.lib.stride_tricks.as_strided should be preferred to create a new view of the same data in a safer way.

Notes¶

Imagine an array of 32-bit integers (each 4 bytes):

x = np.array([[0, 1, 2, 3, 4],
              [5, 6, 7, 8, 9]], dtype=np.int32)

This array is stored in memory as 40 bytes, one after the other (known as a contiguous block of memory). The strides of an array tell us how many bytes we have to skip in memory to move to the next position along a certain axis. For example, we have to skip 4 bytes (1 value) to move to the next column, but 20 bytes (5 values) to get to the same position in the next row. As such, the strides for the array x will be (20, 4).

Examples¶

>>> import numpy as np
>>> y = np.reshape(np.arange(2 * 3 * 4, dtype=np.int32), (2, 3, 4))
>>> y
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],
       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]], dtype=np.int32)
>>> y.strides
(48, 16, 4)
>>> y[1, 1, 1]
np.int32(17)
>>> offset = sum(y.strides * np.array((1, 1, 1)))
>>> offset // y.itemsize
np.int64(17)

>>> x = np.reshape(np.arange(5*6*7*8, dtype=np.int32), (5, 6, 7, 8))
>>> x = x.transpose(2, 3, 1, 0)
>>> x.strides
(32, 4, 224, 1344)
>>> i = np.array([3, 5, 2, 2], dtype=np.int32)
>>> offset = sum(i * x.strides)
>>> x[3, 5, 2, 2]
np.int32(813)
>>> offset // x.itemsize
np.int64(813)

Methods Documentation

all(axis=None, out=None, keepdims=<no value>)¶

Returns True if all elements evaluate to True.

The output array is masked where all the values along the given axis are masked: if the output would have been a scalar and that all the values are masked, then the output is masked.

Refer to numpy.all for full documentation.

Examples¶

>>> import numpy as np
>>> np.ma.array([1,2,3]).all()
True
>>> a = np.ma.array([1,2,3], mask=True)
>>> (a.all() is np.ma.masked)
True

anom(axis=None, dtype=None)¶

Compute the anomalies (deviations from the arithmetic mean) along the given axis.

Returns an array of anomalies, with the same shape as the input and where the arithmetic mean is computed along the given axis.

Parameters¶

axisint, optional

Axis over which the anomalies are taken. The default is to use the mean of the flattened array as reference.

dtypedtype, optional

Type to use in computing the variance. For arrays of integer type: the default is float32; for arrays of float types it is the same as the array type.

Examples¶

>>> import numpy as np
>>> a = np.ma.array([1,2,3])
>>> a.anom()
masked_array(data=[-1.,  0.,  1.],
             mask=False,
       fill_value=1e+20)

any(axis=None, out=None, keepdims=<no value>)¶

Returns True if any of the elements of a evaluate to True.

Masked values are considered as False during computation.

Refer to numpy.any for full documentation.

Parameters¶

axis{None, integer}: If None, the index is into the flattened array, otherwise along the specified axis
fill_valuescalar or None, optional: Value used to fill in the masked values. If None, the output of maximum_fill_value(self._data) is used instead.
out{None, array}, optional: Array into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output.

Returns¶

index_array : {integer_array}

Examples¶

>>> import numpy as np
>>> a = np.arange(6).reshape(2,3)
>>> a.argmax()
5
>>> a.argmax(0)
array([1, 1, 1])
>>> a.argmax(1)
array([2, 2])

argmin(axis=None, fill_value=None, out=None, *, keepdims=<no value>)¶

Return array of indices to the minimum values along the given axis.

Parameters¶

axis{None, integer}: If None, the index is into the flattened array, otherwise along the specified axis
fill_valuescalar or None, optional: Value used to fill in the masked values. If None, the output of minimum_fill_value(self._data) is used instead.
out{None, array}, optional: Array into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output.

Returns¶

ndarray or scalar: If multi-dimension input, returns a new ndarray of indices to the minimum values along the given axis. Otherwise, returns a scalar of index to the minimum values along the given axis.

Examples¶

>>> import numpy as np
>>> x = np.ma.array(np.arange(4), mask=[1,1,0,0])
>>> x.shape = (2,2)
>>> x
masked_array(
  data=[[--, --],
        [2, 3]],
  mask=[[ True,  True],
        [False, False]],
  fill_value=999999)
>>> x.argmin(axis=0, fill_value=-1)
array([0, 0])
>>> x.argmin(axis=0, fill_value=9)
array([1, 1])

argpartition(kth, axis=-1, kind='introselect', order=None)¶

Returns the indices that would partition this array.

Refer to numpy.argpartition for full documentation.

Parameters¶

axisint, optional: Axis along which to sort. If None, the default, the flattened array is used.
kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, optional: The sorting algorithm used.
orderlist, optional: When a is an array with fields defined, this argument specifies which fields to compare first, second, etc. Not all fields need be specified.
endwith{True, False}, optional: Whether missing values (if any) should be treated as the largest values (True) or the smallest values (False) When the array contains unmasked values at the same extremes of the datatype, the ordering of these values and the masked values is undefined.
fill_valuescalar or None, optional: Value used internally for the masked values. If fill_value is not None, it supersedes endwith.
stablebool, optional: Only for compatibility with np.argsort. Ignored.

Returns¶

index_arrayndarray, int: Array of indices that sort a along the specified axis. In other words, a[index_array] yields a sorted a.

Notes¶

See sort for notes on the different sorting algorithms.

Examples¶

>>> import numpy as np
>>> a = np.ma.array([3,2,1], mask=[False, False, True])
>>> a
masked_array(data=[3, 2, --],
             mask=[False, False,  True],
       fill_value=999999)
>>> a.argsort()
array([1, 0, 2])

astype(dtype, order='K', casting='unsafe', subok=True, copy=True)¶

Copy of the array, cast to a specified type.

Parameters¶

dtypestr or dtype

Typecode or data-type to which the array is cast.

order{‘C’, ‘F’, ‘A’, ‘K’}, optional

Controls the memory layout order of the result. ‘C’ means C order, ‘F’ means Fortran order, ‘A’ means ‘F’ order if all the arrays are Fortran contiguous, ‘C’ order otherwise, and ‘K’ means as close to the order the array elements appear in memory as possible. Default is ‘K’.

casting{‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional

Controls what kind of data casting may occur. Defaults to ‘unsafe’ for backwards compatibility.

‘no’ means the data types should not be cast at all.
‘equiv’ means only byte-order changes are allowed.
‘safe’ means only casts which can preserve values are allowed.
‘same_kind’ means only safe casts or casts within a kind, like float64 to float32, are allowed.
‘unsafe’ means any data conversions may be done.

subokbool, optional

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

copybool, optional

By default, astype always returns a newly allocated array. If this is set to false, and the dtype, order, and subok requirements are satisfied, the input array is returned instead of a copy.

Returns¶

arr_tndarray: Unless copy is False and the other conditions for returning the input array are satisfied (see description for copy input parameter), arr_t is a new array of the same shape as the input array, with dtype, order given by dtype, order.

Raises¶

ComplexWarning: When casting from complex to float or int. To avoid this, one should use a.real.astype(t).

Examples¶

>>> import numpy as np
>>> x = np.array([1, 2, 2.5])
>>> x
array([1. ,  2. ,  2.5])

>>> x.astype(int)
array([1, 2, 2])

byteswap(inplace=False)¶

Swap the bytes of the array elements

Toggle between low-endian and big-endian data representation by returning a byteswapped array, optionally swapped in-place. Arrays of byte-strings are not swapped. The real and imaginary parts of a complex number are swapped individually.

Parameters¶

inplacebool, optional: If True, swap bytes in-place, default is False.

Returns¶

outndarray: The byteswapped array. If inplace is True, this is a view to self.

Examples¶

>>> import numpy as np
>>> A = np.array([1, 256, 8755], dtype=np.int16)
>>> list(map(hex, A))
['0x1', '0x100', '0x2233']
>>> A.byteswap(inplace=True)
array([  256,     1, 13090], dtype=int16)
>>> list(map(hex, A))
['0x100', '0x1', '0x3322']

Arrays of byte-strings are not swapped

>>> A = np.array([b'ceg', b'fac'])
>>> A.byteswap()
array([b'ceg', b'fac'], dtype='|S3')

A.view(A.dtype.newbyteorder()).byteswap() produces an array with the same values but different representation in memory

>>> A = np.array([1, 2, 3],dtype=np.int64)
>>> A.view(np.uint8)
array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
       0, 0], dtype=uint8)
>>> A.view(A.dtype.newbyteorder()).byteswap(inplace=True)
array([1, 2, 3], dtype='>i8')
>>> A.view(np.uint8)
array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
       0, 3], dtype=uint8)

choose(choices, out=None, mode='raise')¶

Use an index array to construct a new array from a set of choices.

Refer to numpy.choose for full documentation.

Parameters¶

conditionvar: Boolean 1-d array selecting which entries to return. If len(condition) is less than the size of a along the axis, then output is truncated to length of condition array.
axis{None, int}, optional: Axis along which the operation must be performed.
out{None, ndarray}, optional: Alternative output array in which to place the result. It must have the same shape as the expected output but the type will be cast if necessary.

Returns¶

resultMaskedArray: A MaskedArray object.

Notes¶

Please note the difference with compressed() ! The output of compress() has a mask, the output of compressed() does not.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
  data=[[1, --, 3],
        [--, 5, --],
        [7, --, 9]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=999999)
>>> x.compress([1, 0, 1])
masked_array(data=[1, 3],
             mask=[False, False],
       fill_value=999999)

>>> x.compress([1, 0, 1], axis=1)
masked_array(
  data=[[1, 3],
        [--, --],
        [7, 9]],
  mask=[[False, False],
        [ True,  True],
        [False, False]],
  fill_value=999999)

compressed()¶

Return all the non-masked data as a 1-D array.

Returns¶

datandarray: A new ndarray holding the non-masked data is returned.

Notes¶

The result is not a MaskedArray!

Examples¶

>>> import numpy as np
>>> x = np.ma.array(np.arange(5), mask=[0]*2 + [1]*3)
>>> x.compressed()
array([0, 1])
>>> type(x.compressed())
<class 'numpy.ndarray'>

N-D arrays are compressed to 1-D.

>>> arr = [[1, 2], [3, 4]]
>>> mask = [[1, 0], [0, 1]]
>>> x = np.ma.array(arr, mask=mask)
>>> x.compressed()
array([2, 3])

conj()¶

Complex-conjugate all elements.

Refer to numpy.conjugate for full documentation.

Parameters¶

order{‘C’, ‘F’, ‘A’, ‘K’}, optional: Controls the memory layout of the copy. ‘C’ means C-order, ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous, ‘C’ otherwise. ‘K’ means match the layout of a as closely as possible. (Note that this function and numpy.copy() are very similar but have different default values for their order= arguments, and this function always passes sub-classes through.)

Notes¶

This function is the preferred method for creating an array copy. The function numpy.copy() is similar, but it defaults to using order ‘K’, and will not pass sub-classes through by default.

Examples¶

>>> import numpy as np
>>> x = np.array([[1,2,3],[4,5,6]], order='F')

>>> y = x.copy()

>>> x.fill(0)

>>> x
array([[0, 0, 0],
       [0, 0, 0]])

>>> y
array([[1, 2, 3],
       [4, 5, 6]])

>>> y.flags['C_CONTIGUOUS']
True

For arrays containing Python objects (e.g. dtype=object), the copy is a shallow one. The new array will contain the same object which may lead to surprises if that object can be modified (is mutable):

>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
>>> b = a.copy()
>>> b[2][0] = 10
>>> a
array([1, 'm', list([10, 3, 4])], dtype=object)

To ensure all elements within an object array are copied, use copy.deepcopy:

>>> import copy
>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
>>> c = copy.deepcopy(a)
>>> c[2][0] = 10
>>> c
array([1, 'm', list([10, 3, 4])], dtype=object)
>>> a
array([1, 'm', list([2, 3, 4])], dtype=object)

count(axis=None, keepdims=<no value>)¶

Count the non-masked elements of the array along the given axis.

Parameters¶

axisNone or int or tuple of ints, optional: Axis or axes along which the count is performed. The default, None, performs the count over all the dimensions of the input array. axis may be negative, in which case it counts from the last to the first axis. If this is a tuple of ints, the count is performed on multiple axes, instead of a single axis or all the axes as before.
keepdimsbool, optional: If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the array.

Returns¶

resultndarray or scalar: An array with the same shape as the input array, with the specified axis removed. If the array is a 0-d array, or if axis is None, a scalar is returned.

Examples¶

>>> import numpy.ma as ma
>>> a = ma.arange(6).reshape((2, 3))
>>> a[1, :] = ma.masked
>>> a
masked_array(
  data=[[0, 1, 2],
        [--, --, --]],
  mask=[[False, False, False],
        [ True,  True,  True]],
  fill_value=999999)
>>> a.count()
3

When the axis keyword is specified an array of appropriate size is returned.

>>> a.count(axis=0)
array([1, 1, 1])
>>> a.count(axis=1)
array([3, 0])

cumprod(axis=None, dtype=None, out=None)¶

Return the cumulative product of the array elements over the given axis.

Masked values are set to 1 internally during the computation. However, their position is saved, and the result will be masked at the same locations.

Refer to numpy.cumprod for full documentation.

Notes¶

The mask is lost if out is not a valid MaskedArray !

Arithmetic is modular when using integer types, and no error is raised on overflow.

Notes¶

The mask is lost if out is not a valid ma.MaskedArray !

Arithmetic is modular when using integer types, and no error is raised on overflow.

Examples¶

>>> import numpy as np
>>> marr = np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0])
>>> marr.cumsum()
masked_array(data=[0, 1, 3, --, --, --, 9, 16, 24, 33],
             mask=[False, False, False,  True,  True,  True, False, False,
                   False, False],
       fill_value=999999)

diagonal(offset=0, axis1=0, axis2=1)¶

Return specified diagonals. In NumPy 1.9 the returned array is a read-only view instead of a copy as in previous NumPy versions. In a future version the read-only restriction will be removed.

Refer to numpy.diagonal() for full documentation.

Parameters¶

bmasked_array_like: Inputs array.
outmasked_array, optional: Output argument. This must have the exact kind that would be returned if it was not used. In particular, it must have the right type, must be C-contiguous, and its dtype must be the dtype that would be returned for ma.dot(a,b). This is a performance feature. Therefore, if these conditions are not met, an exception is raised, instead of attempting to be flexible.
strictbool, optional: Whether masked data are propagated (True) or set to 0 (False) for the computation. Default is False. Propagating the mask means that if a masked value appears in a row or column, the whole row or column is considered masked.

Parameters¶

filestr or Path: A string naming the dump file.

dumps()¶: Returns the pickle of the array as a string. pickle.loads will convert the string back to an array.

Parameters¶

None

fill(value)¶

Fill the array with a scalar value.

Parameters¶

valuescalar: All elements of a will be assigned this value.

Examples¶

>>> import numpy as np
>>> a = np.array([1, 2])
>>> a.fill(0)
>>> a
array([0, 0])
>>> a = np.empty(2)
>>> a.fill(1)
>>> a
array([1.,  1.])

Fill expects a scalar value and always behaves the same as assigning to a single array element. The following is a rare example where this distinction is important:

>>> a = np.array([None, None], dtype=object)
>>> a[0] = np.array(3)
>>> a
array([array(3), None], dtype=object)
>>> a.fill(np.array(3))
>>> a
array([array(3), array(3)], dtype=object)

Where other forms of assignments will unpack the array being assigned:

>>> a[...] = np.array(3)
>>> a
array([3, 3], dtype=object)

filled(fill_value=None)¶

Return a copy of self, with masked values filled with a given value. However, if there are no masked values to fill, self will be returned instead as an ndarray.

Parameters¶

fill_valuearray_like, optional: The value to use for invalid entries. Can be scalar or non-scalar. If non-scalar, the resulting ndarray must be broadcastable over input array. Default is None, in which case, the fill_value attribute of the array is used instead.

Returns¶

filled_arrayndarray: A copy of self with invalid entries replaced by fill_value (be it the function argument or the attribute of self), or self itself as an ndarray if there are no invalid entries to be replaced.

Notes¶

The result is not a MaskedArray!

Examples¶

>>> import numpy as np
>>> x = np.ma.array([1,2,3,4,5], mask=[0,0,1,0,1], fill_value=-999)
>>> x.filled()
array([   1,    2, -999,    4, -999])
>>> x.filled(fill_value=1000)
array([   1,    2, 1000,    4, 1000])
>>> type(x.filled())
<class 'numpy.ndarray'>

Subclassing is preserved. This means that if, e.g., the data part of the masked array is a recarray, filled returns a recarray:

>>> x = np.array([(-1, 2), (-3, 4)], dtype='i8,i8').view(np.recarray)
>>> m = np.ma.array(x, mask=[(True, False), (False, True)])
>>> m.filled()
rec.array([(999999,      2), (    -3, 999999)],
          dtype=[('f0', '<i8'), ('f1', '<i8')])

flatten(order='C')¶

Return a copy of the array collapsed into one dimension.

Parameters¶

order{‘C’, ‘F’, ‘A’, ‘K’}, optional: ‘C’ means to flatten in row-major (C-style) order. ‘F’ means to flatten in column-major (Fortran- style) order. ‘A’ means to flatten in column-major order if a is Fortran contiguous in memory, row-major order otherwise. ‘K’ means to flatten a in the order the elements occur in memory. The default is ‘C’.

Returns¶

yndarray: A copy of the input array, flattened to one dimension.

Examples¶

>>> import numpy as np
>>> a = np.array([[1,2], [3,4]])
>>> a.flatten()
array([1, 2, 3, 4])
>>> a.flatten('F')
array([1, 3, 2, 4])

get_fill_value()¶

The filling value of the masked array is a scalar. When setting, None will set to a default based on the data type.

Examples¶

>>> import numpy as np
>>> for dt in [np.int32, np.int64, np.float64, np.complex128]:
...     np.ma.array([0, 1], dtype=dt).get_fill_value()
...
np.int64(999999)
np.int64(999999)
np.float64(1e+20)
np.complex128(1e+20+0j)

>>> x = np.ma.array([0, 1.], fill_value=-np.inf)
>>> x.fill_value
np.float64(-inf)
>>> x.fill_value = np.pi
>>> x.fill_value
np.float64(3.1415926535897931)

Reset to default:

>>> x.fill_value = None
>>> x.fill_value
np.float64(1e+20)

get_imag()¶

The imaginary part of the masked array.

This property is a view on the imaginary part of this MaskedArray.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False])
>>> x.imag
masked_array(data=[1.0, --, 1.6],
             mask=[False,  True, False],
       fill_value=1e+20)

get_real()¶

The real part of the masked array.

This property is a view on the real part of this MaskedArray.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False])
>>> x.real
masked_array(data=[1.0, --, 3.45],
             mask=[False,  True, False],
       fill_value=1e+20)

getfield(dtype, offset=0)¶

Returns a field of the given array as a certain type.

A field is a view of the array data with a given data-type. The values in the view are determined by the given type and the offset into the current array in bytes. The offset needs to be such that the view dtype fits in the array dtype; for example an array of dtype complex128 has 16-byte elements. If taking a view with a 32-bit integer (4 bytes), the offset needs to be between 0 and 12 bytes.

Parameters¶

dtypestr or dtype: The data type of the view. The dtype size of the view can not be larger than that of the array itself.
offsetint: Number of bytes to skip before beginning the element view.

Examples¶

>>> import numpy as np
>>> x = np.diag([1.+1.j]*2)
>>> x[1, 1] = 2 + 4.j
>>> x
array([[1.+1.j,  0.+0.j],
       [0.+0.j,  2.+4.j]])
>>> x.getfield(np.float64)
array([[1.,  0.],
       [0.,  2.]])

By choosing an offset of 8 bytes we can select the complex part of the array for our view:

>>> x.getfield(np.float64, offset=8)
array([[1.,  0.],
       [0.,  4.]])

harden_mask()¶

Force the mask to hard, preventing unmasking by assignment.

Whether the mask of a masked array is hard or soft is determined by its ~ma.MaskedArray.hardmask property. harden_mask sets ~ma.MaskedArray.hardmask to True (and returns the modified self).

Parameters¶

None

Examples¶

>>> import numpy as np
>>> x = np.ma.array([1, 2, 3], mask=[0, 1, 1])
>>> x.ids()
(166670640, 166659832) # may vary

If the array has no mask, the address of nomask is returned. This address is typically not close to the data in memory:

>>> x = np.ma.array([1, 2, 3])
>>> x.ids()
(166691080, 3083169284) # may vary

iscontiguous()¶

Return a boolean indicating whether the data is contiguous.

Parameters¶

None

Examples¶

>>> import numpy as np
>>> x = np.ma.array([1, 2, 3])
>>> x.iscontiguous()
True

iscontiguous returns one of the flags of the masked array:

>>> x.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False

item(*args)¶

Copy an element of an array to a standard Python scalar and return it.

Parameters¶

*args : Arguments (variable number and type)

none: in this case, the method only works for arrays with one element (a.size == 1), which element is copied into a standard Python scalar object and returned.

int_type: this argument is interpreted as a flat index into the array, specifying which element to copy and return.

tuple of int_types: functions as does a single int_type argument, except that the argument is interpreted as an nd-index into the array.

Returns¶

zStandard Python scalar object: A copy of the specified element of the array as a suitable Python scalar

Notes¶

When the data type of a is longdouble or clongdouble, item() returns a scalar array object because there is no available Python scalar that would not lose information. Void arrays return a buffer object for item(), unless fields are defined, in which case a tuple is returned.

item is very similar to a[args], except, instead of an array scalar, a standard Python scalar is returned. This can be useful for speeding up access to elements of the array and doing arithmetic on elements of the array using Python’s optimized math.

Examples¶

>>> import numpy as np
>>> np.random.seed(123)
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[2, 2, 6],
       [1, 3, 6],
       [1, 0, 1]])
>>> x.item(3)
1
>>> x.item(7)
0
>>> x.item((0, 1))
2
>>> x.item((2, 2))
1

For an array with object dtype, elements are returned as-is.

>>> a = np.array([np.int64(1)], dtype=object)
>>> a.item() #return np.int64
np.int64(1)

keys()[source]¶: Return a list of column headers.

max(axis=None, out=None, fill_value=None, keepdims=<no value>)¶

Return the maximum along a given axis.

Parameters¶

axisNone or int or tuple of ints, optional: Axis along which to operate. By default, axis is None and the flattened input is used. If this is a tuple of ints, the maximum is selected over multiple axes, instead of a single axis or all the axes as before.
outarray_like, optional: Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output.
fill_valuescalar or None, optional: Value used to fill in the masked values. If None, use the output of maximum_fill_value().
keepdimsbool, optional: If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the array.

Returns¶

amaxarray_like: New array holding the result. If out was specified, out is returned.

Examples¶

>>> import numpy.ma as ma
>>> x = [[-1., 2.5], [4., -2.], [3., 0.]]
>>> mask = [[0, 0], [1, 0], [1, 0]]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(
  data=[[-1.0, 2.5],
        [--, -2.0],
        [--, 0.0]],
  mask=[[False, False],
        [ True, False],
        [ True, False]],
  fill_value=1e+20)
>>> ma.max(masked_x)
2.5
>>> ma.max(masked_x, axis=0)
masked_array(data=[-1.0, 2.5],
             mask=[False, False],
       fill_value=1e+20)
>>> ma.max(masked_x, axis=1, keepdims=True)
masked_array(
  data=[[2.5],
        [-2.0],
        [0.0]],
  mask=[[False],
        [False],
        [False]],
  fill_value=1e+20)
>>> mask = [[1, 1], [1, 1], [1, 1]]
>>> masked_x = ma.masked_array(x, mask)
>>> ma.max(masked_x, axis=1)
masked_array(data=[--, --, --],
             mask=[ True,  True,  True],
       fill_value=1e+20,
            dtype=float64)

mean(axis=None, dtype=None, out=None, keepdims=<no value>)¶

Returns the average of the array elements along given axis.

Masked entries are ignored, and result elements which are not finite will be masked.

Refer to numpy.mean for full documentation.

Examples¶

>>> import numpy as np
>>> a = np.ma.array([1,2,3], mask=[False, False, True])
>>> a
masked_array(data=[1, 2, --],
             mask=[False, False,  True],
       fill_value=999999)
>>> a.mean()
1.5

min(axis=None, out=None, fill_value=None, keepdims=<no value>)¶

Return the minimum along a given axis.

Parameters¶

axisNone or int or tuple of ints, optional: Axis along which to operate. By default, axis is None and the flattened input is used. If this is a tuple of ints, the minimum is selected over multiple axes, instead of a single axis or all the axes as before.
outarray_like, optional: Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output.
fill_valuescalar or None, optional: Value used to fill in the masked values. If None, use the output of minimum_fill_value.
keepdimsbool, optional: If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the array.

Returns¶

aminarray_like: New array holding the result. If out was specified, out is returned.

Examples¶

>>> import numpy.ma as ma
>>> x = [[1., -2., 3.], [0.2, -0.7, 0.1]]
>>> mask = [[1, 1, 0], [0, 0, 1]]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(
  data=[[--, --, 3.0],
        [0.2, -0.7, --]],
  mask=[[ True,  True, False],
        [False, False,  True]],
  fill_value=1e+20)
>>> ma.min(masked_x)
-0.7
>>> ma.min(masked_x, axis=-1)
masked_array(data=[3.0, -0.7],
             mask=[False, False],
        fill_value=1e+20)
>>> ma.min(masked_x, axis=0, keepdims=True)
masked_array(data=[[0.2, -0.7, 3.0]],
             mask=[[False, False, False]],
        fill_value=1e+20)
>>> mask = [[1, 1, 1,], [1, 1, 1]]
>>> masked_x = ma.masked_array(x, mask)
>>> ma.min(masked_x, axis=0)
masked_array(data=[--, --, --],
             mask=[ True,  True,  True],
        fill_value=1e+20,
            dtype=float64)

nonzero()¶

Return the indices of unmasked elements that are not zero.

Returns a tuple of arrays, one for each dimension, containing the indices of the non-zero elements in that dimension. The corresponding non-zero values can be obtained with:

a[a.nonzero()]

To group the indices by element, rather than dimension, use instead:

np.transpose(a.nonzero())

The result of this is always a 2d array, with a row for each non-zero element.

Parameters¶

None

Returns¶

tuple_of_arraystuple: Indices of elements that are non-zero.

Examples¶

>>> import numpy as np
>>> import numpy.ma as ma
>>> x = ma.array(np.eye(3))
>>> x
masked_array(
  data=[[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]],
  mask=False,
  fill_value=1e+20)
>>> x.nonzero()
(array([0, 1, 2]), array([0, 1, 2]))

Masked elements are ignored.

>>> x[1, 1] = ma.masked
>>> x
masked_array(
  data=[[1.0, 0.0, 0.0],
        [0.0, --, 0.0],
        [0.0, 0.0, 1.0]],
  mask=[[False, False, False],
        [False,  True, False],
        [False, False, False]],
  fill_value=1e+20)
>>> x.nonzero()
(array([0, 2]), array([0, 2]))

Indices can also be grouped by element.

>>> np.transpose(x.nonzero())
array([[0, 0],
       [2, 2]])

A common use for nonzero is to find the indices of an array, where a condition is True. Given an array a, the condition a > 3 is a boolean array and since False is interpreted as 0, ma.nonzero(a > 3) yields the indices of the a where the condition is true.

>>> a = ma.array([[1,2,3],[4,5,6],[7,8,9]])
>>> a > 3
masked_array(
  data=[[False, False, False],
        [ True,  True,  True],
        [ True,  True,  True]],
  mask=False,
  fill_value=True)
>>> ma.nonzero(a > 3)
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))

The nonzero method of the condition array can also be called.

>>> (a > 3).nonzero()
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))

partition(kth, axis=-1, kind='introselect', order=None)¶

Partially sorts the elements in the array in such a way that the value of the element in k-th position is in the position it would be in a sorted array. In the output array, all elements smaller than the k-th element are located to the left of this element and all equal or greater are located to its right. The ordering of the elements in the two partitions on the either side of the k-th element in the output array is undefined.

Parameters¶

kthint or sequence of ints: Element index to partition by. The kth element value will be in its final sorted position and all smaller elements will be moved before it and all equal or greater elements behind it. The order of all elements in the partitions is undefined. If provided with a sequence of kth it will partition all elements indexed by kth of them into their sorted position at once.

Deprecated since version 1.22.0: Passing booleans as index is deprecated.
axisint, optional: Axis along which to sort. Default is -1, which means sort along the last axis.
kind{‘introselect’}, optional: Selection algorithm. Default is ‘introselect’.
orderstr or list of str, optional: When a is an array with fields defined, this argument specifies which fields to compare first, second, etc. A single field can be specified as a string, and not all fields need to be specified, but unspecified fields will still be used, in the order in which they come up in the dtype, to break ties.

Notes¶

See np.partition for notes on the different algorithms.

Examples¶

>>> import numpy as np
>>> a = np.array([3, 4, 2, 1])
>>> a.partition(3)
>>> a
array([2, 1, 3, 4]) # may vary

>>> a.partition((1, 3))
>>> a
array([1, 2, 3, 4])

prod(axis=None, dtype=None, out=None, keepdims=<no value>)¶

Return the product of the array elements over the given axis.

Masked elements are set to 1 internally for computation.

Refer to numpy.prod for full documentation.

Notes¶

Arithmetic is modular when using integer types, and no error is raised on overflow.

Notes¶

Arithmetic is modular when using integer types, and no error is raised on overflow.

Parameters¶

axis{None, int}, optional: Axis along which to find the peaks. If None (default) the flattened array is used.
out{None, array_like}, optional: Alternative output array in which to place the result. It must have the same shape and buffer length as the expected output but the type will be cast if necessary.
fill_valuescalar or None, optional: Value used to fill in the masked values.
keepdimsbool, optional: If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the array.

Returns¶

ptpndarray.: A new array holding the result, unless out was specified, in which case a reference to out is returned.

Examples¶

>>> import numpy as np
>>> x = np.ma.MaskedArray([[4, 9, 2, 10],
...                        [6, 9, 7, 12]])

>>> x.ptp(axis=1)
masked_array(data=[8, 6],
             mask=False,
       fill_value=999999)

>>> x.ptp(axis=0)
masked_array(data=[2, 0, 5, 2],
             mask=False,
       fill_value=999999)

>>> x.ptp()
10

This example shows that a negative value can be returned when the input is an array of signed integers.

>>> y = np.ma.MaskedArray([[1, 127],
...                        [0, 127],
...                        [-1, 127],
...                        [-2, 127]], dtype=np.int8)
>>> y.ptp(axis=1)
masked_array(data=[ 126,  127, -128, -127],
             mask=False,
       fill_value=np.int64(999999),
            dtype=int8)

A work-around is to use the view() method to view the result as unsigned integers with the same bit width:

>>> y.ptp(axis=1).view(np.uint8)
masked_array(data=[126, 127, 128, 129],
             mask=False,
       fill_value=np.uint64(999999),
            dtype=uint8)

put(indices, values, mode='raise')¶

Set storage-indexed locations to corresponding values.

Sets self._data.flat[n] = values[n] for each n in indices. If values is shorter than indices then it will repeat. If values has some masked values, the initial mask is updated in consequence, else the corresponding values are unmasked.

Parameters¶

indices1-D array_like: Target indices, interpreted as integers.
valuesarray_like: Values to place in self._data copy at target indices.
mode{‘raise’, ‘wrap’, ‘clip’}, optional: Specifies how out-of-bounds indices will behave. ‘raise’ : raise an error. ‘wrap’ : wrap around. ‘clip’ : clip to the range.

Notes¶

values can be a scalar or length 1 array.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
  data=[[1, --, 3],
        [--, 5, --],
        [7, --, 9]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=999999)
>>> x.put([0,4,8],[10,20,30])
>>> x
masked_array(
  data=[[10, --, 3],
        [--, 20, --],
        [7, --, 30]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=999999)

>>> x.put(4,999)
>>> x
masked_array(
  data=[[10, --, 3],
        [--, 999, --],
        [7, --, 30]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=999999)

ravel(order='C')¶

Returns a 1D version of self, as a view.

Parameters¶

order{‘C’, ‘F’, ‘A’, ‘K’}, optional: The elements of a are read using this index order. ‘C’ means to index the elements in C-like order, with the last axis index changing fastest, back to the first axis index changing slowest. ‘F’ means to index the elements in Fortran-like index order, with the first index changing fastest, and the last index changing slowest. Note that the ‘C’ and ‘F’ options take no account of the memory layout of the underlying array, and only refer to the order of axis indexing. ‘A’ means to read the elements in Fortran-like index order if m is Fortran contiguous in memory, C-like order otherwise. ‘K’ means to read the elements in the order they occur in memory, except for reversing the data when strides are negative. By default, ‘C’ index order is used. (Masked arrays currently use ‘A’ on the data when ‘K’ is passed.)

Returns¶

MaskedArray: Output view is of shape (self.size,) (or (np.ma.product(self.shape),)).

Examples¶

>>> import numpy as np
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
  data=[[1, --, 3],
        [--, 5, --],
        [7, --, 9]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=999999)
>>> x.ravel()
masked_array(data=[1, --, 3, --, 5, --, 7, --, 9],
             mask=[False,  True, False,  True, False,  True, False,  True,
                   False],
       fill_value=999999)

repeat(repeats, axis=None)¶

Repeat elements of an array.

Refer to numpy.repeat for full documentation.

Parameters¶

shapeint or tuple of ints: The new shape should be compatible with the original shape. If an integer is supplied, then the result will be a 1-D array of that length.
order{‘C’, ‘F’}, optional: Determines whether the array data should be viewed as in C (row-major) or FORTRAN (column-major) order.

Returns¶

reshaped_arrayarray: A new view on the array.

Notes¶

The reshaping operation cannot guarantee that a copy will not be made, to modify the shape in place, use a.shape = s

Examples¶

>>> import numpy as np
>>> x = np.ma.array([[1,2],[3,4]], mask=[1,0,0,1])
>>> x
masked_array(
  data=[[--, 2],
        [3, --]],
  mask=[[ True, False],
        [False,  True]],
  fill_value=999999)
>>> x = x.reshape((4,1))
>>> x
masked_array(
  data=[[--],
        [2],
        [3],
        [--]],
  mask=[[ True],
        [False],
        [False],
        [ True]],
  fill_value=999999)

resize(newshape, refcheck=True, order=False)¶: Warning

This method does nothing, except raise a ValueError exception. A masked array does not own its data and therefore cannot safely be resized in place. Use the numpy.ma.resize function instead.

This method is difficult to implement safely and may be deprecated in future releases of NumPy.

round(decimals=0, out=None)¶

Return each element rounded to the given number of decimals.

Refer to numpy.around for full documentation.

Examples¶

>>> import numpy as np
>>> import numpy.ma as ma
>>> x = ma.array([1.35, 2.5, 1.5, 1.75, 2.25, 2.75],
...              mask=[0, 0, 0, 1, 0, 0])
>>> ma.round(x)
masked_array(data=[1.0, 2.0, 2.0, --, 2.0, 3.0],
             mask=[False, False, False,  True, False, False],
        fill_value=1e+20)

searchsorted(v, side='left', sorter=None)¶

Find indices where elements of v should be inserted in a to maintain order.

For full documentation, see numpy.searchsorted

Parameters¶

valobject: Value to be placed in field.
dtypedtype object: Data-type of the field in which to place val.
offsetint, optional: The number of bytes into the field at which to place val.

Returns¶

None

Examples¶

>>> import numpy as np
>>> x = np.eye(3)
>>> x.getfield(np.float64)
array([[1.,  0.,  0.],
       [0.,  1.,  0.],
       [0.,  0.,  1.]])
>>> x.setfield(3, np.int32)
>>> x.getfield(np.int32)
array([[3, 3, 3],
       [3, 3, 3],
       [3, 3, 3]], dtype=int32)
>>> x
array([[1.0e+000, 1.5e-323, 1.5e-323],
       [1.5e-323, 1.0e+000, 1.5e-323],
       [1.5e-323, 1.5e-323, 1.0e+000]])
>>> x.setfield(np.eye(3), np.int32)
>>> x
array([[1.,  0.,  0.],
       [0.,  1.,  0.],
       [0.,  0.,  1.]])

setflags(write=None, align=None, uic=None)¶

Set array flags WRITEABLE, ALIGNED, WRITEBACKIFCOPY, respectively.

These Boolean-valued flags affect how numpy interprets the memory area used by a (see Notes below). The ALIGNED flag can only be set to True if the data is actually aligned according to the type. The WRITEBACKIFCOPY flag can never be set to True. The flag WRITEABLE can only be set to True if the array owns its own memory, or the ultimate owner of the memory exposes a writeable buffer interface, or is a string. (The exception for string is made so that unpickling can be done without copying memory.)

Parameters¶

writebool, optional: Describes whether or not a can be written to.
alignbool, optional: Describes whether or not a is aligned properly for its type.
uicbool, optional: Describes whether or not a is a copy of another “base” array.

Notes¶

Array flags provide information about how the memory area used for the array is to be interpreted. There are 7 Boolean flags in use, only three of which can be changed by the user: WRITEBACKIFCOPY, WRITEABLE, and ALIGNED.

WRITEABLE (W) the data area can be written to;

ALIGNED (A) the data and strides are aligned appropriately for the hardware (as determined by the compiler);

WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced by .base). When the C-API function PyArray_ResolveWritebackIfCopy is called, the base array will be updated with the contents of this array.

All flags can be accessed using the single (upper case) letter as well as the full name.

Examples¶

>>> import numpy as np
>>> y = np.array([[3, 1, 7],
...               [2, 0, 0],
...               [8, 5, 9]])
>>> y
array([[3, 1, 7],
       [2, 0, 0],
       [8, 5, 9]])
>>> y.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
>>> y.setflags(write=0, align=0)
>>> y.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : False
  ALIGNED : False
  WRITEBACKIFCOPY : False
>>> y.setflags(uic=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot set WRITEBACKIFCOPY flag to True

shrink_mask()¶

Reduce a mask to nomask when possible.

Parameters¶

None

Returns¶

resultMaskedArray: A MaskedArray object.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([[1,2 ], [3, 4]], mask=[0]*4)
>>> x.mask
array([[False, False],
       [False, False]])
>>> x.shrink_mask()
masked_array(
  data=[[1, 2],
        [3, 4]],
  mask=False,
  fill_value=999999)
>>> x.mask
False

soften_mask()¶

Force the mask to soft (default), allowing unmasking by assignment.

Whether the mask of a masked array is hard or soft is determined by its ~ma.MaskedArray.hardmask property. soften_mask sets ~ma.MaskedArray.hardmask to False (and returns the modified self).

Parameters¶

aarray_like: Array to be sorted.
axisint, optional: Axis along which to sort. If None, the array is flattened before sorting. The default is -1, which sorts along the last axis.
kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, optional: The sorting algorithm used.
orderlist, optional: When a is a structured array, this argument specifies which fields to compare first, second, and so on. This list does not need to include all of the fields.
endwith{True, False}, optional: Whether missing values (if any) should be treated as the largest values (True) or the smallest values (False) When the array contains unmasked values sorting at the same extremes of the datatype, the ordering of these values and the masked values is undefined.
fill_valuescalar or None, optional: Value used internally for the masked values. If fill_value is not None, it supersedes endwith.
stablebool, optional: Only for compatibility with np.sort. Ignored.

Returns¶

sorted_arrayndarray: Array of the same type and shape as a.

Notes¶

See sort for notes on the different sorting algorithms.

Examples¶

>>> import numpy as np
>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
>>> # Default
>>> a.sort()
>>> a
masked_array(data=[1, 3, 5, --, --],
             mask=[False, False, False,  True,  True],
       fill_value=999999)

>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
>>> # Put missing values in the front
>>> a.sort(endwith=False)
>>> a
masked_array(data=[--, --, 1, 3, 5],
             mask=[ True,  True, False, False, False],
       fill_value=999999)

>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
>>> # fill_value takes over endwith
>>> a.sort(endwith=False, fill_value=3)
>>> a
masked_array(data=[1, --, --, 3, 5],
             mask=[False,  True,  True, False, False],
       fill_value=999999)

squeeze(axis=None)¶

Remove axes of length one from a.

Refer to numpy.squeeze for full documentation.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
  data=[[1, --, 3],
        [--, 5, --],
        [7, --, 9]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=999999)
>>> x.sum()
25
>>> x.sum(axis=1)
masked_array(data=[4, 5, 16],
             mask=[False, False, False],
       fill_value=999999)
>>> x.sum(axis=0)
masked_array(data=[8, 5, 12],
             mask=[False, False, False],
       fill_value=999999)
>>> print(type(x.sum(axis=0, dtype=np.int64)[0]))
<class 'numpy.int64'>

swap_column(*swp, **kwargs)[source]¶

Swap pairs of columns in the data.

Useful for reordering data for idiot programs that expect columns in a fixed order.

Parameters:

swp (tuple of list of tuples of two elements) – Each element will be iused as a column index (using the normal rules for matching columns). The two elements represent the two columns that are to be swapped.
headers_too (bool) – Indicates the column headers are swapped as well

Returns:

self – A copy of the modified DataFile objects

Note

If swp is a list, then the function is called recursively on each element of the list. Thus in principle the @swp could contain lists of lists of tuples

swapaxes(axis1, axis2)¶

Return a view of the array with axis1 and axis2 interchanged.

Refer to numpy.swapaxes for full documentation.

Parameters¶

amasked_array

The source masked array.

indicesarray_like

The indices of the values to extract. Also allow scalars for indices.

axisint, optional

The axis over which to select values. By default, the flattened input array is used.

outMaskedArray, optional

If provided, the result will be placed in this array. It should be of the appropriate shape and dtype. Note that out is always buffered if mode=’raise’; use other modes for better performance.

mode{‘raise’, ‘wrap’, ‘clip’}, optional

Specifies how out-of-bounds indices will behave.

‘raise’ – raise an error (default)
‘wrap’ – wrap around
‘clip’ – clip to the range

‘clip’ mode means that all indices that are too large are replaced by the index that addresses the last element along that axis. Note that this disables indexing with negative numbers.

Returns¶

outMaskedArray: The returned array has the same type as a.

Notes¶

This function behaves similarly to numpy.take, but it handles masked values. The mask is retained in the output array, and masked values in the input array remain masked in the output.

Examples¶

>>> import numpy as np
>>> a = np.ma.array([4, 3, 5, 7, 6, 8], mask=[0, 0, 1, 0, 1, 0])
>>> indices = [0, 1, 4]
>>> np.ma.take(a, indices)
masked_array(data=[4, 3, --],
            mask=[False, False,  True],
    fill_value=999999)

When indices is not one-dimensional, the output also has these dimensions:

>>> np.ma.take(a, [[0, 1], [2, 3]])
masked_array(data=[[4, 3],
                [--, 7]],
            mask=[[False, False],
                [ True, False]],
    fill_value=999999)

to_device()¶

tobytes(fill_value=None, order='C')¶

Return the array data as a string containing the raw bytes in the array.

The array is filled with a fill value before the string conversion.

Parameters¶

fill_valuescalar, optional

Value used to fill in the masked values. Default is None, in which case MaskedArray.fill_value is used.

order{‘C’,’F’,’A’}, optional

Order of the data item in the copy. Default is ‘C’.

‘C’ – C order (row major).
‘F’ – Fortran order (column major).
‘A’ – Any, current order of array.
None – Same as ‘A’.

Notes¶

As for ndarray.tobytes, information about the shape, dtype, etc., but also about fill_value, will be lost.

Examples¶

>>> import numpy as np
>>> x = np.ma.array(np.array([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
>>> x.tobytes()
b'\x01\x00\x00\x00\x00\x00\x00\x00?B\x0f\x00\x00\x00\x00\x00?B\x0f\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00'

tofile(fid, sep='', format='%s')[source]¶: Silly pass through.

toflex()¶

Transforms a masked array into a flexible-type array.

The flexible type array that is returned will have two fields:

the _data field stores the _data part of the array.
the _mask field stores the _mask part of the array.

Parameters¶

None

Returns¶

recordndarray: A new flexible-type ndarray with two fields: the first element containing a value, the second element containing the corresponding mask boolean. The returned record shape matches self.shape.

Notes¶

A side-effect of transforming a masked array into a flexible ndarray is that meta information (fill_value, …) will be lost.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
  data=[[1, --, 3],
        [--, 5, --],
        [7, --, 9]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=999999)
>>> x.toflex()
array([[(1, False), (2,  True), (3, False)],
       [(4,  True), (5, False), (6,  True)],
       [(7, False), (8,  True), (9, False)]],
      dtype=[('_data', '<i8'), ('_mask', '?')])

tolist(fill_value=None)¶

Return the data portion of the masked array as a hierarchical Python list.

Data items are converted to the nearest compatible Python type. Masked values are converted to fill_value. If fill_value is None, the corresponding entries in the output list will be None.

Parameters¶

fill_valuescalar, optional: The value to use for invalid entries. Default is None.

Returns¶

resultlist: The Python list representation of the masked array.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([[1,2,3], [4,5,6], [7,8,9]], mask=[0] + [1,0]*4)
>>> x.tolist()
[[1, None, 3], [None, 5, None], [7, None, 9]]
>>> x.tolist(-999)
[[1, -999, 3], [-999, 5, -999], [7, -999, 9]]

torecords()¶

Transforms a masked array into a flexible-type array.

The flexible type array that is returned will have two fields:

the _data field stores the _data part of the array.
the _mask field stores the _mask part of the array.

Parameters¶

None

Returns¶

recordndarray: A new flexible-type ndarray with two fields: the first element containing a value, the second element containing the corresponding mask boolean. The returned record shape matches self.shape.

Notes¶

A side-effect of transforming a masked array into a flexible ndarray is that meta information (fill_value, …) will be lost.

Examples¶

>>> import numpy as np
>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
  data=[[1, --, 3],
        [--, 5, --],
        [7, --, 9]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=999999)
>>> x.toflex()
array([[(1, False), (2,  True), (3, False)],
       [(4,  True), (5, False), (6,  True)],
       [(7, False), (8,  True), (9, False)]],
      dtype=[('_data', '<i8'), ('_mask', '?')])

trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)¶

Return the sum along diagonals of the array.

Refer to numpy.trace for full documentation.

Parameters¶

axes : None, tuple of ints, or n ints

None or no argument: reverses the order of the axes.

tuple of ints: i in the j-th place in the tuple means that the array’s i-th axis becomes the transposed array’s j-th axis.

n ints: same as an n-tuple of the same ints (this form is intended simply as a “convenience” alternative to the tuple form).

Returns¶

pndarray: View of the array with its axes suitably permuted.

Examples¶

>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
       [3, 4]])
>>> a.transpose()
array([[1, 3],
       [2, 4]])
>>> a.transpose((1, 0))
array([[1, 3],
       [2, 4]])
>>> a.transpose(1, 0)
array([[1, 3],
       [2, 4]])

>>> a = np.array([1, 2, 3, 4])
>>> a
array([1, 2, 3, 4])
>>> a.transpose()
array([1, 2, 3, 4])

unshare_mask()¶

Copy the mask and set the sharedmask flag to False.

Whether the mask is shared between masked arrays can be seen from the sharedmask property. unshare_mask ensures the mask is not shared. A copy of the mask is only made if it was shared.

Parameters¶

aarray_like

Array containing numbers whose variance is desired. If a is not an array, a conversion is attempted.

axisNone or int or tuple of ints, optional

Axis or axes along which the variance is computed. The default is to compute the variance of the flattened array. If this is a tuple of ints, a variance is performed over multiple axes, instead of a single axis or all the axes as before.

dtypedata-type, optional

Type to use in computing the variance. For arrays of integer type the default is float64; for arrays of float types it is the same as the array type.

outndarray, optional

Alternate output array in which to place the result. It must have the same shape as the expected output, but the type is cast if necessary.

ddof{int, float}, optional

“Delta Degrees of Freedom”: the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is zero. See notes for details about use of ddof.

keepdimsbool, optional

If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array.

If the default value is passed, then keepdims will not be passed through to the var method of sub-classes of ndarray, however any non-default value will be. If the sub-class’ method does not implement keepdims any exceptions will be raised.

wherearray_like of bool, optional

Elements to include in the variance. See ~numpy.ufunc.reduce for details.

Added in version 1.20.0.

meanarray like, optional

Provide the mean to prevent its recalculation. The mean should have a shape as if it was calculated with keepdims=True. The axis for the calculation of the mean should be the same as used in the call to this var function.

Added in version 2.0.0.

correction{int, float}, optional

Array API compatible name for the ddof parameter. Only one of them can be provided at the same time.

Added in version 2.0.0.

Returns¶

variancendarray, see dtype parameter above: If out=None, returns a new array containing the variance; otherwise, a reference to the output array is returned.

Notes¶

There are several common variants of the array variance calculation. Assuming the input a is a one-dimensional NumPy array and mean is either provided as an argument or computed as a.mean(), NumPy computes the variance of an array as:

N = len(a)
d2 = abs(a - mean)**2  # abs is for complex `a`
var = d2.sum() / (N - ddof)  # note use of `ddof`

Different values of the argument ddof are useful in different contexts. NumPy’s default ddof=0 corresponds with the expression:

\[\frac{\sum_i{|a_i - \bar{a}|^2 }}{N}\]

which is sometimes called the “population variance” in the field of statistics because it applies the definition of variance to a as if a were a complete population of possible observations.

Many other libraries define the variance of an array differently, e.g.:

\[\frac{\sum_i{|a_i - \bar{a}|^2}}{N - 1}\]

In statistics, the resulting quantity is sometimes called the “sample variance” because if a is a random sample from a larger population, this calculation provides an unbiased estimate of the variance of the population. The use of \(N-1\) in the denominator is often called “Bessel’s correction” because it corrects for bias (toward lower values) in the variance estimate introduced when the sample mean of a is used in place of the true mean of the population. For this quantity, use ddof=1.

Note that for complex numbers, the absolute value is taken before squaring, so that the result is always real and nonnegative.

For floating-point input, the variance is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for float32 (see example below). Specifying a higher-accuracy accumulator using the dtype keyword can alleviate this issue.

Examples¶

>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> np.var(a)
1.25
>>> np.var(a, axis=0)
array([1.,  1.])
>>> np.var(a, axis=1)
array([0.25,  0.25])

In single precision, var() can be inaccurate:

>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.var(a)
np.float32(0.20250003)

Computing the variance in float64 is more accurate:

>>> np.var(a, dtype=np.float64)
0.20249999932944759 # may vary
>>> ((1-0.55)**2 + (0.1-0.55)**2)/2
0.2025

Specifying a where argument:

>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> np.var(a)
6.833333333333333 # may vary
>>> np.var(a, where=[[True], [True], [False]])
4.0

Using the mean keyword to save computation time:

>>> import numpy as np
>>> from timeit import timeit
>>>
>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> mean = np.mean(a, axis=1, keepdims=True)
>>>
>>> g = globals()
>>> n = 10000
>>> t1 = timeit("var = np.var(a, axis=1, mean=mean)", globals=g, number=n)
>>> t2 = timeit("var = np.var(a, axis=1)", globals=g, number=n)
>>> print(f'Percentage execution time saved {100*(t2-t1)/t2:.0f}%')

Percentage execution time saved 32%

view(dtype=None, type=None, fill_value=None)¶

Return a view of the MaskedArray data.

Parameters¶

dtypedata-type or ndarray sub-class, optional: Data-type descriptor of the returned view, e.g., float32 or int16. The default, None, results in the view having the same data-type as a. As with ndarray.view, dtype can also be specified as an ndarray sub-class, which then specifies the type of the returned object (this is equivalent to setting the type parameter).
typePython type, optional: Type of the returned view, either ndarray or a subclass. The default None results in type preservation.
fill_valuescalar, optional: The value to use for invalid entries (None by default). If None, then this argument is inferred from the passed dtype, or in its absence the original array, as discussed in the notes below.

Notes¶

a.view() is used two different ways:

a.view(some_dtype) or a.view(dtype=some_dtype) constructs a view of the array’s memory with a different data-type. This can cause a reinterpretation of the bytes of memory.

a.view(ndarray_subclass) or a.view(type=ndarray_subclass) just returns an instance of ndarray_subclass that looks at the same array (same shape, dtype, etc.) This does not cause a reinterpretation of the memory.

If fill_value is not specified, but dtype is specified (and is not an ndarray sub-class), the fill_value of the MaskedArray will be reset. If neither fill_value nor dtype are specified (or if dtype is an ndarray sub-class), then the fill value is preserved. Finally, if fill_value is specified, but dtype is not, the fill value is set to the specified value.

For a.view(some_dtype), if some_dtype has a different number of bytes per entry than the previous dtype (for example, converting a regular array to a structured array), then the behavior of the view cannot be predicted just from the superficial appearance of a (shown by print(a)). It also depends on exactly how a is stored in memory. Therefore if a is C-ordered versus fortran-ordered, versus defined as a slice or transpose, etc., the view may give different results.

DataArray¶

Examples¶

Parameters¶

Returns¶

See Also¶

Notes¶

Examples¶

Examples¶

Attributes¶

Notes¶

See Also¶

Examples¶

See Also¶

Examples¶

Examples¶

Returns¶

Raises¶

See Also¶

Notes¶

See Also¶

Examples¶

Examples¶

See Also¶

Examples¶

Notes¶

Examples¶

Notes¶

See Also¶

Examples¶

See Also¶

Examples¶

Parameters¶

See Also¶

Examples¶

See Also¶

Parameters¶

Returns¶

Examples¶

Parameters¶

Returns¶

Examples¶

See Also¶

Parameters¶

Returns¶

See Also¶

Notes¶

Examples¶

Parameters¶

Returns¶

Raises¶

Examples¶

Parameters¶

Returns¶

Examples¶

See Also¶

See Also¶

Parameters¶

Returns¶

Notes¶

Examples¶

Returns¶

Notes¶

Examples¶

See Also¶

See Also¶

Parameters¶

See also¶

Notes¶

Examples¶

Parameters¶

Returns¶

See Also¶

Examples¶

Notes¶

See Also¶

Notes¶

See Also¶

Examples¶

See Also¶

Parameters¶