NumPy Reference Release 1.8.1 Written by the NumPy community March 25, 2014 CONTENTS 1 Array objects 3 1.1 The N-dimensional array (ndarray)..................................3 1.2 Scalars.................................................. 71 1.3 Data type objects (dtype)........................................ 87 1.4 Indexing................................................. 102 1.5 Iterating Over Arrays........................................... 107 1.6 Standard array subclasses........................................ 118 1.7 Masked arrays.............................................. 233 1.8 The Array Interface........................................... 418 1.9 Datetimes and Timedeltas........................................ 422 2 Universal functions (ufunc) 431 2.1 Broadcasting............................................... 431 2.2 Output type determination........................................ 432 2.3 Use of internal buffers.......................................... 432 2.4 Error handling.............................................. 432 2.5 Casting Rules............................................... 435 2.6 ufunc .................................................. 437 2.7 Available ufuncs............................................. 446 3 Routines 451 3.1 Array creation routines.......................................... 451 3.2 Array manipulation routines....................................... 484 3.3 Binary operations............................................. 523 3.4 String operations............................................. 531 3.5 C-Types Foreign Function Interface (numpy.ctypeslib)...................... 576 3.6 Datetime Support Functions....................................... 577 3.7 Data type routines............................................ 582 3.8 Optionally Scipy-accelerated routines (numpy.dual)......................... 600 3.9 Mathematical functions with automatic domain (numpy.emath)................... 601 3.10 Floating point error handling....................................... 601 3.11 Discrete Fourier Transform (numpy.fft)............................... 608 3.12 Financial functions............................................ 630 3.13 Functional programming......................................... 639 3.14 Numpy-speciﬁc help functions...................................... 645 3.15 Indexing routines............................................. 647 3.16 Input and output............................................. 680 3.17 Linear algebra (numpy.linalg)................................... 703 3.18 Logic functions.............................................. 737 i 3.19 Masked array operations......................................... 754 3.20 Mathematical functions......................................... 876 3.21 Matrix library (numpy.matlib).................................... 941 3.22 Numarray compatibility (numpy.numarray)............................. 947 3.23 Old Numeric compatibility (numpy.oldnumeric).......................... 947 3.24 Miscellaneous routines.......................................... 947 3.25 Padding Arrays.............................................. 948 3.26 Polynomials............................................... 952 3.27 Random sampling (numpy.random)................................. 1133 3.28 Set routines................................................ 1230 3.29 Sorting, searching, and counting..................................... 1235 3.30 Statistics................................................. 1251 3.31 Test Support (numpy.testing).................................... 1279 3.32 Asserts.................................................. 1280 3.33 Window functions............................................ 1292 4 Packaging (numpy.distutils) 1301 4.1 Modules in numpy.distutils .................................... 1301 4.2 Building Installable C libraries...................................... 1312 4.3 Conversion of .src ﬁles........................................ 1313 5 Numpy C-API 1315 5.1 Python Types and C-Structures..................................... 1315 5.2 System conﬁguration........................................... 1329 5.3 Data Type API.............................................. 1331 5.4 Array API................................................ 1336 5.5 Array Iterator API............................................ 1375 5.6 UFunc API................................................ 1391 5.7 Generalized Universal Function API................................... 1397 5.8 Numpy core libraries........................................... 1400 5.9 C API Deprecations........................................... 1404 6 Numpy internals 1407 6.1 Numpy C Code Explanations...................................... 1407 6.2 Internal organization of numpy arrays.................................. 1414 6.3 Multidimensional Array Indexing Order Issues............................. 1415 7 Numpy and SWIG 1417 7.1 Numpy.i: a SWIG Interface File for NumPy............................... 1417 7.2 Testing the numpy.i Typemaps...................................... 1432 8 Acknowledgements 1435 Bibliography 1437 Index 1445 ii NumPy Reference, Release 1.8.1 Release 1.8 Date March 25, 2014 This reference manual details functions, modules, and objects included in Numpy, describing what they are and what they do. For learning how to use NumPy, see also user. CONTENTS 1 NumPy Reference, Release 1.8.1 2 CONTENTS CHAPTER ONE ARRAY OBJECTS NumPy provides an N-dimensional array type, the ndarray, which describes a collection of “items” of the same type. The items can be indexed using for example N integers. All ndarrays are homogenous: every item takes up the same size block of memory, and all blocks are interpreted in exactly the same way. How each item in the array is to be interpreted is speciﬁed by a separate data-type object, one of which is associated with every array. In addition to basic types (integers, ﬂoats, etc.), the data type objects can also represent data structures. An item extracted from an array, e.g., by indexing, is represented by a Python object whose type is one of the array scalar types built in Numpy. The array scalars allow easy manipulation of also more complicated arrangements of data. Figure 1.1: Figure Conceptual diagram showing the relationship between the three fundamental objects used to de- scribe the data in an array: 1) the ndarray itself, 2) the data-type object that describes the layout of a single ﬁxed-size element of the array, 3) the array-scalar Python object that is returned when a single element of the array is accessed. 1.1 The N-dimensional array (ndarray) An ndarray is a (usually ﬁxed-size) multidimensional container of items of the same type and size. The number of dimensions and items in an array is deﬁned by its shape, which is a tuple of N positive integers that specify the sizes of each dimension. The type of items in the array is speciﬁed by a separate data-type object (dtype), one of which is associated with each ndarray. As with other container objects in Python, the contents of an ndarray can be accessed and modiﬁed by indexing or slicing the array (using, for example, N integers), and via the methods and attributes of the ndarray. 3 NumPy Reference, Release 1.8.1 Different ndarrays can share the same data, so that changes made in one ndarray may be visible in another. That is, an ndarray can be a “view” to another ndarray, and the data it is referring to is taken care of by the “base” ndarray. ndarrays can also be views to memory owned by Python strings or objects implementing the buffer or array interfaces. Example A 2-dimensional array of size 2 x 3, composed of 4-byte integer elements: >>> x= np.array([[1,2,3], [4,5,6]], np.int32) >>> type(x) >>> x.shape (2, 3) >>> x.dtype dtype(’int32’) The array can be indexed using Python container-like syntax: >>> x[1,2]# i.e., the element of x in the *second* row, *third* column, namely, 6. For example slicing can produce views of the array: >>> y= x[:,1] >>> y array([2, 5]) >>> y[0]=9 # this also changes the corresponding element in x >>> y array([9, 5]) >>> x array([[1, 9, 3], [4, 5, 6]]) 1.1.1 Constructing arrays New arrays can be constructed using the routines detailed in Array creation routines, and also by using the low-level ndarray constructor: ndarray An array object represents a multidimensional, homogeneous array of ﬁxed-size items. class numpy.ndarray An array object represents a multidimensional, homogeneous array of ﬁxed-size items. An associated data-type object describes the format of each element in the array (its byte-order, how many bytes it occupies in memory, whether it is an integer, a ﬂoating point number, or something else, etc.) Arrays should be constructed using array, zeros or empty (refer to the See Also section below). The parameters given here refer to a low-level method (ndarray(...)) for instantiating an array. For more information, refer to the numpy module and examine the the methods and attributes of an array. Parameters (for the __new__ method; see Notes below) shape : tuple of ints Shape of created array. 4 Chapter 1. Array objects NumPy Reference, Release 1.8.1 dtype : data-type, optional Any object that can be interpreted as a numpy data type. buffer : object exposing buffer interface, optional Used to ﬁll the array with data. offset : int, optional Offset of array data in buffer. strides : tuple of ints, optional Strides of data in memory. order : {‘C’, ‘F’}, optional Row-major or column-major order. See Also: array Construct an array. zeros Create an array, each element of which is zero. empty Create an array, but leave its allocated memory unchanged (i.e., it contains “garbage”). dtype Create a data-type. Notes There are two modes of creating an array using __new__: 1.If buffer is None, then only shape, dtype, and order are used. 2.If buffer is an object exposing the buffer interface, then all keywords are interpreted. No __init__ method is needed because the array is fully initialized after the __new__ method. Examples These examples illustrate the low-level ndarray constructor. Refer to the See Also section above for easier ways of constructing an ndarray. First mode, buffer is None: >>> np.ndarray(shape=(2,2), dtype=float, order=’F’) array([[ -1.13698227e+002, 4.25087011e-303], [ 2.88528414e-306, 3.27025015e-309]]) #random Second mode: >>> np.ndarray((2,), buffer=np.array([1,2,3]), ... offset=np.int_().itemsize, ... dtype=int)# offset = 1*itemsize, i.e. skip first element array([2, 3]) Attributes 1.1. The N-dimensional array (ndarray) 5 NumPy Reference, Release 1.8.1 T Same as self.transpose(), except that self is returned if self.ndim < 2. data Python buffer object pointing to the start of the array’s data. dtype Data-type of the array’s elements. flags Information about the memory layout of the array. flat A 1-D iterator over the array. imag The imaginary part of the array. real The real part of the array. size Number of elements in the array. itemsize Length of one array element in bytes. nbytes Total bytes consumed by the elements of the array. ndim Number of array dimensions. shape Tuple of array dimensions. strides Tuple of bytes to step in each dimension when traversing an array. ctypes An object to simplify the interaction of the array with the ctypes module. base Base object if memory is from some other object. ndarray.T Same as self.transpose(), except that self is returned if self.ndim < 2. Examples >>> x= np.array([[1.,2.],[3.,4.]]) >>> x array([[ 1., 2.], [ 3., 4.]]) >>> x.T array([[ 1., 3.], [ 2., 4.]]) >>> x= np.array([1.,2.,3.,4.]) >>> x array([ 1., 2., 3., 4.]) >>> x.T array([ 1., 2., 3., 4.]) ndarray.data Python buffer object pointing to the start of the array’s data. ndarray.dtype Data-type of the array’s elements. Parameters None Returns d : numpy dtype object See Also: numpy.dtype Examples >>> x array([[0, 1], [2, 3]]) >>> x.dtype dtype(’int32’) 6 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> type(x.dtype) ndarray.flags Information about the memory layout of the array. Notes The flags object can be accessed dictionary-like (as in a.flags[’WRITEABLE’]), or by using low- ercased attribute names (as in a.flags.writeable). Short ﬂag names are only supported in dictionary access. Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED ﬂags can be changed by the user, via direct assignment to the attribute or dictionary entry, or by calling ndarray.setflags. The array ﬂags cannot be set arbitrarily: •UPDATEIFCOPY 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 arbi- trary 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. 1.1. The N-dimensional array (ndarray) 7 NumPy Reference, Release 1.8.1 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. OWN- DATA (O) The array owns the memory it uses or borrows it from another object. WRITE- ABLE (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. UP- DATEIF- COPY (U) This array is a copy of some other array. When this array is deallocated, 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. ndarray.flat A 1-D iterator over the array. This is a numpy.flatiter instance, which acts similarly to, but is not a subclass of, Python’s built-in iterator object. See Also: flatten Return a copy of the array collapsed into one dimension. flatiter Examples >>> x= np.arange(1,7).reshape(2,3) >>> x array([[1, 2, 3], [4, 5, 6]]) >>> x.flat[3] 4 >>> x.T array([[1, 4], [2, 5], [3, 6]]) 8 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> x.T.flat[3] 5 >>> type(x.flat) An assignment example: >>> x.flat=3; x array([[3, 3, 3], [3, 3, 3]]) >>> x.flat[[1,4]]=1; x array([[3, 1, 3], [3, 1, 3]]) ndarray.imag The imaginary part of the array. Examples >>> x= np.sqrt([1+0j,0+1j]) >>> x.imag array([ 0. , 0.70710678]) >>> x.imag.dtype dtype(’float64’) ndarray.real The real part of the array. See Also: numpy.real equivalent function Examples >>> x= np.sqrt([1+0j,0+1j]) >>> x.real array([ 1. , 0.70710678]) >>> x.real.dtype dtype(’float64’) ndarray.size Number of elements in the array. Equivalent to np.prod(a.shape), i.e., the product of the array’s dimensions. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.size 30 >>> np.prod(x.shape) 30 ndarray.itemsize Length of one array element in bytes. 1.1. The N-dimensional array (ndarray) 9 NumPy Reference, Release 1.8.1 Examples >>> x= np.array([1,2,3], dtype=np.float64) >>> x.itemsize 8 >>> x= np.array([1,2,3], dtype=np.complex128) >>> x.itemsize 16 ndarray.nbytes Total bytes consumed by the elements of the array. Notes Does not include memory consumed by non-element attributes of the array object. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.nbytes 480 >>> np.prod(x.shape) * x.itemsize 480 ndarray.ndim Number of array dimensions. Examples >>> x= np.array([1,2,3]) >>> x.ndim 1 >>> y= np.zeros((2,3,4)) >>> y.ndim 3 ndarray.shape Tuple of array dimensions. Notes May be used to “reshape” the array, as long as this would not require a change in the total number of elements Examples >>> x= np.array([1,2,3,4]) >>> x.shape (4,) >>> y= np.zeros((2,3,4)) >>> y.shape (2, 3, 4) >>> y.shape=(3,8) >>> y array([[ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.]]) >>> y.shape=(3,6) Traceback (most recent call last): 10 Chapter 1. Array objects NumPy Reference, Release 1.8.1 File "", line1, in ValueError: total size of new array must be unchanged ndarray.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 “ndarray.rst” ﬁle in the NumPy reference guide. See Also: numpy.lib.stride_tricks.as_strided 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 >>> y= np.reshape(np.arange(2 *3*4), (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]]]) >>> y.strides (48, 16, 4) >>> y[1,1,1] 17 >>> offset=sum(y.strides * np.array((1,1,1))) >>> offset/y.itemsize 17 >>> x= np.reshape(np.arange(5 *6*7*8), (5,6,7,8)).transpose(2,3,1,0) >>> x.strides (32, 4, 224, 1344) >>> i= np.array([3,5,2,2]) >>> offset= sum(i * x.strides) >>> x[3,5,2,2] 813 >>> offset/x.itemsize 813 ndarray.ctypes An object to simplify the interaction of the array with the ctypes module. 1.1. The N-dimensional array (ndarray) 11 NumPy Reference, Release 1.8.1 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 c : Python object Possessing attributes data, shape, strides, etc. See Also: numpy.ctypeslib 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): •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 ﬂags 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]. •shape (c_intp*self.ndim): A ctypes array of length self.ndim where the basetype is the C-integer corresponding to dtype(‘p’) on this platform. This base-type could be c_int, c_long, or c_longlong depending on the platform. The c_intp type is deﬁned accordingly in numpy.ctypeslib. The ctypes array contains the shape of the underlying array. •strides (c_intp*self.ndim): 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. •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 ﬂoating-point data: self.data_as(ctypes.POINTER(ctypes.c_double)). •shape_as(obj): Return the shape tuple as an array of some other c-types type. For example: self.shape_as(ctypes.c_short). •strides_as(obj): Return the strides tuple as an array of some other c-types type. For example: self.strides_as(ctypes.c_longlong). Be careful using the ctypes attribute - especially on temporary arrays or arrays constructed on the ﬂy. For example, calling (a+b).ctypes.data_as(ctypes.c_void_p) returns a pointer to memory that is invalid because the array created as (a+b) is deallocated before the next Python statement. You can avoid this problem using either c=a+b or ct=(a+b).ctypes. In the latter case, ct will hold a reference to the array until ct is deleted or re-assigned. 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 ctypes >>> x 12 Chapter 1. Array objects NumPy Reference, Release 1.8.1 array([[0, 1], [2, 3]]) >>> x.ctypes.data 30439712 >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents c_long(0) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents c_longlong(4294967296L) >>> x.ctypes.shape >>> x.ctypes.shape_as(ctypes.c_long) >>> x.ctypes.strides >>> x.ctypes.strides_as(ctypes.c_longlong) ndarray.base Base object if memory is from some other object. Examples The base of an array that owns its memory is None: >>> 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 Methods all([axis, out]) Returns True if all elements evaluate to True. any([axis, out]) Returns True if any of the elements of a evaluate to True. argmax([axis, out]) Return indices of the maximum values along the given axis. argmin([axis, out]) Return indices of the minimum values along the given axis of a. argpartition(kth[, axis, kind, order]) Returns the indices that would partition this array. argsort([axis, kind, order]) Returns the indices that would sort this array. astype(dtype[, order, casting, subok, copy]) Copy of the array, cast to a speciﬁed 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(a_min, a_max[, out]) Return an array whose values are limited to [a_min, a_max]. compress(condition[, axis, out]) Return selected slices of this array along given axis. conj() Complex-conjugate all elements. conjugate() Return the complex conjugate, element-wise. copy([order]) Return a copy of the array. cumprod([axis, dtype, out]) Return the cumulative product of the elements along the given axis. cumsum([axis, dtype, out]) Return the cumulative sum of the elements along the given axis. diagonal([offset, axis1, axis2]) Return speciﬁed diagonals. Continued on next page 1.1. The N-dimensional array (ndarray) 13 NumPy Reference, Release 1.8.1 Table 1.3 – continued from previous page dot(b[, out]) Dot product of two arrays. dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. dumps() Returns the pickle of the array as a string. fill(value) Fill the array with a scalar value. flatten([order]) Return a copy of the array collapsed into one dimension. getfield(dtype[, offset]) Returns a ﬁeld of the given array as a certain type. item(*args) Copy an element of an array to a standard Python scalar and return it. itemset(*args) Insert scalar into an array (scalar is cast to array’s dtype, if possible) max([axis, out]) Return the maximum along a given axis. mean([axis, dtype, out]) Returns the average of the array elements along given axis. min([axis, out]) Return the minimum along a given axis. newbyteorder([new_order]) Return the array with the same data viewed with a different byte order. nonzero() Return the indices of the elements that are non-zero. partition(kth[, axis, kind, order]) Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. prod([axis, dtype, out]) Return the product of the array elements over the given axis ptp([axis, out]) Peak to peak (maximum - minimum) value along a given axis. put(indices, values[, mode]) Set a.flat[n] = values[n] for all n in indices. ravel([order]) Return a ﬂattened array. repeat(repeats[, axis]) Repeat elements of an array. reshape(shape[, order]) Returns an array containing the same data with a new shape. resize(new_shape[, refcheck]) Change shape and size of array in-place. round([decimals, out]) Return a with 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. setfield(val, dtype[, offset]) Put a value into a speciﬁed place in a ﬁeld deﬁned by a data-type. setflags([write, align, uic]) Set array ﬂags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. sort([axis, kind, order]) Sort an array, in-place. squeeze([axis]) Remove single-dimensional entries from the shape of a. std([axis, dtype, out, ddof]) Returns the standard deviation of the array elements along given axis. sum([axis, dtype, out]) Return the sum of the array elements over the given axis. swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. take(indices[, axis, out, mode]) Return an array formed from the elements of a at the given indices. tofile(ﬁd[, sep, format]) Write array to a ﬁle as text or binary (default). tolist() Return the array as a (possibly nested) list. tostring([order]) Construct a Python string containing the raw data bytes in the 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. var([axis, dtype, out, ddof]) Returns the variance of the array elements, along given axis. view([dtype, type]) New view of array with the same data. ndarray.all(axis=None, out=None) Returns True if all elements evaluate to True. Refer to numpy.all for full documentation. See Also: numpy.all equivalent function ndarray.any(axis=None, out=None) Returns True if any of the elements of a evaluate to True. Refer to numpy.any for full documentation. 14 Chapter 1. Array objects NumPy Reference, Release 1.8.1 See Also: numpy.any equivalent function ndarray.argmax(axis=None, out=None) Return indices of the maximum values along the given axis. Refer to numpy.argmax for full documentation. See Also: numpy.argmax equivalent function ndarray.argmin(axis=None, out=None) Return indices of the minimum values along the given axis of a. Refer to numpy.argmin for detailed documentation. See Also: numpy.argmin equivalent function ndarray.argpartition(kth, axis=-1, kind=’introselect’, order=None) Returns the indices that would partition this array. Refer to numpy.argpartition for full documentation. New in version 1.8.0. See Also: numpy.argpartition equivalent function ndarray.argsort(axis=-1, kind=’quicksort’, order=None) Returns the indices that would sort this array. Refer to numpy.argsort for full documentation. See Also: numpy.argsort equivalent function ndarray.astype(dtype, order=’K’, casting=’unsafe’, subok=True, copy=True) Copy of the array, cast to a speciﬁed type. Parameters dtype : str 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’. 1.1. The N-dimensional array (ndarray) 15 NumPy Reference, Release 1.8.1 casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional Controls what kind of data casting may occur. Defaults to ‘unsafe’ for backwards com- patibility. • ‘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 ﬂoat64 to ﬂoat32, are allowed. • ‘unsafe’ means any data conversions may be done. subok : bool, optional If True, then sub-classes will be passed-through (default), otherwise the returned array will be forced to be a base-class array. copy : bool, optional By default, astype always returns a newly allocated array. If this is set to false, and the dtype, order, and subok requirements are satisﬁed, the input array is returned instead of a copy. Returns arr_t : ndarray Unless copy is False and the other conditions for returning the input array are satisﬁed (see description for copy input paramter), 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 ﬂoat or int. To avoid this, one should use a.real.astype(t). Examples >>> x= np.array([1,2, 2.5]) >>> x array([ 1. , 2. , 2.5]) >>> x.astype(int) array([1, 2, 2]) ndarray.byteswap(inplace) Swap the bytes of the array elements Toggle between low-endian and big-endian data representation by returning a byteswapped array, option- ally swapped in-place. Parameters inplace : bool, optional If True, swap bytes in-place, default is False. Returns out : ndarray The byteswapped array. If inplace is True, this is a view to self. 16 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> A= np.array([1, 256, 8755], dtype=np.int16) >>> map(hex, A) [’0x1’, ’0x100’, ’0x2233’] >>> A.byteswap(True) array([ 256, 1, 13090], dtype=int16) >>> map(hex, A) [’0x100’, ’0x1’, ’0x3322’] Arrays of strings are not swapped >>> A= np.array([’ceg’,’fac’]) >>> A.byteswap() array([’ceg’, ’fac’], dtype=’|S3’) ndarray.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. See Also: numpy.choose equivalent function ndarray.clip(a_min, a_max, out=None) Return an array whose values are limited to [a_min, a_max]. Refer to numpy.clip for full documentation. See Also: numpy.clip equivalent function ndarray.compress(condition, axis=None, out=None) Return selected slices of this array along given axis. Refer to numpy.compress for full documentation. See Also: numpy.compress equivalent function ndarray.conj() Complex-conjugate all elements. Refer to numpy.conjugate for full documentation. See Also: numpy.conjugate equivalent function ndarray.conjugate() Return the complex conjugate, element-wise. 1.1. The N-dimensional array (ndarray) 17 NumPy Reference, Release 1.8.1 Refer to numpy.conjugate for full documentation. See Also: numpy.conjugate equivalent function ndarray.copy(order=’C’) Return a copy of the array. 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 :func:numpy.copy are very similar, but have different default values for their order= arguments.) See Also: numpy.copy, numpy.copyto Examples >>> 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 ndarray.cumprod(axis=None, dtype=None, out=None) Return the cumulative product of the elements along the given axis. Refer to numpy.cumprod for full documentation. See Also: numpy.cumprod equivalent function ndarray.cumsum(axis=None, dtype=None, out=None) Return the cumulative sum of the elements along the given axis. Refer to numpy.cumsum for full documentation. See Also: numpy.cumsum equivalent function 18 Chapter 1. Array objects NumPy Reference, Release 1.8.1 ndarray.diagonal(offset=0, axis1=0, axis2=1) Return speciﬁed diagonals. Refer to numpy.diagonal for full documentation. See Also: numpy.diagonal equivalent function ndarray.dot(b, out=None) Dot product of two arrays. Refer to numpy.dot for full documentation. See Also: numpy.dot equivalent function Examples >>> a= np.eye(2) >>> b= np.ones((2,2)) * 2 >>> a.dot(b) array([[ 2., 2.], [ 2., 2.]]) This array method can be conveniently chained: >>> a.dot(b).dot(b) array([[ 8., 8.], [ 8., 8.]]) ndarray.dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. The array can be read back with pickle.load or numpy.load. Parameters ﬁle : str A string naming the dump ﬁle. ndarray.dumps() Returns the pickle of the array as a string. pickle.loads or numpy.loads will convert the string back to an array. Parameters None ndarray.fill(value) Fill the array with a scalar value. Parameters value : scalar All elements of a will be assigned this value. Examples 1.1. The N-dimensional array (ndarray) 19 NumPy Reference, Release 1.8.1 >>> a= np.array([1,2]) >>> a.fill(0) >>> a array([0, 0]) >>> a= np.empty(2) >>> a.fill(1) >>> a array([ 1., 1.]) ndarray.flatten(order=’C’) Return a copy of the array collapsed into one dimension. Parameters order : {‘C’, ‘F’, ‘A’}, optional Whether to ﬂatten in C (row-major), Fortran (column-major) order, or preserve the C/Fortran ordering from a. The default is ‘C’. Returns y : ndarray A copy of the input array, ﬂattened to one dimension. See Also: ravel Return a ﬂattened array. flat A 1-D ﬂat iterator over the array. Examples >>> a= np.array([[1,2], [3,4]]) >>> a.flatten() array([1, 2, 3, 4]) >>> a.flatten(’F’) array([1, 3, 2, 4]) ndarray.getfield(dtype, offset=0) Returns a ﬁeld of the given array as a certain type. A ﬁeld 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 ﬁts 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 dtype : str or dtype The data type of the view. The dtype size of the view can not be larger than that of the array itself. offset : int Number of bytes to skip before beginning the element view. Examples 20 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> 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.]]) ndarray.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 ﬂat index into the array, specifying which ele- ment 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 z : Standard Python scalar object A copy of the speciﬁed 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 ﬁelds are deﬁned, 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 >>> x= np.random.randint(9, size=(3,3)) >>> x array([[3, 1, 7], [2, 8, 3], [8, 5, 3]]) >>> x.item(3) 2 >>> x.item(7) 5 >>> x.item((0,1)) 1 >>> x.item((2,2)) 3 1.1. The N-dimensional array (ndarray) 21 NumPy Reference, Release 1.8.1 ndarray.itemset(*args) Insert scalar into an array (scalar is cast to array’s dtype, if possible) There must be at least 1 argument, and deﬁne the last argument as item. Then, a.itemset(*args) is equivalent to but faster than a[args] = item. The item should be a scalar value and args must select a single item in the array a. Parameters *args : Arguments If one argument: a scalar, only used in case a is of size 1. If two arguments: the last argument is the value to be set and must be a scalar, the ﬁrst argument speciﬁes a single array element location. It is either an int or a tuple. Notes Compared to indexing syntax, itemset provides some speed increase for placing a scalar into a particular location in an ndarray, if you must do this. However, generally this is discouraged: among other problems, it complicates the appearance of the code. Also, when using itemset (and item) inside a loop, be sure to assign the methods to a local variable to avoid the attribute look-up at each loop iteration. Examples >>> x= np.random.randint(9, size=(3,3)) >>> x array([[3, 1, 7], [2, 8, 3], [8, 5, 3]]) >>> x.itemset(4,0) >>> x.itemset((2,2),9) >>> x array([[3, 1, 7], [2, 0, 3], [8, 5, 9]]) ndarray.max(axis=None, out=None) Return the maximum along a given axis. Refer to numpy.amax for full documentation. See Also: numpy.amax equivalent function ndarray.mean(axis=None, dtype=None, out=None) Returns the average of the array elements along given axis. Refer to numpy.mean for full documentation. See Also: numpy.mean equivalent function ndarray.min(axis=None, out=None) Return the minimum along a given axis. Refer to numpy.amin for full documentation. See Also: 22 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.amin equivalent function ndarray.newbyteorder(new_order=’S’) Return the array with the same data viewed with a different byte order. Equivalent to: arr.view(arr.dtype.newbytorder(new_order)) Changes are also made in all ﬁelds and sub-arrays of the array data type. Parameters new_order : string, optional Byte order to force; a value from the byte order speciﬁcations above. new_order codes can be any of: *’S’ - swap dtype from current to opposite endian *{’<’, ’L’} - little endian *{’>’, ’B’} - big endian *{’=’, ’N’} - native order *{’|’, ’I’} - ignore (no change to byte order) The default value (‘S’) results in swapping the current byte order. The code does a case-insensitive check on the ﬁrst letter of new_order for the alternatives above. For example, any of ‘B’ or ‘b’ or ‘biggish’ are valid to specify big-endian. Returns new_arr : array New array object with the dtype reﬂecting given change to the byte order. ndarray.nonzero() Return the indices of the elements that are non-zero. Refer to numpy.nonzero for full documentation. See Also: numpy.nonzero equivalent function ndarray.partition(kth, axis=-1, kind=’introselect’, order=None) Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. All elements smaller than the kth element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undeﬁned. New in version 1.8.0. Parameters kth : int or sequence of ints Element index to partition by. The kth element value will be in its ﬁnal sorted position and all smaller elements will be moved before it and all equal or greater elements behind it. The order all elements in the partitions is undeﬁned. If provided with a sequence of kth it will partition all elements indexed by kth of them into their sorted position at once. axis : int, optional Axis along which to sort. Default is -1, which means sort along the last axis. 1.1. The N-dimensional array (ndarray) 23 NumPy Reference, Release 1.8.1 kind : {‘introselect’}, optional Selection algorithm. Default is ‘introselect’. order : list, optional When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. See Also: numpy.partition Return a parititioned copy of an array. argpartition Indirect partition. sort Full sort. Notes See np.partition for notes on the different algorithms. Examples >>> a= np.array([3,4,2,1]) >>> a.partition(a,3) >>> a array([2, 1, 3, 4]) >>> a.partition((1,3)) array([1, 2, 3, 4]) ndarray.prod(axis=None, dtype=None, out=None) Return the product of the array elements over the given axis Refer to numpy.prod for full documentation. See Also: numpy.prod equivalent function ndarray.ptp(axis=None, out=None) Peak to peak (maximum - minimum) value along a given axis. Refer to numpy.ptp for full documentation. See Also: numpy.ptp equivalent function ndarray.put(indices, values, mode=’raise’) Set a.flat[n] = values[n] for all n in indices. Refer to numpy.put for full documentation. See Also: 24 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.put equivalent function ndarray.ravel([order ]) Return a ﬂattened array. Refer to numpy.ravel for full documentation. See Also: numpy.ravel equivalent function ndarray.flat a ﬂat iterator on the array. ndarray.repeat(repeats, axis=None) Repeat elements of an array. Refer to numpy.repeat for full documentation. See Also: numpy.repeat equivalent function ndarray.reshape(shape, order=’C’) Returns an array containing the same data with a new shape. Refer to numpy.reshape for full documentation. See Also: numpy.reshape equivalent function ndarray.resize(new_shape, refcheck=True) Change shape and size of array in-place. Parameters new_shape : tuple of ints, or n ints Shape of resized array. refcheck : bool, optional If False, reference count will not be checked. Default is True. Returns None Raises ValueError If a does not own its own data or references or views to it exist, and the data memory must be changed. SystemError If the order keyword argument is speciﬁed. This behaviour is a bug in NumPy. See Also: 1.1. The N-dimensional array (ndarray) 25 NumPy Reference, Release 1.8.1 resize Return a new array with the speciﬁed shape. Notes This reallocates space for the data area if necessary. Only contiguous arrays (data elements consecutive in memory) can be resized. The purpose of the reference count check is to make sure you do not use this array as a buffer for another Python object and then reallocate the memory. However, reference counts can increase in other ways so if you are sure that you have not shared the memory for this array with another Python object, then you may safely set refcheck to False. Examples Shrinking an array: array is ﬂattened (in the order that the data are stored in memory), resized, and re- shaped: >>> a= np.array([[0,1], [2,3]], order=’C’) >>> a.resize((2,1)) >>> a array([[0], [1]]) >>> a= np.array([[0,1], [2,3]], order=’F’) >>> a.resize((2,1)) >>> a array([[0], [2]]) Enlarging an array: as above, but missing entries are ﬁlled with zeros: >>> b= np.array([[0,1], [2,3]]) >>> b.resize(2,3)# new_shape parameter doesn’t have to be a tuple >>> b array([[0, 1, 2], [3, 0, 0]]) Referencing an array prevents resizing... >>> c=a >>> a.resize((1,1)) Traceback (most recent call last): ... ValueError: cannot resize an array that has been referenced ... Unless refcheck is False: >>> a.resize((1,1), refcheck=False) >>> a array([[0]]) >>> c array([[0]]) ndarray.round(decimals=0, out=None) Return a with each element rounded to the given number of decimals. Refer to numpy.around for full documentation. See Also: 26 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.around equivalent function ndarray.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 See Also: numpy.searchsorted equivalent function ndarray.setfield(val, dtype, offset=0) Put a value into a speciﬁed place in a ﬁeld deﬁned by a data-type. Place val into a‘s ﬁeld deﬁned by dtype and beginning offset bytes into the ﬁeld. Parameters val : object Value to be placed in ﬁeld. dtype : dtype object Data-type of the ﬁeld in which to place val. offset : int, optional The number of bytes into the ﬁeld at which to place val. Returns None See Also: getfield Examples >>> 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]]) >>> x array([[ 1.00000000e+000, 1.48219694e-323, 1.48219694e-323], [ 1.48219694e-323, 1.00000000e+000, 1.48219694e-323], [ 1.48219694e-323, 1.48219694e-323, 1.00000000e+000]]) >>> x.setfield(np.eye(3), np.int32) >>> x array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]]) ndarray.setflags(write=None, align=None, uic=None) Set array ﬂags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. 1.1. The N-dimensional array (ndarray) 27 NumPy Reference, Release 1.8.1 These Boolean-valued ﬂags affect how numpy interprets the memory area used by a (see Notes below). The ALIGNED ﬂag can only be set to True if the data is actually aligned according to the type. The UPDATEIFCOPY ﬂag can never be set to True. The ﬂag 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 write : bool, optional Describes whether or not a can be written to. align : bool, optional Describes whether or not a is aligned properly for its type. uic : bool, optional Describes whether or not a is a copy of another “base” array. Notes Array ﬂags provide information about how the memory area used for the array is to be interpreted. There are 6 Boolean ﬂags in use, only three of which can be changed by the user: UPDATEIFCOPY, WRITE- ABLE, 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 com- piler); UPDATEIFCOPY (U) this array is a copy of some other array (referenced by .base). When this array is deallocated, the base array will be updated with the contents of this array. All ﬂags can be accessed using their ﬁrst (upper case) letter as well as the full name. Examples >>> 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 UPDATEIFCOPY : False >>> y.setflags(write=0, align=0) >>> y.flags C_CONTIGUOUS : True F_CONTIGUOUS : False OWNDATA : True WRITEABLE : False ALIGNED : False UPDATEIFCOPY : False >>> y.setflags(uic=1) Traceback (most recent call last): File "", line1, in ValueError: cannot set UPDATEIFCOPY flag to True 28 Chapter 1. Array objects NumPy Reference, Release 1.8.1 ndarray.sort(axis=-1, kind=’quicksort’, order=None) Sort an array, in-place. Parameters axis : int, optional Axis along which to sort. Default is -1, which means sort along the last axis. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional Sorting algorithm. Default is ‘quicksort’. order : list, optional When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. See Also: numpy.sort Return a sorted copy of an array. argsort Indirect sort. lexsort Indirect stable sort on multiple keys. searchsorted Find elements in sorted array. partition Partial sort. Notes See sort for notes on the different sorting algorithms. Examples >>> a= np.array([[1,4], [3,1]]) >>> a.sort(axis=1) >>> a array([[1, 4], [1, 3]]) >>> a.sort(axis=0) >>> a array([[1, 3], [1, 4]]) Use the order keyword to specify a ﬁeld to use when sorting a structured array: >>> a= np.array([(’a’,2), (’c’,1)], dtype=[(’x’,’S1’), (’y’, int)]) >>> a.sort(order=’y’) >>> a array([(’c’, 1), (’a’, 2)], dtype=[(’x’, ’|S1’), (’y’, ’>> a= np.array([1,2]) >>> a.tolist() [1, 2] >>> a= np.array([[1,2], [3,4]]) >>> list(a) [array([1, 2]), array([3, 4])] >>> a.tolist() [[1, 2], [3, 4]] ndarray.tostring(order=’C’) Construct a Python string containing the raw data bytes in the array. Constructs a Python string showing a copy of the raw contents of data memory. The string can be produced in either ‘C’ or ‘Fortran’, or ‘Any’ order (the default is ‘C’-order). ‘Any’ order means C-order unless the F_CONTIGUOUS ﬂag in the array is set, in which case it means ‘Fortran’ order. Parameters order : {‘C’, ‘F’, None}, optional Order of the data for multidimensional arrays: C, Fortran, or the same as for the original array. Returns s : str A Python string exhibiting a copy of a‘s raw data. 1.1. The N-dimensional array (ndarray) 31 NumPy Reference, Release 1.8.1 Examples >>> x= np.array([[0,1], [2,3]]) >>> x.tostring() ’\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00’ >>> x.tostring(’C’) ==x.tostring() True >>> x.tostring(’F’) ’\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00’ ndarray.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. See Also: numpy.trace equivalent function ndarray.transpose(*axes) Returns a view of the array with axes transposed. For a 1-D array, this has no effect. (To change between column and row vectors, ﬁrst cast the 1-D ar- ray into a matrix object.) For a 2-D array, this is the usual matrix transpose. For an n-D array, if axes are given, their order indicates how the axes are permuted (see Examples). If axes are not provided and a.shape = (i[0], i[1], ... i[n-2], i[n-1]), then a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0]). 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 a‘s i-th axis becomes a.transpose()‘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 out : ndarray View of a, with axes suitably permuted. See Also: ndarray.T Array property returning the array transposed. Examples >>> 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], 32 Chapter 1. Array objects NumPy Reference, Release 1.8.1 [2, 4]]) >>> a.transpose(1,0) array([[1, 3], [2, 4]]) ndarray.var(axis=None, dtype=None, out=None, ddof=0) Returns the variance of the array elements, along given axis. Refer to numpy.var for full documentation. See Also: numpy.var equivalent function ndarray.view(dtype=None, type=None) New view of array with the same data. Parameters dtype : data-type or ndarray sub-class, optional Data-type descriptor of the returned view, e.g., ﬂoat32 or int16. The default, None, results in the view having the same data-type as a. This argument can also be speciﬁed as an ndarray sub-class, which then speciﬁes the type of the returned object (this is equivalent to setting the type parameter). type : Python type, optional Type of the returned view, e.g., ndarray or matrix. Again, the default None results in type preservation. 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 reinter- pretation of the memory. For a.view(some_dtype), if some_dtype has a different number of bytes per entry than the pre- vious dtype (for example, converting a regular array to a structured array), then the behavior of the view cannot be predicted just from the superﬁcial 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 deﬁned as a slice or transpose, etc., the view may give different results. Examples >>> x= np.array([(1,2)], dtype=[(’a’, np.int8), (’b’, np.int8)]) Viewing array data using a different type and dtype: >>> y=x.view(dtype=np.int16, type=np.matrix) >>> y matrix([[513]], dtype=int16) >>> print type(y) 1.1. The N-dimensional array (ndarray) 33 NumPy Reference, Release 1.8.1 Creating a view on a structured array so it can be used in calculations >>> x= np.array([(1,2),(3,4)], dtype=[(’a’, np.int8), (’b’, np.int8)]) >>> xv=x.view(dtype=np.int8).reshape(-1,2) >>> xv array([[1, 2], [3, 4]], dtype=int8) >>> xv.mean(0) array([ 2., 3.]) Making changes to the view changes the underlying array >>> xv[0,1]= 20 >>> print x [(1, 20) (3, 4)] Using a view to convert an array to a record array: >>> z=x.view(np.recarray) >>> z.a array([1], dtype=int8) Views share data: >>> x[0]=(9, 10) >>> z[0] (9, 10) Views that change the dtype size (bytes per entry) should normally be avoided on arrays deﬁned by slices, transposes, fortran-ordering, etc.: >>> x= np.array([[1,2,3],[4,5,6]], dtype=np.int16) >>> y= x[:,0:2] >>> y array([[1, 2], [4, 5]], dtype=int16) >>> y.view(dtype=[(’width’, np.int16), (’length’, np.int16)]) Traceback (most recent call last): File "", line1, in ValueError: new type not compatible with array. >>> z=y.copy() >>> z.view(dtype=[(’width’, np.int16), (’length’, np.int16)]) array([[(1, 2)], [(4, 5)]], dtype=[(’width’, ’>> x= np.array([1,2,3,4]) >>> x.shape (4,) >>> y= np.zeros((2,3,4)) >>> y.shape (2, 3, 4) >>> y.shape=(3,8) >>> y array([[ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.]]) >>> y.shape=(3,6) Traceback (most recent call last): File "", line1, in ValueError: total size of new array must be unchanged ndarray.strides Tuple of bytes to step in each dimension when traversing an array. 1.1. The N-dimensional array (ndarray) 37 NumPy Reference, Release 1.8.1 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 “ndarray.rst” ﬁle in the NumPy reference guide. See Also: numpy.lib.stride_tricks.as_strided 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 >>> y= np.reshape(np.arange(2 *3*4), (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]]]) >>> y.strides (48, 16, 4) >>> y[1,1,1] 17 >>> offset=sum(y.strides * np.array((1,1,1))) >>> offset/y.itemsize 17 >>> x= np.reshape(np.arange(5 *6*7*8), (5,6,7,8)).transpose(2,3,1,0) >>> x.strides (32, 4, 224, 1344) >>> i= np.array([3,5,2,2]) >>> offset= sum(i * x.strides) >>> x[3,5,2,2] 813 >>> offset/x.itemsize 813 ndarray.ndim Number of array dimensions. Examples >>> x= np.array([1,2,3]) >>> x.ndim 1 >>> y= np.zeros((2,3,4)) >>> y.ndim 3 38 Chapter 1. Array objects NumPy Reference, Release 1.8.1 ndarray.data Python buffer object pointing to the start of the array’s data. ndarray.size Number of elements in the array. Equivalent to np.prod(a.shape), i.e., the product of the array’s dimensions. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.size 30 >>> np.prod(x.shape) 30 ndarray.itemsize Length of one array element in bytes. Examples >>> x= np.array([1,2,3], dtype=np.float64) >>> x.itemsize 8 >>> x= np.array([1,2,3], dtype=np.complex128) >>> x.itemsize 16 ndarray.nbytes Total bytes consumed by the elements of the array. Notes Does not include memory consumed by non-element attributes of the array object. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.nbytes 480 >>> np.prod(x.shape) * x.itemsize 480 ndarray.base Base object if memory is from some other object. Examples The base of an array that owns its memory is None: >>> 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 1.1. The N-dimensional array (ndarray) 39 NumPy Reference, Release 1.8.1 Data type See Also: Data type objects The data type object associated with the array can be found in the dtype attribute: ndarray.dtype Data-type of the array’s elements. ndarray.dtype Data-type of the array’s elements. Parameters None Returns d : numpy dtype object See Also: numpy.dtype Examples >>> x array([[0, 1], [2, 3]]) >>> x.dtype dtype(’int32’) >>> type(x.dtype) Other attributes ndarray.T Same as self.transpose(), except that self is returned if self.ndim < 2. ndarray.real The real part of the array. ndarray.imag The imaginary part of the array. ndarray.flat A 1-D iterator over the array. ndarray.ctypes An object to simplify the interaction of the array with the ctypes module. __array_priority__ ndarray.T Same as self.transpose(), except that self is returned if self.ndim < 2. Examples >>> x= np.array([[1.,2.],[3.,4.]]) >>> x array([[ 1., 2.], [ 3., 4.]]) >>> x.T array([[ 1., 3.], [ 2., 4.]]) >>> x= np.array([1.,2.,3.,4.]) >>> x 40 Chapter 1. Array objects NumPy Reference, Release 1.8.1 array([ 1., 2., 3., 4.]) >>> x.T array([ 1., 2., 3., 4.]) ndarray.real The real part of the array. See Also: numpy.real equivalent function Examples >>> x= np.sqrt([1+0j,0+1j]) >>> x.real array([ 1. , 0.70710678]) >>> x.real.dtype dtype(’float64’) ndarray.imag The imaginary part of the array. Examples >>> x= np.sqrt([1+0j,0+1j]) >>> x.imag array([ 0. , 0.70710678]) >>> x.imag.dtype dtype(’float64’) ndarray.flat A 1-D iterator over the array. This is a numpy.flatiter instance, which acts similarly to, but is not a subclass of, Python’s built-in iterator object. See Also: flatten Return a copy of the array collapsed into one dimension. flatiter Examples >>> x= np.arange(1,7).reshape(2,3) >>> x array([[1, 2, 3], [4, 5, 6]]) >>> x.flat[3] 4 >>> x.T array([[1, 4], [2, 5], [3, 6]]) >>> x.T.flat[3] 5 1.1. The N-dimensional array (ndarray) 41 NumPy Reference, Release 1.8.1 >>> type(x.flat) An assignment example: >>> x.flat=3; x array([[3, 3, 3], [3, 3, 3]]) >>> x.flat[[1,4]]=1; x array([[3, 1, 3], [3, 1, 3]]) ndarray.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 c : Python object Possessing attributes data, shape, strides, etc. See Also: numpy.ctypeslib 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): •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 ﬂags 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]. •shape (c_intp*self.ndim): A ctypes array of length self.ndim where the basetype is the C-integer corre- sponding to dtype(‘p’) on this platform. This base-type could be c_int, c_long, or c_longlong depending on the platform. The c_intp type is deﬁned accordingly in numpy.ctypeslib. The ctypes array contains the shape of the underlying array. •strides (c_intp*self.ndim): 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. •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 ﬂoating-point data: self.data_as(ctypes.POINTER(ctypes.c_double)). •shape_as(obj): Return the shape tuple as an array of some other c-types type. For example: self.shape_as(ctypes.c_short). •strides_as(obj): Return the strides tuple as an array of some other c-types type. For example: self.strides_as(ctypes.c_longlong). 42 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Be careful using the ctypes attribute - especially on temporary arrays or arrays constructed on the ﬂy. For example, calling (a+b).ctypes.data_as(ctypes.c_void_p) returns a pointer to memory that is invalid because the array created as (a+b) is deallocated before the next Python statement. You can avoid this problem using either c=a+b or ct=(a+b).ctypes. In the latter case, ct will hold a reference to the array until ct is deleted or re-assigned. 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 ctypes >>> x array([[0, 1], [2, 3]]) >>> x.ctypes.data 30439712 >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents c_long(0) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents c_longlong(4294967296L) >>> x.ctypes.shape >>> x.ctypes.shape_as(ctypes.c_long) >>> x.ctypes.strides >>> x.ctypes.strides_as(ctypes.c_longlong) Array interface See Also: The Array Interface. __array_interface__ Python-side of the array interface __array_struct__ C-side of the array interface ctypes foreign function interface ndarray.ctypes An object to simplify the interaction of the array with the ctypes module. ndarray.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 1.1. The N-dimensional array (ndarray) 43 NumPy Reference, Release 1.8.1 Returns c : Python object Possessing attributes data, shape, strides, etc. See Also: numpy.ctypeslib 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): •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 ﬂags 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]. •shape (c_intp*self.ndim): A ctypes array of length self.ndim where the basetype is the C-integer corre- sponding to dtype(‘p’) on this platform. This base-type could be c_int, c_long, or c_longlong depending on the platform. The c_intp type is deﬁned accordingly in numpy.ctypeslib. The ctypes array contains the shape of the underlying array. •strides (c_intp*self.ndim): 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. •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 ﬂoating-point data: self.data_as(ctypes.POINTER(ctypes.c_double)). •shape_as(obj): Return the shape tuple as an array of some other c-types type. For example: self.shape_as(ctypes.c_short). •strides_as(obj): Return the strides tuple as an array of some other c-types type. For example: self.strides_as(ctypes.c_longlong). Be careful using the ctypes attribute - especially on temporary arrays or arrays constructed on the ﬂy. For example, calling (a+b).ctypes.data_as(ctypes.c_void_p) returns a pointer to memory that is invalid because the array created as (a+b) is deallocated before the next Python statement. You can avoid this problem using either c=a+b or ct=(a+b).ctypes. In the latter case, ct will hold a reference to the array until ct is deleted or re-assigned. 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 ctypes >>> x array([[0, 1], [2, 3]]) >>> x.ctypes.data 30439712 >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents 44 Chapter 1. Array objects NumPy Reference, Release 1.8.1 c_long(0) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents c_longlong(4294967296L) >>> x.ctypes.shape >>> x.ctypes.shape_as(ctypes.c_long) >>> x.ctypes.strides >>> x.ctypes.strides_as(ctypes.c_longlong) 1.1.5 Array methods An ndarray object has many methods which operate on or with the array in some fashion, typically returning an array result. These methods are brieﬂy explained below. (Each method’s docstring has a more complete description.) For the following methods there are also corresponding functions in numpy: all, any, argmax, argmin, argpartition, argsort, choose, clip, compress, copy, cumprod, cumsum, diagonal, imag, max, mean, min, nonzero, partition, prod, ptp, put, ravel, real, repeat, reshape, round, searchsorted, sort, squeeze, std, sum, swapaxes, take, trace, transpose, var. Array conversion ndarray.item(*args) Copy an element of an array to a standard Python scalar and return it. ndarray.tolist() Return the array as a (possibly nested) list. ndarray.itemset(*args) Insert scalar into an array (scalar is cast to array’s dtype, if possible) ndarray.setasflat ndarray.tostring([order]) Construct a Python string containing the raw data bytes in the array. ndarray.tofile(ﬁd[, sep, format]) Write array to a ﬁle as text or binary (default). ndarray.dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. ndarray.dumps() Returns the pickle of the array as a string. ndarray.astype(dtype[, order, casting, ...]) Copy of the array, cast to a speciﬁed type. ndarray.byteswap(inplace) Swap the bytes of the array elements ndarray.copy([order]) Return a copy of the array. ndarray.view([dtype, type]) New view of array with the same data. ndarray.getfield(dtype[, offset]) Returns a ﬁeld of the given array as a certain type. ndarray.setflags([write, align, uic]) Set array ﬂags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. ndarray.fill(value) Fill the array with a scalar value. ndarray.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 ﬂat 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 1.1. The N-dimensional array (ndarray) 45 NumPy Reference, Release 1.8.1 interpreted as an nd-index into the array. Returns z : Standard Python scalar object A copy of the speciﬁed 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 ﬁelds are deﬁned, 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 >>> x= np.random.randint(9, size=(3,3)) >>> x array([[3, 1, 7], [2, 8, 3], [8, 5, 3]]) >>> x.item(3) 2 >>> x.item(7) 5 >>> x.item((0,1)) 1 >>> x.item((2,2)) 3 ndarray.tolist() Return the array as a (possibly nested) list. Return a copy of the array data as a (nested) Python list. Data items are converted to the nearest compatible Python type. Parameters none Returns y : list The possibly nested list of array elements. Notes The array may be recreated, a = np.array(a.tolist()). Examples >>> a= np.array([1,2]) >>> a.tolist() [1, 2] >>> a= np.array([[1,2], [3,4]]) >>> list(a) [array([1, 2]), array([3, 4])] >>> a.tolist() [[1, 2], [3, 4]] 46 Chapter 1. Array objects NumPy Reference, Release 1.8.1 ndarray.itemset(*args) Insert scalar into an array (scalar is cast to array’s dtype, if possible) There must be at least 1 argument, and deﬁne the last argument as item. Then, a.itemset(*args) is equivalent to but faster than a[args] = item. The item should be a scalar value and args must select a single item in the array a. Parameters *args : Arguments If one argument: a scalar, only used in case a is of size 1. If two arguments: the last argument is the value to be set and must be a scalar, the ﬁrst argument speciﬁes a single array element location. It is either an int or a tuple. Notes Compared to indexing syntax, itemset provides some speed increase for placing a scalar into a particular location in an ndarray, if you must do this. However, generally this is discouraged: among other problems, it complicates the appearance of the code. Also, when using itemset (and item) inside a loop, be sure to assign the methods to a local variable to avoid the attribute look-up at each loop iteration. Examples >>> x= np.random.randint(9, size=(3,3)) >>> x array([[3, 1, 7], [2, 8, 3], [8, 5, 3]]) >>> x.itemset(4,0) >>> x.itemset((2,2),9) >>> x array([[3, 1, 7], [2, 0, 3], [8, 5, 9]]) ndarray.tostring(order=’C’) Construct a Python string containing the raw data bytes in the array. Constructs a Python string showing a copy of the raw contents of data memory. The string can be produced in either ‘C’ or ‘Fortran’, or ‘Any’ order (the default is ‘C’-order). ‘Any’ order means C-order unless the F_CONTIGUOUS ﬂag in the array is set, in which case it means ‘Fortran’ order. Parameters order : {‘C’, ‘F’, None}, optional Order of the data for multidimensional arrays: C, Fortran, or the same as for the original array. Returns s : str A Python string exhibiting a copy of a‘s raw data. Examples >>> x= np.array([[0,1], [2,3]]) >>> x.tostring() ’\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00’ >>> x.tostring(’C’) ==x.tostring() True 1.1. The N-dimensional array (ndarray) 47 NumPy Reference, Release 1.8.1 >>> x.tostring(’F’) ’\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00’ ndarray.tofile(ﬁd, sep=”“, format=”%s”) Write array to a ﬁle as text or binary (default). Data is always written in ‘C’ order, independent of the order of a. The data produced by this method can be recovered using the function fromﬁle(). Parameters ﬁd : ﬁle or str An open ﬁle object, or a string containing a ﬁlename. sep : str Separator between array items for text output. If “” (empty), a binary ﬁle is written, equivalent to file.write(a.tostring()). format : str Format string for text ﬁle output. Each entry in the array is formatted to text by ﬁrst converting it to the closest Python type, and then using “format” % item. Notes This is a convenience function for quick storage of array data. Information on endianness and precision is lost, so this method is not a good choice for ﬁles intended to archive data or transport data between machines with different endianness. Some of these problems can be overcome by outputting the data as text ﬁles, at the expense of speed and ﬁle size. ndarray.dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. The array can be read back with pickle.load or numpy.load. Parameters ﬁle : str A string naming the dump ﬁle. ndarray.dumps() Returns the pickle of the array as a string. pickle.loads or numpy.loads will convert the string back to an array. Parameters None ndarray.astype(dtype, order=’K’, casting=’unsafe’, subok=True, copy=True) Copy of the array, cast to a speciﬁed type. Parameters dtype : str 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 com- patibility. 48 Chapter 1. Array objects NumPy Reference, Release 1.8.1 • ‘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 ﬂoat64 to ﬂoat32, are allowed. • ‘unsafe’ means any data conversions may be done. subok : bool, optional If True, then sub-classes will be passed-through (default), otherwise the returned array will be forced to be a base-class array. copy : bool, optional By default, astype always returns a newly allocated array. If this is set to false, and the dtype, order, and subok requirements are satisﬁed, the input array is returned instead of a copy. Returns arr_t : ndarray Unless copy is False and the other conditions for returning the input array are satisﬁed (see description for copy input paramter), 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 ﬂoat or int. To avoid this, one should use a.real.astype(t). Examples >>> x= np.array([1,2, 2.5]) >>> x array([ 1. , 2. , 2.5]) >>> x.astype(int) array([1, 2, 2]) ndarray.byteswap(inplace) 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. Parameters inplace : bool, optional If True, swap bytes in-place, default is False. Returns out : ndarray The byteswapped array. If inplace is True, this is a view to self. Examples 1.1. The N-dimensional array (ndarray) 49 NumPy Reference, Release 1.8.1 >>> A= np.array([1, 256, 8755], dtype=np.int16) >>> map(hex, A) [’0x1’, ’0x100’, ’0x2233’] >>> A.byteswap(True) array([ 256, 1, 13090], dtype=int16) >>> map(hex, A) [’0x100’, ’0x1’, ’0x3322’] Arrays of strings are not swapped >>> A= np.array([’ceg’,’fac’]) >>> A.byteswap() array([’ceg’, ’fac’], dtype=’|S3’) ndarray.copy(order=’C’) Return a copy of the array. 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 :func:numpy.copy are very similar, but have different default values for their order= arguments.) See Also: numpy.copy, numpy.copyto Examples >>> 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 ndarray.view(dtype=None, type=None) New view of array with the same data. Parameters dtype : data-type or ndarray sub-class, optional Data-type descriptor of the returned view, e.g., ﬂoat32 or int16. The default, None, results in the view having the same data-type as a. This argument can also be speciﬁed as an ndarray sub-class, which then speciﬁes the type of the returned object (this is equivalent to setting the type parameter). type : Python type, optional 50 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Type of the returned view, e.g., ndarray or matrix. Again, the default None results in type preservation. 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. 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 superﬁcial 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 deﬁned as a slice or transpose, etc., the view may give different results. Examples >>> x= np.array([(1,2)], dtype=[(’a’, np.int8), (’b’, np.int8)]) Viewing array data using a different type and dtype: >>> y=x.view(dtype=np.int16, type=np.matrix) >>> y matrix([[513]], dtype=int16) >>> print type(y) Creating a view on a structured array so it can be used in calculations >>> x= np.array([(1,2),(3,4)], dtype=[(’a’, np.int8), (’b’, np.int8)]) >>> xv=x.view(dtype=np.int8).reshape(-1,2) >>> xv array([[1, 2], [3, 4]], dtype=int8) >>> xv.mean(0) array([ 2., 3.]) Making changes to the view changes the underlying array >>> xv[0,1]= 20 >>> print x [(1, 20) (3, 4)] Using a view to convert an array to a record array: >>> z=x.view(np.recarray) >>> z.a array([1], dtype=int8) Views share data: >>> x[0]=(9, 10) >>> z[0] (9, 10) 1.1. The N-dimensional array (ndarray) 51 NumPy Reference, Release 1.8.1 Views that change the dtype size (bytes per entry) should normally be avoided on arrays deﬁned by slices, transposes, fortran-ordering, etc.: >>> x= np.array([[1,2,3],[4,5,6]], dtype=np.int16) >>> y= x[:,0:2] >>> y array([[1, 2], [4, 5]], dtype=int16) >>> y.view(dtype=[(’width’, np.int16), (’length’, np.int16)]) Traceback (most recent call last): File "", line1, in ValueError: new type not compatible with array. >>> z=y.copy() >>> z.view(dtype=[(’width’, np.int16), (’length’, np.int16)]) array([[(1, 2)], [(4, 5)]], dtype=[(’width’, ’>> 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.]]) ndarray.setflags(write=None, align=None, uic=None) Set array ﬂags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. These Boolean-valued ﬂags affect how numpy interprets the memory area used by a (see Notes below). The ALIGNED ﬂag can only be set to True if the data is actually aligned according to the type. The UPDATEIF- COPY ﬂag can never be set to True. The ﬂag 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.) 52 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Parameters write : bool, optional Describes whether or not a can be written to. align : bool, optional Describes whether or not a is aligned properly for its type. uic : bool, optional Describes whether or not a is a copy of another “base” array. Notes Array ﬂags provide information about how the memory area used for the array is to be interpreted. There are 6 Boolean ﬂags in use, only three of which can be changed by the user: UPDATEIFCOPY, 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); UPDATEIFCOPY (U) this array is a copy of some other array (referenced by .base). When this array is deallo- cated, the base array will be updated with the contents of this array. All ﬂags can be accessed using their ﬁrst (upper case) letter as well as the full name. Examples >>> 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 UPDATEIFCOPY : False >>> y.setflags(write=0, align=0) >>> y.flags C_CONTIGUOUS : True F_CONTIGUOUS : False OWNDATA : True WRITEABLE : False ALIGNED : False UPDATEIFCOPY : False >>> y.setflags(uic=1) Traceback (most recent call last): File "", line1, in ValueError: cannot set UPDATEIFCOPY flag to True ndarray.fill(value) Fill the array with a scalar value. Parameters value : scalar All elements of a will be assigned this value. 1.1. The N-dimensional array (ndarray) 53 NumPy Reference, Release 1.8.1 Examples >>> a= np.array([1,2]) >>> a.fill(0) >>> a array([0, 0]) >>> a= np.empty(2) >>> a.fill(1) >>> a array([ 1., 1.]) Shape manipulation For reshape, resize, and transpose, the single tuple argument may be replaced with n integers which will be interpreted as an n-tuple. ndarray.reshape(shape[, order]) Returns an array containing the same data with a new shape. ndarray.resize(new_shape[, refcheck]) Change shape and size of array in-place. ndarray.transpose(*axes) Returns a view of the array with axes transposed. ndarray.swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. ndarray.flatten([order]) Return a copy of the array collapsed into one dimension. ndarray.ravel([order]) Return a ﬂattened array. ndarray.squeeze([axis]) Remove single-dimensional entries from the shape of a. ndarray.reshape(shape, order=’C’) Returns an array containing the same data with a new shape. Refer to numpy.reshape for full documentation. See Also: numpy.reshape equivalent function ndarray.resize(new_shape, refcheck=True) Change shape and size of array in-place. Parameters new_shape : tuple of ints, or n ints Shape of resized array. refcheck : bool, optional If False, reference count will not be checked. Default is True. Returns None Raises ValueError If a does not own its own data or references or views to it exist, and the data memory must be changed. SystemError If the order keyword argument is speciﬁed. This behaviour is a bug in NumPy. 54 Chapter 1. Array objects NumPy Reference, Release 1.8.1 See Also: resize Return a new array with the speciﬁed shape. Notes This reallocates space for the data area if necessary. Only contiguous arrays (data elements consecutive in memory) can be resized. The purpose of the reference count check is to make sure you do not use this array as a buffer for another Python object and then reallocate the memory. However, reference counts can increase in other ways so if you are sure that you have not shared the memory for this array with another Python object, then you may safely set refcheck to False. Examples Shrinking an array: array is ﬂattened (in the order that the data are stored in memory), resized, and reshaped: >>> a= np.array([[0,1], [2,3]], order=’C’) >>> a.resize((2,1)) >>> a array([[0], [1]]) >>> a= np.array([[0,1], [2,3]], order=’F’) >>> a.resize((2,1)) >>> a array([[0], [2]]) Enlarging an array: as above, but missing entries are ﬁlled with zeros: >>> b= np.array([[0,1], [2,3]]) >>> b.resize(2,3)# new_shape parameter doesn’t have to be a tuple >>> b array([[0, 1, 2], [3, 0, 0]]) Referencing an array prevents resizing... >>> c=a >>> a.resize((1,1)) Traceback (most recent call last): ... ValueError: cannot resize an array that has been referenced ... Unless refcheck is False: >>> a.resize((1,1), refcheck=False) >>> a array([[0]]) >>> c array([[0]]) ndarray.transpose(*axes) Returns a view of the array with axes transposed. For a 1-D array, this has no effect. (To change between column and row vectors, ﬁrst cast the 1-D array into a ma- trix object.) For a 2-D array, this is the usual matrix transpose. For an n-D array, if axes are given, their order in- 1.1. The N-dimensional array (ndarray) 55 NumPy Reference, Release 1.8.1 dicates how the axes are permuted (see Examples). If axes are not provided and a.shape = (i[0], i[1], ... i[n-2], i[n-1]), then a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0]). 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 a‘s i-th axis becomes a.transpose()‘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 out : ndarray View of a, with axes suitably permuted. See Also: ndarray.T Array property returning the array transposed. Examples >>> 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]]) ndarray.swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. Refer to numpy.swapaxes for full documentation. See Also: numpy.swapaxes equivalent function ndarray.flatten(order=’C’) Return a copy of the array collapsed into one dimension. Parameters order : {‘C’, ‘F’, ‘A’}, optional Whether to ﬂatten in C (row-major), Fortran (column-major) order, or preserve the C/Fortran ordering from a. The default is ‘C’. Returns y : ndarray 56 Chapter 1. Array objects NumPy Reference, Release 1.8.1 A copy of the input array, ﬂattened to one dimension. See Also: ravel Return a ﬂattened array. flat A 1-D ﬂat iterator over the array. Examples >>> a= np.array([[1,2], [3,4]]) >>> a.flatten() array([1, 2, 3, 4]) >>> a.flatten(’F’) array([1, 3, 2, 4]) ndarray.ravel([order ]) Return a ﬂattened array. Refer to numpy.ravel for full documentation. See Also: numpy.ravel equivalent function ndarray.flat a ﬂat iterator on the array. ndarray.squeeze(axis=None) Remove single-dimensional entries from the shape of a. Refer to numpy.squeeze for full documentation. See Also: numpy.squeeze equivalent function Item selection and manipulation For array methods that take an axis keyword, it defaults to None. If axis is None, then the array is treated as a 1-D array. Any other value for axis represents the dimension along which the operation should proceed. ndarray.take(indices[, axis, out, mode]) Return an array formed from the elements of a at the given indices. ndarray.put(indices, values[, mode]) Set a.flat[n] = values[n] for all n in indices. ndarray.repeat(repeats[, axis]) Repeat elements of an array. ndarray.choose(choices[, out, mode]) Use an index array to construct a new array from a set of choices. ndarray.sort([axis, kind, order]) Sort an array, in-place. ndarray.argsort([axis, kind, order]) Returns the indices that would sort this array. ndarray.partition(kth[, axis, kind, order]) Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. ndarray.argpartition(kth[, axis, kind, order]) Returns the indices that would partition this array. ndarray.searchsorted(v[, side, sorter]) Find indices where elements of v should be inserted in a to maintain order. ndarray.nonzero() Return the indices of the elements that are non-zero. Continued on next page 1.1. The N-dimensional array (ndarray) 57 NumPy Reference, Release 1.8.1 Table 1.10 – continued from previous page ndarray.compress(condition[, axis, out]) Return selected slices of this array along given axis. ndarray.diagonal([offset, axis1, axis2]) Return speciﬁed diagonals. ndarray.take(indices, axis=None, out=None, mode=’raise’) Return an array formed from the elements of a at the given indices. Refer to numpy.take for full documentation. See Also: numpy.take equivalent function ndarray.put(indices, values, mode=’raise’) Set a.flat[n] = values[n] for all n in indices. Refer to numpy.put for full documentation. See Also: numpy.put equivalent function ndarray.repeat(repeats, axis=None) Repeat elements of an array. Refer to numpy.repeat for full documentation. See Also: numpy.repeat equivalent function ndarray.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. See Also: numpy.choose equivalent function ndarray.sort(axis=-1, kind=’quicksort’, order=None) Sort an array, in-place. Parameters axis : int, optional Axis along which to sort. Default is -1, which means sort along the last axis. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional Sorting algorithm. Default is ‘quicksort’. order : list, optional When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. 58 Chapter 1. Array objects NumPy Reference, Release 1.8.1 See Also: numpy.sort Return a sorted copy of an array. argsort Indirect sort. lexsort Indirect stable sort on multiple keys. searchsorted Find elements in sorted array. partition Partial sort. Notes See sort for notes on the different sorting algorithms. Examples >>> a= np.array([[1,4], [3,1]]) >>> a.sort(axis=1) >>> a array([[1, 4], [1, 3]]) >>> a.sort(axis=0) >>> a array([[1, 3], [1, 4]]) Use the order keyword to specify a ﬁeld to use when sorting a structured array: >>> a= np.array([(’a’,2), (’c’,1)], dtype=[(’x’,’S1’), (’y’, int)]) >>> a.sort(order=’y’) >>> a array([(’c’, 1), (’a’, 2)], dtype=[(’x’, ’|S1’), (’y’, ’>> a= np.array([3,4,2,1]) >>> a.partition(a,3) >>> a array([2, 1, 3, 4]) >>> a.partition((1,3)) array([1, 2, 3, 4]) ndarray.argpartition(kth, axis=-1, kind=’introselect’, order=None) Returns the indices that would partition this array. Refer to numpy.argpartition for full documentation. New in version 1.8.0. See Also: numpy.argpartition equivalent function ndarray.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 See Also: numpy.searchsorted equivalent function 60 Chapter 1. Array objects NumPy Reference, Release 1.8.1 ndarray.nonzero() Return the indices of the elements that are non-zero. Refer to numpy.nonzero for full documentation. See Also: numpy.nonzero equivalent function ndarray.compress(condition, axis=None, out=None) Return selected slices of this array along given axis. Refer to numpy.compress for full documentation. See Also: numpy.compress equivalent function ndarray.diagonal(offset=0, axis1=0, axis2=1) Return speciﬁed diagonals. Refer to numpy.diagonal for full documentation. See Also: numpy.diagonal equivalent function Calculation Many of these methods take an argument named axis. In such cases, • If axis is None (the default), the array is treated as a 1-D array and the operation is performed over the entire array. This behavior is also the default if self is a 0-dimensional array or array scalar. (An array scalar is an instance of the types/classes ﬂoat32, ﬂoat64, etc., whereas a 0-dimensional array is an ndarray instance containing precisely one array scalar.) • If axis is an integer, then the operation is done over the given axis (for each 1-D subarray that can be created along the given axis). Example of the axis argument A 3-dimensional array of size 3 x 3 x 3, summed over each of its three axes >>> x 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], [24, 25, 26]]]) >>> x.sum(axis=0) array([[27, 30, 33], [36, 39, 42], 1.1. The N-dimensional array (ndarray) 61 NumPy Reference, Release 1.8.1 [45, 48, 51]]) >>> # for sum, axis is the first keyword, so we may omit it, >>> # specifying only its value >>> x.sum(0), x.sum(1), x.sum(2) (array([[27, 30, 33], [36, 39, 42], [45, 48, 51]]), array([[ 9, 12, 15], [36, 39, 42], [63, 66, 69]]), array([[ 3, 12, 21], [30, 39, 48], [57, 66, 75]])) The parameter dtype speciﬁes the data type over which a reduction operation (like summing) should take place. The default reduce data type is the same as the data type of self. To avoid overﬂow, it can be useful to perform the reduction using a larger data type. For several methods, an optional out argument can also be provided and the result will be placed into the output array given. The out argument must be an ndarray and have the same number of elements. It can have a different data type in which case casting will be performed. ndarray.argmax([axis, out]) Return indices of the maximum values along the given axis. ndarray.min([axis, out]) Return the minimum along a given axis. ndarray.argmin([axis, out]) Return indices of the minimum values along the given axis of a. ndarray.ptp([axis, out]) Peak to peak (maximum - minimum) value along a given axis. ndarray.clip(a_min, a_max[, out]) Return an array whose values are limited to [a_min, a_max]. ndarray.conj() Complex-conjugate all elements. ndarray.round([decimals, out]) Return a with each element rounded to the given number of decimals. ndarray.trace([offset, axis1, axis2, dtype, out]) Return the sum along diagonals of the array. ndarray.sum([axis, dtype, out]) Return the sum of the array elements over the given axis. ndarray.cumsum([axis, dtype, out]) Return the cumulative sum of the elements along the given axis. ndarray.mean([axis, dtype, out]) Returns the average of the array elements along given axis. ndarray.var([axis, dtype, out, ddof]) Returns the variance of the array elements, along given axis. ndarray.std([axis, dtype, out, ddof]) Returns the standard deviation of the array elements along given axis. ndarray.prod([axis, dtype, out]) Return the product of the array elements over the given axis ndarray.cumprod([axis, dtype, out]) Return the cumulative product of the elements along the given axis. ndarray.all([axis, out]) Returns True if all elements evaluate to True. ndarray.any([axis, out]) Returns True if any of the elements of a evaluate to True. ndarray.argmax(axis=None, out=None) Return indices of the maximum values along the given axis. Refer to numpy.argmax for full documentation. See Also: numpy.argmax equivalent function ndarray.min(axis=None, out=None) Return the minimum along a given axis. Refer to numpy.amin for full documentation. 62 Chapter 1. Array objects NumPy Reference, Release 1.8.1 See Also: numpy.amin equivalent function ndarray.argmin(axis=None, out=None) Return indices of the minimum values along the given axis of a. Refer to numpy.argmin for detailed documentation. See Also: numpy.argmin equivalent function ndarray.ptp(axis=None, out=None) Peak to peak (maximum - minimum) value along a given axis. Refer to numpy.ptp for full documentation. See Also: numpy.ptp equivalent function ndarray.clip(a_min, a_max, out=None) Return an array whose values are limited to [a_min, a_max]. Refer to numpy.clip for full documentation. See Also: numpy.clip equivalent function ndarray.conj() Complex-conjugate all elements. Refer to numpy.conjugate for full documentation. See Also: numpy.conjugate equivalent function ndarray.round(decimals=0, out=None) Return a with each element rounded to the given number of decimals. Refer to numpy.around for full documentation. See Also: numpy.around equivalent function ndarray.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. 1.1. The N-dimensional array (ndarray) 63 NumPy Reference, Release 1.8.1 See Also: numpy.trace equivalent function ndarray.sum(axis=None, dtype=None, out=None) Return the sum of the array elements over the given axis. Refer to numpy.sum for full documentation. See Also: numpy.sum equivalent function ndarray.cumsum(axis=None, dtype=None, out=None) Return the cumulative sum of the elements along the given axis. Refer to numpy.cumsum for full documentation. See Also: numpy.cumsum equivalent function ndarray.mean(axis=None, dtype=None, out=None) Returns the average of the array elements along given axis. Refer to numpy.mean for full documentation. See Also: numpy.mean equivalent function ndarray.var(axis=None, dtype=None, out=None, ddof=0) Returns the variance of the array elements, along given axis. Refer to numpy.var for full documentation. See Also: numpy.var equivalent function ndarray.std(axis=None, dtype=None, out=None, ddof=0) Returns the standard deviation of the array elements along given axis. Refer to numpy.std for full documentation. See Also: numpy.std equivalent function ndarray.prod(axis=None, dtype=None, out=None) Return the product of the array elements over the given axis Refer to numpy.prod for full documentation. 64 Chapter 1. Array objects NumPy Reference, Release 1.8.1 See Also: numpy.prod equivalent function ndarray.cumprod(axis=None, dtype=None, out=None) Return the cumulative product of the elements along the given axis. Refer to numpy.cumprod for full documentation. See Also: numpy.cumprod equivalent function ndarray.all(axis=None, out=None) Returns True if all elements evaluate to True. Refer to numpy.all for full documentation. See Also: numpy.all equivalent function ndarray.any(axis=None, out=None) Returns True if any of the elements of a evaluate to True. Refer to numpy.any for full documentation. See Also: numpy.any equivalent function 1.1.6 Arithmetic and comparison operations Arithmetic and comparison operations on ndarrays are deﬁned as element-wise operations, and generally yield ndarray objects as results. Each of the arithmetic operations (+,-,*,/,//,%, divmod(),** or pow(), <<, >>,&, ^, |, ~) and the comparisons (==, <, >, <=, >=,!=) is equivalent to the corresponding universal function (or ufunc for short) in Numpy. For more information, see the section on Universal Functions. Comparison operators: ndarray.__lt__ x.__lt__(y) <==> x x<=y ndarray.__gt__ x.__gt__(y) <==> x>y ndarray.__ge__ x.__ge__(y) <==> x>=y ndarray.__eq__ x.__eq__(y) <==> x==y ndarray.__ne__ x.__ne__(y) <==> x!=y ndarray.__lt__ x.__lt__(y) <==> x x<=y ndarray.__gt__ x.__gt__(y) <==> x>y ndarray.__ge__ x.__ge__(y) <==> x>=y ndarray.__eq__ x.__eq__(y) <==> x==y ndarray.__ne__ x.__ne__(y) <==> x!=y Truth value of an array (bool): ndarray.__nonzero__ x.__nonzero__() <==> x != 0 ndarray.__nonzero__ x.__nonzero__() <==> x != 0 Note: Truth-value testing of an array invokes ndarray.__nonzero__, which raises an error if the number of elements in the the array is larger than 1, because the truth value of such arrays is ambiguous. Use .any() and .all() instead to be clear about what is meant in such cases. (If the number of elements is 0, the array evaluates to False.) Unary operations: ndarray.__neg__ x.__neg__() <==> -x ndarray.__pos__ x.__pos__() <==> +x ndarray.__abs__() <==> abs(x) ndarray.__invert__ x.__invert__() <==> ~x ndarray.__neg__ x.__neg__() <==> -x ndarray.__pos__ x.__pos__() <==> +x ndarray.__abs__() <==> abs(x) ndarray.__invert__ x.__invert__() <==> ~x Arithmetic: ndarray.__add__ x.__add__(y) <==> x+y ndarray.__sub__ x.__sub__(y) <==> x-y ndarray.__mul__ x.__mul__(y) <==> x*y ndarray.__div__ x.__div__(y) <==> x/y ndarray.__truediv__ x.__truediv__(y) <==> x/y ndarray.__floordiv__ x.__ﬂoordiv__(y) <==> x//y ndarray.__mod__ x.__mod__(y) <==> x%y ndarray.__divmod__(y) <==> divmod(x, y) Continued on next page 66 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Table 1.15 – continued from previous page ndarray.__pow__(y[, z]) <==> pow(x, y[, z]) ndarray.__lshift__ x.__lshift__(y) <==> x< x>>y ndarray.__and__ x.__and__(y) <==> x&y ndarray.__or__ x.__or__(y) <==> x|y ndarray.__xor__ x.__xor__(y) <==> x^y ndarray.__add__ x.__add__(y) <==> x+y ndarray.__sub__ x.__sub__(y) <==> x-y ndarray.__mul__ x.__mul__(y) <==> x*y ndarray.__div__ x.__div__(y) <==> x/y ndarray.__truediv__ x.__truediv__(y) <==> x/y ndarray.__floordiv__ x.__ﬂoordiv__(y) <==> x//y ndarray.__mod__ x.__mod__(y) <==> x%y ndarray.__divmod__(y) <==> divmod(x, y) ndarray.__pow__(y[, z]) <==> pow(x, y[, z]) ndarray.__lshift__ x.__lshift__(y) <==> x< x>>y ndarray.__and__ x.__and__(y) <==> x&y ndarray.__or__ x.__or__(y) <==> x|y ndarray.__xor__ x.__xor__(y) <==> x^y Note: • Any third argument to pow is silently ignored, as the underlying ufunc takes only two arguments. • The three division operators are all deﬁned; div is active by default, truediv is active when __future__ division is in effect. • Because ndarray is a built-in type (written in C), the __r{op}__ special methods are not directly deﬁned. • The functions called to implement many arithmetic special methods for arrays can be modiﬁed using set_numeric_ops. 1.1. The N-dimensional array (ndarray) 67 NumPy Reference, Release 1.8.1 Arithmetic, in-place: ndarray.__iadd__ x.__iadd__(y) <==> x+=y ndarray.__isub__ x.__isub__(y) <==> x-=y ndarray.__imul__ x.__imul__(y) <==> x*=y ndarray.__idiv__ x.__idiv__(y) <==> x/=y ndarray.__itruediv__ x.__itruediv__(y) <==> x/y ndarray.__ifloordiv__ x.__iﬂoordiv__(y) <==> x//y ndarray.__imod__ x.__imod__(y) <==> x%=y ndarray.__ipow__ x.__ipow__(y) <==> x**=y ndarray.__ilshift__ x.__ilshift__(y) <==> x<<=y ndarray.__irshift__ x.__irshift__(y) <==> x>>=y ndarray.__iand__ x.__iand__(y) <==> x&=y ndarray.__ior__ x.__ior__(y) <==> x|=y ndarray.__ixor__ x.__ixor__(y) <==> x^=y ndarray.__iadd__ x.__iadd__(y) <==> x+=y ndarray.__isub__ x.__isub__(y) <==> x-=y ndarray.__imul__ x.__imul__(y) <==> x*=y ndarray.__idiv__ x.__idiv__(y) <==> x/=y ndarray.__itruediv__ x.__itruediv__(y) <==> x/y ndarray.__ifloordiv__ x.__iﬂoordiv__(y) <==> x//y ndarray.__imod__ x.__imod__(y) <==> x%=y ndarray.__ipow__ x.__ipow__(y) <==> x**=y ndarray.__ilshift__ x.__ilshift__(y) <==> x<<=y ndarray.__irshift__ x.__irshift__(y) <==> x>>=y ndarray.__iand__ x.__iand__(y) <==> x&=y ndarray.__ior__ x.__ior__(y) <==> x|=y ndarray.__ixor__ x.__ixor__(y) <==> x^=y 68 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Warning: In place operations will perform the calculation using the precision decided by the data type of the two operands, but will silently downcast the result (if necessary) so it can ﬁt back into the array. Therefore, for mixed precision calculations, A {op}= B can be different than A = A {op} B. For example, suppose a = ones((3,3)). Then, a += 3j is different than a = a + 3j: while they both perform the same computation, a += 3 casts the result to ﬁt back in a, whereas a = a + 3j re-binds the name a to the result. 1.1.7 Special methods For standard library functions: ndarray.__copy__([order]) Return a copy of the array. ndarray.__deepcopy__(() -> Deep copy of array.) Used if copy.deepcopy is called on an array. ndarray.__reduce__() For pickling. ndarray.__setstate__(version, shape, dtype, ...) For unpickling. ndarray.__copy__([order ]) Return a copy of the array. Parameters order : {‘C’, ‘F’, ‘A’}, optional If order is ‘C’ (False) then the result is contiguous (default). If order is ‘Fortran’ (True) then the result has fortran order. If order is ‘Any’ (None) then the result has fortran order only if the array already is in fortran order. ndarray.__deepcopy__() → Deep copy of array. Used if copy.deepcopy is called on an array. ndarray.__reduce__() For pickling. ndarray.__setstate__(version, shape, dtype, isfortran, rawdata) For unpickling. Parameters version : int optional pickle version. If omitted defaults to 0. shape : tuple dtype : data-type isFortran : bool rawdata : string or list a binary string with the data (or a list if ‘a’ is an object array) Basic customization: ndarray.__new__((S, ...) ndarray.__array__(...) Returns either a new reference to self if dtype is not given or a new array ndarray.__array_wrap__(...) static ndarray.__new__(S,...) → a new object with type S, a subtype of T 1.1. The N-dimensional array (ndarray) 69 NumPy Reference, Release 1.8.1 ndarray.__array__(|dtype) → reference if type unchanged, copy otherwise. Returns either a new reference to self if dtype is not given or a new array of provided data type if dtype is different from the current dtype of the array. ndarray.__array_wrap__(obj) → Object of same type as ndarray object a. Container customization: (see Indexing) ndarray.__len__() <==> len(x) ndarray.__getitem__ x.__getitem__(y) <==> x[y] ndarray.__setitem__ x.__setitem__(i, y) <==> x[i]=y ndarray.__getslice__ x.__getslice__(i, j) <==> x[i:j] ndarray.__setslice__ x.__setslice__(i, j, y) <==> x[i:j]=y ndarray.__contains__ x.__contains__(y) <==> y in x ndarray.__len__() <==> len(x) ndarray.__getitem__ x.__getitem__(y) <==> x[y] ndarray.__setitem__ x.__setitem__(i, y) <==> x[i]=y ndarray.__getslice__ x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported. ndarray.__setslice__ x.__setslice__(i, j, y) <==> x[i:j]=y Use of negative indices is not supported. ndarray.__contains__ x.__contains__(y) <==> y in x Conversion; the operations complex, int, long, float, oct, and hex. They work only on arrays that have one element in them and return the appropriate scalar. ndarray.__int__() <==> int(x) ndarray.__long__() <==> long(x) ndarray.__float__() <==> ﬂoat(x) ndarray.__oct__() <==> oct(x) ndarray.__hex__() <==> hex(x) ndarray.__int__() <==> int(x) ndarray.__long__() <==> long(x) ndarray.__float__() <==> ﬂoat(x) ndarray.__oct__() <==> oct(x) 70 Chapter 1. Array objects NumPy Reference, Release 1.8.1 ndarray.__hex__() <==> hex(x) String representations: ndarray.__str__() <==> str(x) ndarray.__repr__() <==> repr(x) ndarray.__str__() <==> str(x) ndarray.__repr__() <==> repr(x) 1.2 Scalars Python deﬁnes only one type of a particular data class (there is only one integer type, one ﬂoating-point type, etc.). This can be convenient in applications that don’t need to be concerned with all the ways data can be represented in a computer. For scientiﬁc computing, however, more control is often needed. In NumPy, there are 24 new fundamental Python types to describe different types of scalars. These type descriptors are mostly based on the types available in the C language that CPython is written in, with several additional types compatible with Python’s types. Array scalars have the same attributes and methods as ndarrays. 1 This allows one to treat items of an array partly on the same footing as arrays, smoothing out rough edges that result when mixing scalar and array operations. Array scalars live in a hierarchy (see the Figure below) of data types. They can be detected using the hierarchy: For example, isinstance(val, np.generic) will return True if val is an array scalar object. Alternatively, what kind of array scalar is present can be determined using other members of the data type hierarchy. Thus, for example isinstance(val, np.complexfloating) will return True if val is a complex valued type, while isinstance(val, np.flexible) will return true if val is one of the ﬂexible itemsize array types (string, unicode, void). 1.2.1 Built-in scalar types The built-in scalar types are shown below. Along with their (mostly) C-derived names, the integer, ﬂoat, and complex data-types are also available using a bit-width convention so that an array of the right size can always be ensured (e.g. int8, float64, complex128). Two aliases (intp and uintp) pointing to the integer type that is sufﬁciently large to hold a C pointer are also provided. The C-like names are associated with character codes, which are shown in the table. Use of the character codes, however, is discouraged. Some of the scalar types are essentially equivalent to fundamental Python types and therefore inherit from them as well as from the generic array scalar type: Array scalar type Related Python type int_ IntType (Python 2 only) float_ FloatType complex_ ComplexType str_ StringType unicode_ UnicodeType 1 However, array scalars are immutable, so none of the array scalar attributes are settable. 1.2. Scalars 71 NumPy Reference, Release 1.8.1 Figure 1.2: Figure: Hierarchy of type objects representing the array data types. Not shown are the two integer types intp and uintp which just point to the integer type that holds a pointer for the platform. All the number types can be obtained using bit-width names as well. 72 Chapter 1. Array objects NumPy Reference, Release 1.8.1 The bool_ data type is very similar to the Python BooleanType but does not inherit from it because Python’s BooleanType does not allow itself to be inherited from, and on the C-level the size of the actual bool data is not the same as a Python Boolean scalar. Warning: The bool_ type is not a subclass of the int_ type (the bool_ is not even a number type). This is different than Python’s default implementation of bool as a sub-class of int. Warning: The int_ type does not inherit from the int built-in under Python 3, because type int is no longer a ﬁxed-width integer type. Tip: The default data type in Numpy is float_. In the tables below, platform? means that the type may not be available on all platforms. Compatibility with different C or Python types is indicated: two types are compatible if their data is of the same size and interpreted in the same way. Booleans: Type Remarks Character code bool_ compatible: Python bool ’?’ bool8 8 bits Integers: byte compatible: C char ’b’ short compatible: C short ’h’ intc compatible: C int ’i’ int_ compatible: Python int ’l’ longlong compatible: C long long ’q’ intp large enough to ﬁt a pointer ’p’ int8 8 bits int16 16 bits int32 32 bits int64 64 bits Unsigned integers: ubyte compatible: C unsigned char ’B’ ushort compatible: C unsigned short ’H’ uintc compatible: C unsigned int ’I’ uint compatible: Python int ’L’ ulonglong compatible: C long long ’Q’ uintp large enough to ﬁt a pointer ’P’ uint8 8 bits uint16 16 bits uint32 32 bits uint64 64 bits Floating-point numbers: 1.2. Scalars 73 NumPy Reference, Release 1.8.1 half ’e’ single compatible: C ﬂoat ’f’ double compatible: C double float_ compatible: Python ﬂoat ’d’ longfloat compatible: C long ﬂoat ’g’ float16 16 bits float32 32 bits float64 64 bits float96 96 bits, platform? float128 128 bits, platform? Complex ﬂoating-point numbers: csingle ’F’ complex_ compatible: Python complex ’D’ clongfloat ’G’ complex64 two 32-bit ﬂoats complex128 two 64-bit ﬂoats complex192 two 96-bit ﬂoats, platform? complex256 two 128-bit ﬂoats, platform? Any Python object: object_ any Python object ’O’ Note: The data actually stored in object arrays (i.e., arrays having dtype object_) are references to Python objects, not the objects themselves. Hence, object arrays behave more like usual Python lists, in the sense that their contents need not be of the same Python type. The object type is also special because an array containing object_ items does not return an object_ object on item access, but instead returns the actual object that the array item refers to. The following data types are ﬂexible. They have no predeﬁned size: the data they describe can be of different length in different arrays. (In the character codes # is an integer denoting how many elements the data type consists of.) str_ compatible: Python str ’S#’ unicode_ compatible: Python unicode ’U#’ void ’V#’ Warning: Numeric Compatibility: If you used old typecode characters in your Numeric code (which was never recommended), you will need to change some of them to the new characters. In particular, the needed changes are c -> S1, b -> B, 1 -> b, s -> h, w -> H, and u -> I. These changes make the type character convention more consistent with other Python modules such as the struct module. 1.2.2 Attributes The array scalar objects have an array priority of NPY_SCALAR_PRIORITY (-1,000,000.0). They also do not (yet) have a ctypes attribute. Otherwise, they share the same attributes as arrays: generic.flags integer value of ﬂags generic.shape tuple of array dimensions generic.strides tuple of bytes steps in each dimension generic.ndim number of array dimensions Continued on next page 74 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Table 1.22 – continued from previous page generic.data pointer to start of data generic.size number of elements in the gentype generic.itemsize length of one element in bytes generic.base base object generic.dtype get array data-descriptor generic.real real part of scalar generic.imag imaginary part of scalar generic.flat a 1-d view of scalar generic.T transpose generic.__array_interface__ Array protocol: Python side generic.__array_struct__ Array protocol: struct generic.__array_priority__ Array priority. generic.__array_wrap__ sc.__array_wrap__(obj) return scalar from array generic.flags integer value of ﬂags generic.shape tuple of array dimensions generic.strides tuple of bytes steps in each dimension generic.ndim number of array dimensions generic.data pointer to start of data generic.size number of elements in the gentype generic.itemsize length of one element in bytes generic.base base object generic.dtype get array data-descriptor generic.real real part of scalar generic.imag imaginary part of scalar generic.flat a 1-d view of scalar generic.T transpose generic.__array_interface__ Array protocol: Python side generic.__array_struct__ Array protocol: struct 1.2. Scalars 75 NumPy Reference, Release 1.8.1 generic.__array_priority__ Array priority. generic.__array_wrap__() sc.__array_wrap__(obj) return scalar from array 1.2.3 Indexing See Also: Indexing, Data type objects (dtype) Array scalars can be indexed like 0-dimensional arrays: if x is an array scalar, • x[()] returns a 0-dimensional ndarray • x[’field-name’] returns the array scalar in the ﬁeld ﬁeld-name.(x can have ﬁelds, for example, when it corresponds to a record data type.) 1.2.4 Methods Array scalars have exactly the same methods as arrays. The default behavior of these methods is to internally convert the scalar to an equivalent 0-dimensional array and to call the corresponding array method. In addition, math operations on array scalars are deﬁned so that the same hardware ﬂags are set and used to interpret the results as for ufunc, so that the error state used for ufuncs also carries over to the math on array scalars. The exceptions to the above rules are given below: generic Base class for numpy scalar types. generic.__array__ sc.__array__(|type) return 0-dim array generic.__array_wrap__ sc.__array_wrap__(obj) return scalar from array generic.squeeze Not implemented (virtual attribute) generic.byteswap Not implemented (virtual attribute) generic.__reduce__ generic.__setstate__ generic.setflags Not implemented (virtual attribute) class numpy.generic Base class for numpy scalar types. Class from which most (all?) numpy scalar types are derived. For consistency, exposes the same API as ndarray, despite many consequent attributes being either “get-only,” or completely irrelevant. This is the class from which it is strongly suggested users should derive custom scalar types. Attributes T transpose base base object data pointer to start of data dtype get array data-descriptor flags integer value of ﬂags flat a 1-d view of scalar imag imaginary part of scalar Continued on next page 76 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Table 1.24 – continued from previous page itemsize length of one element in bytes nbytes length of item in bytes ndim number of array dimensions real real part of scalar shape tuple of array dimensions size number of elements in the gentype strides tuple of bytes steps in each dimension generic.T transpose generic.base base object generic.data pointer to start of data generic.dtype get array data-descriptor generic.flags integer value of ﬂags generic.flat a 1-d view of scalar generic.imag imaginary part of scalar generic.itemsize length of one element in bytes generic.nbytes length of item in bytes generic.ndim number of array dimensions generic.real real part of scalar generic.shape tuple of array dimensions generic.size number of elements in the gentype generic.strides tuple of bytes steps in each dimension Methods all Not implemented (virtual attribute) any Not implemented (virtual attribute) argmax Not implemented (virtual attribute) argmin Not implemented (virtual attribute) argsort Not implemented (virtual attribute) Continued on next page 1.2. Scalars 77 NumPy Reference, Release 1.8.1 Table 1.25 – continued from previous page astype Not implemented (virtual attribute) byteswap Not implemented (virtual attribute) choose Not implemented (virtual attribute) clip Not implemented (virtual attribute) compress Not implemented (virtual attribute) conj conjugate Not implemented (virtual attribute) copy Not implemented (virtual attribute) cumprod Not implemented (virtual attribute) cumsum Not implemented (virtual attribute) diagonal Not implemented (virtual attribute) dump Not implemented (virtual attribute) dumps Not implemented (virtual attribute) fill Not implemented (virtual attribute) flatten Not implemented (virtual attribute) getfield Not implemented (virtual attribute) item Not implemented (virtual attribute) itemset Not implemented (virtual attribute) max Not implemented (virtual attribute) mean Not implemented (virtual attribute) min Not implemented (virtual attribute) newbyteorder([new_order]) Return a new dtype with a different byte order. nonzero Not implemented (virtual attribute) prod Not implemented (virtual attribute) ptp Not implemented (virtual attribute) put Not implemented (virtual attribute) ravel Not implemented (virtual attribute) repeat Not implemented (virtual attribute) reshape Not implemented (virtual attribute) resize Not implemented (virtual attribute) round Not implemented (virtual attribute) searchsorted Not implemented (virtual attribute) setfield Not implemented (virtual attribute) setflags Not implemented (virtual attribute) sort Not implemented (virtual attribute) squeeze Not implemented (virtual attribute) std Not implemented (virtual attribute) sum Not implemented (virtual attribute) swapaxes Not implemented (virtual attribute) take Not implemented (virtual attribute) tofile Not implemented (virtual attribute) tolist Not implemented (virtual attribute) tostring Not implemented (virtual attribute) trace Not implemented (virtual attribute) transpose Not implemented (virtual attribute) var Not implemented (virtual attribute) view Not implemented (virtual attribute) generic.all() Not implemented (virtual attribute) 78 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.any() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.argmax() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.argmin() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.argsort() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.astype() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.byteswap() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The 1.2. Scalars 79 NumPy Reference, Release 1.8.1 generic.choose() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.clip() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.compress() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.conj() generic.conjugate() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.copy() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.cumprod() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.cumsum() Not implemented (virtual attribute) 80 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.diagonal() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.dump() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.dumps() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.fill() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.flatten() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.getfield() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The 1.2. Scalars 81 NumPy Reference, Release 1.8.1 generic.item() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.itemset() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.max() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.mean() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.min() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.newbyteorder(new_order=’S’) Return a new dtype with a different byte order. Changes are also made in all ﬁelds and sub-arrays of the data type. The new_order code can be any from the following: •{‘<’, ‘L’} - little endian •{‘>’, ‘B’} - big endian •{‘=’, ‘N’} - native order •‘S’ - swap dtype from current to opposite endian •{‘|’, ‘I’} - ignore (no change to byte order) 82 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Parameters new_order : str, optional Byte order to force; a value from the byte order speciﬁcations above. The default value (‘S’) results in swapping the current byte order. The code does a case-insensitive check on the ﬁrst letter of new_order for the alternatives above. For example, any of ‘B’ or ‘b’ or ‘biggish’ are valid to specify big-endian. Returns new_dtype : dtype New dtype object with the given change to the byte order. generic.nonzero() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.prod() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.ptp() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.put() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.ravel() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.repeat() Not implemented (virtual attribute) 1.2. Scalars 83 NumPy Reference, Release 1.8.1 Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.reshape() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.resize() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.round() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.searchsorted() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.setfield() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.setflags() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The 84 Chapter 1. Array objects NumPy Reference, Release 1.8.1 generic.sort() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.squeeze() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.std() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.sum() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.swapaxes() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.take() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.tofile() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: 1.2. Scalars 85 NumPy Reference, Release 1.8.1 The generic.tolist() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.tostring() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.trace() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.transpose() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.var() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.view() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.__array__() sc.__array__(|type) return 0-dim array generic.__array_wrap__() sc.__array_wrap__(obj) return scalar from array 86 Chapter 1. Array objects NumPy Reference, Release 1.8.1 generic.squeeze() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.byteswap() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The generic.__reduce__() generic.__setstate__() generic.setflags() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The 1.2.5 Deﬁning new types There are two ways to effectively deﬁne a new array scalar type (apart from composing record dtypes from the built-in scalar types): One way is to simply subclass the ndarray and overwrite the methods of interest. This will work to a degree, but internally certain behaviors are ﬁxed by the data type of the array. To fully customize the data type of an array you need to deﬁne a new data-type, and register it with NumPy. Such new types can only be deﬁned in C, using the Numpy C-API. 1.3 Data type objects (dtype) A data type object (an instance of numpy.dtype class) describes how the bytes in the ﬁxed-size block of memory corresponding to an array item should be interpreted. It describes the following aspects of the data: 1. Type of the data (integer, ﬂoat, Python object, etc.) 2. Size of the data (how many bytes is in e.g. the integer) 3. Byte order of the data (little-endian or big-endian) 4. If the data type is a record, an aggregate of other data types, (e.g., describing an array item consisting of an integer and a ﬂoat), (a) what are the names of the “ﬁelds” of the record, by which they can be accessed, (b) what is the data-type of each ﬁeld, and 1.3. Data type objects (dtype) 87 NumPy Reference, Release 1.8.1 (c) which part of the memory block each ﬁeld takes. 5. If the data type is a sub-array, what is its shape and data type. To describe the type of scalar data, there are several built-in scalar types in Numpy for various precision of integers, ﬂoating-point numbers, etc. An item extracted from an array, e.g., by indexing, will be a Python object whose type is the scalar type associated with the data type of the array. Note that the scalar types are not dtype objects, even though they can be used in place of one whenever a data type speciﬁcation is needed in Numpy. Struct data types are formed by creating a data type whose ﬁelds contain other data types. Each ﬁeld has a name by which it can be accessed. The parent data type should be of sufﬁcient size to contain all its ﬁelds; the parent is nearly always based on the void type which allows an arbitrary item size. Struct data types may also contain nested struct sub-array data types in their ﬁelds. Finally, a data type can describe items that are themselves arrays of items of another data type. These sub-arrays must, however, be of a ﬁxed size. If an array is created using a data-type describing a sub-array, the dimensions of the sub-array are appended to the shape of the array when the array is created. Sub-arrays in a ﬁeld of a record behave differently, see Record Access. Sub-arrays always have a C-contiguous memory layout. Example A simple data type containing a 32-bit big-endian integer: (see Specifying and constructing data types for details on construction) >>> dt= np.dtype(’>i4’) >>> dt.byteorder ’>’ >>> dt.itemsize 4 >>> dt.name ’int32’ >>> dt.type is np.int32 True The corresponding array scalar type is int32. Example A record data type containing a 16-character string (in ﬁeld ‘name’) and a sub-array of two 64-bit ﬂoating-point number (in ﬁeld ‘grades’): >>> dt= np.dtype([(’name’, np.str_, 16), (’grades’, np.float64, (2,))]) >>> dt[’name’] dtype(’|S16’) >>> dt[’grades’] dtype((’float64’,(2,))) Items of an array of this data type are wrapped in an array scalar type that also has two ﬁelds: >>> x= np.array([(’Sarah’,(8.0, 7.0)), (’John’,(6.0, 7.0))], dtype=dt) >>> x[1] (’John’, [6.0, 7.0]) >>> x[1][’grades’] array([ 6., 7.]) >>> type(x[1]) 88 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> type(x[1][’grades’]) 1.3.1 Specifying and constructing data types Whenever a data-type is required in a NumPy function or method, either a dtype object or something that can be converted to one can be supplied. Such conversions are done by the dtype constructor: dtype Create a data type object. class numpy.dtype Create a data type object. A numpy array is homogeneous, and contains elements described by a dtype object. A dtype object can be constructed from different combinations of fundamental numeric types. Parameters obj Object to be converted to a data type object. align : bool, optional Add padding to the ﬁelds to match what a C compiler would output for a similar C- struct. Can be True only if obj is a dictionary or a comma-separated string. If a struct dtype is being created, this also sets a sticky alignment ﬂag isalignedstruct. copy : bool, optional Make a new copy of the data-type object. If False, the result may just be a reference to a built-in data-type object. See Also: result_type Examples Using array-scalar type: >>> np.dtype(np.int16) dtype(’int16’) Record, one ﬁeld name ‘f1’, containing int16: >>> np.dtype([(’f1’, np.int16)]) dtype([(’f1’, ’>> np.dtype([(’f1’, [(’f1’, np.int16)])]) dtype([(’f1’, [(’f1’, ’>> np.dtype([(’f1’, np.uint), (’f2’, np.int32)]) dtype([(’f1’, ’>> np.dtype([(’a’,’f8’),(’b’,’S10’)]) dtype([(’a’, ’>> np.dtype("i4, (2,3)f8") dtype([(’f0’, ’>> np.dtype([(’hello’,(np.int,3)),(’world’,np.void,10)]) dtype([(’hello’, ’>> np.dtype((np.int16, {’x’:(np.int8,0),’y’:(np.int8,1)})) dtype((’>> np.dtype({’names’:[’gender’,’age’],’formats’:[’S1’,np.uint8]}) dtype([(’gender’, ’|S1’), (’age’, ’|u1’)]) Offsets in bytes, here 0 and 25: >>> np.dtype({’surname’:(’S25’,0),’age’:(np.uint8,25)}) dtype([(’surname’, ’|S25’), (’age’, ’|u1’)]) Attributes base descr Array-interface compliant full description of the data-type. fields Dictionary of named ﬁelds deﬁned for this data type, or None. hasobject Boolean indicating whether this dtype contains any reference-counted objects in any ﬁelds or sub-dtypes. isalignedstruct Boolean indicating whether the dtype is a struct which maintains ﬁeld alignment. isbuiltin Integer indicating how this dtype relates to the built-in dtypes. isnative Boolean indicating whether the byte order of this dtype is native metadata name A bit-width name for this data-type. names Ordered list of ﬁeld names, or None if there are no ﬁelds. shape Shape tuple of the sub-array if this data type describes a sub-array, str The array-protocol typestring of this data-type object. subdtype Tuple (item_dtype, shape) if this dtype describes a sub-array, and dtype.base dtype.descr Array-interface compliant full description of the data-type. The format is that required by the ‘descr’ key in the __array_interface__ attribute. dtype.fields Dictionary of named ﬁelds deﬁned for this data type, or None. The dictionary is indexed by keys that are the names of the ﬁelds. Each entry in the dictionary is a tuple 90 Chapter 1. Array objects NumPy Reference, Release 1.8.1 fully describing the ﬁeld: (dtype, offset[, title]) If present, the optional title can be any object (if it is a string or unicode then it will also be a key in the ﬁelds dictionary, otherwise it’s meta-data). Notice also that the ﬁrst two elements of the tuple can be passed directly as arguments to the ndarray.getfield and ndarray.setfield methods. See Also: ndarray.getfield, ndarray.setfield Examples >>> dt= np.dtype([(’name’, np.str_, 16), (’grades’, np.float64, (2,))]) >>> print dt.fields {’grades’: (dtype((’float64’,(2,))), 16), ’name’: (dtype(’|S16’), 0)} dtype.hasobject Boolean indicating whether this dtype contains any reference-counted objects in any ﬁelds or sub-dtypes. Recall that what is actually in the ndarray memory representing the Python object is the memory address of that object (a pointer). Special handling may be required, and this attribute is useful for distinguishing data types that may contain arbitrary Python objects and data-types that won’t. dtype.isalignedstruct Boolean indicating whether the dtype is a struct which maintains ﬁeld alignment. This ﬂag is sticky, so when combining multiple structs together, it is preserved and produces new dtypes which are also aligned. dtype.isbuiltin Integer indicating how this dtype relates to the built-in dtypes. Read-only. 0 if this is a structured array type, with ﬁelds 1 if this is a dtype compiled into numpy (such as ints, ﬂoats etc) 2 if the dtype is for a user-deﬁned numpy type A user-deﬁned type uses the numpy C-API machinery to extend numpy to handle a new array type. See user.user-deﬁned-data-types in the Numpy manual. Examples >>> dt= np.dtype(’i2’) >>> dt.isbuiltin 1 >>> dt= np.dtype(’f8’) >>> dt.isbuiltin 1 >>> dt= np.dtype([(’field1’,’f8’)]) >>> dt.isbuiltin 0 dtype.isnative Boolean indicating whether the byte order of this dtype is native to the platform. dtype.metadata dtype.name A bit-width name for this data-type. Un-sized ﬂexible data-type objects do not have this attribute. 1.3. Data type objects (dtype) 91 NumPy Reference, Release 1.8.1 dtype.names Ordered list of ﬁeld names, or None if there are no ﬁelds. The names are ordered according to increasing byte offset. This can be used, for example, to walk through all of the named ﬁelds in offset order. Examples >>> dt= np.dtype([(’name’, np.str_, 16), (’grades’, np.float64, (2,))]) >>> dt.names (’name’, ’grades’) dtype.shape Shape tuple of the sub-array if this data type describes a sub-array, and () otherwise. dtype.str The array-protocol typestring of this data-type object. dtype.subdtype Tuple (item_dtype, shape) if this dtype describes a sub-array, and None otherwise. The shape is the ﬁxed shape of the sub-array described by this data type, and item_dtype the data type of the array. If a ﬁeld whose dtype object has this attribute is retrieved, then the extra dimensions implied by shape are tacked on to the end of the retrieved array. Methods newbyteorder([new_order]) Return a new dtype with a different byte order. dtype.newbyteorder(new_order=’S’) Return a new dtype with a different byte order. Changes are also made in all ﬁelds and sub-arrays of the data type. Parameters new_order : string, optional Byte order to force; a value from the byte order speciﬁcations below. The default value (‘S’) results in swapping the current byte order. new_order codes can be any of: *’S’ - swap dtype from current to opposite endian *{’<’, ’L’} - little endian *{’>’, ’B’} - big endian *{’=’, ’N’} - native order *{’|’, ’I’} - ignore (no change to byte order) The code does a case-insensitive check on the ﬁrst letter of new_order for these alterna- tives. For example, any of ‘>’ or ‘B’ or ‘b’ or ‘brian’ are valid to specify big-endian. Returns new_dtype : dtype New dtype object with the given change to the byte order. Notes Changes are also made in all ﬁelds and sub-arrays of the data type. 92 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> import sys >>> sys_is_le= sys.byteorder ==’little’ >>> native_code= sys_is_le and ’<’ or ’>’ >>> swapped_code= sys_is_le and ’>’ or ’<’ >>> native_dt= np.dtype(native_code+’i2’) >>> swapped_dt= np.dtype(swapped_code+’i2’) >>> native_dt.newbyteorder(’S’) == swapped_dt True >>> native_dt.newbyteorder() == swapped_dt True >>> native_dt == swapped_dt.newbyteorder(’S’) True >>> native_dt == swapped_dt.newbyteorder(’=’) True >>> native_dt == swapped_dt.newbyteorder(’N’) True >>> native_dt == native_dt.newbyteorder(’|’) True >>> np.dtype(’>> np.dtype(’>> np.dtype(’>i2’) == native_dt.newbyteorder(’>’) True >>> np.dtype(’>i2’) == native_dt.newbyteorder(’B’) True What can be converted to a data-type object is described below: dtype object Used as-is. None The default data type: float_. Array-scalar types The 24 built-in array scalar type objects all convert to an associated data-type object. This is true for their sub-classes as well. Note that not all data-type information can be supplied with a type-object: for example, ﬂexible data-types have a default itemsize of 0, and require an explicitly given size to be useful. Example >>> dt= np.dtype(np.int32) # 32-bit integer >>> dt= np.dtype(np.complex128) # 128-bit complex floating-point number Generic types The generic hierarchical type objects convert to corresponding type objects according to the associations: 1.3. Data type objects (dtype) 93 NumPy Reference, Release 1.8.1 number, inexact, floating float complexfloating cfloat integer, signedinteger int_ unsignedinteger uint character string generic, flexible void Built-in Python types Several python types are equivalent to a corresponding array scalar when used to generate a dtype object: int int_ bool bool_ float float_ complex cfloat str string unicode unicode_ buffer void (all others) object_ Example >>> dt= np.dtype(float)# Python-compatible floating-point number >>> dt= np.dtype(int)# Python-compatible integer >>> dt= np.dtype(object)# Python object Types with .dtype Any type object with a dtype attribute: The attribute will be accessed and used directly. The attribute must return something that is convertible into a dtype object. Several kinds of strings can be converted. Recognized strings can be prepended with ’>’ (big-endian), ’<’ (little- endian), or ’=’ (hardware-native, the default), to specify the byte order. One-character strings Each built-in data-type has a character code (the updated Numeric typecodes), that uniquely identiﬁes it. Example >>> dt= np.dtype(’b’)# byte, native byte order >>> dt= np.dtype(’>H’)# big-endian unsigned short >>> dt= np.dtype(’>> dt= np.dtype(’d’)# double-precision floating-point number Array-protocol type strings (see The Array Interface) The ﬁrst character speciﬁes the kind of data and the remaining characters specify how many bytes of data. The supported kinds are ’b’ Boolean ’i’ (signed) integer ’u’ unsigned integer ’f’ ﬂoating-point ’c’ complex-ﬂoating point ’S’,’a’ string ’U’ unicode ’V’ raw data (void) 94 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Example >>> dt= np.dtype(’i4’)# 32-bit signed integer >>> dt= np.dtype(’f8’)# 64-bit floating-point number >>> dt= np.dtype(’c16’)# 128-bit complex floating-point number >>> dt= np.dtype(’a25’)# 25-character string String with comma-separated ﬁelds Numarray introduced a short-hand notation for specifying the format of a record as a comma-separated string of basic formats. A basic format in this context is an optional shape speciﬁer followed by an array-protocol type string. Parenthesis are required on the shape if it has more than one dimension. NumPy allows a modiﬁcation on the format in that any string that can uniquely identify the type can be used to specify the data-type in a ﬁeld. The generated data-type ﬁelds are named ’f0’,’f1’, ..., ’f’ where N (>1) is the number of comma-separated basic formats in the string. If the optional shape speciﬁer is provided, then the data-type for the corresponding ﬁeld describes a sub-array. Example • ﬁeld named f0 containing a 32-bit integer • ﬁeld named f1 containing a 2 x 3 sub-array of 64-bit ﬂoating-point numbers • ﬁeld named f2 containing a 32-bit ﬂoating-point number >>> dt= np.dtype("i4, (2,3)f8, f4") • ﬁeld named f0 containing a 3-character string • ﬁeld named f1 containing a sub-array of shape (3,) containing 64-bit unsigned integers • ﬁeld named f2 containing a 3 x 4 sub-array containing 10-character strings >>> dt= np.dtype("a3, 3u8, (3,4)a10") Type strings Any string in numpy.sctypeDict.keys(): Example >>> dt= np.dtype(’uint32’)# 32-bit unsigned integer >>> dt= np.dtype(’Float64’)# 64-bit floating-point number (flexible_dtype, itemsize) The ﬁrst argument must be an object that is converted to a zero-sized ﬂexible data-type object, the second argument is an integer providing the desired itemsize. Example >>> dt= np.dtype((void, 10)) # 10-byte wide data block >>> dt= np.dtype((str, 35)) # 35-character string >>> dt= np.dtype((’U’, 10)) # 10-character unicode string 1.3. Data type objects (dtype) 95 NumPy Reference, Release 1.8.1 (fixed_dtype, shape) The ﬁrst argument is any object that can be converted into a ﬁxed-size data-type object. The second argument is the desired shape of this type. If the shape parameter is 1, then the data-type object is equivalent to ﬁxed dtype. If shape is a tuple, then the new dtype deﬁnes a sub-array of the given shape. Example >>> dt= np.dtype((np.int32, (2,2))) # 2 x 2 integer sub-array >>> dt= np.dtype((’S10’,1)) # 10-character string >>> dt= np.dtype((’i4, (2,3)f8, f4’,(2,3))) # 2 x 3 record sub-array [(field_name, field_dtype, field_shape), ...] obj should be a list of ﬁelds where each ﬁeld is described by a tuple of length 2 or 3. (Equivalent to the descr item in the __array_interface__ attribute.) The ﬁrst element, ﬁeld_name, is the ﬁeld name (if this is ” then a standard ﬁeld name, ’f#’, is assigned). The ﬁeld name may also be a 2-tuple of strings where the ﬁrst string is either a “title” (which may be any string or unicode string) or meta-data for the ﬁeld which can be any object, and the second string is the “name” which must be a valid Python identiﬁer. The second element, ﬁeld_dtype, can be anything that can be interpreted as a data-type. The optional third element ﬁeld_shape contains the shape if this ﬁeld represents an array of the data-type in the second element. Note that a 3-tuple with a third argument equal to 1 is equivalent to a 2-tuple. This style does not accept align in the dtype constructor as it is assumed that all of the memory is accounted for by the array interface description. Example Data-type with ﬁelds big (big-endian 32-bit integer) and little (little-endian 32-bit integer): >>> dt= np.dtype([(’big’,’>i4’), (’little’,’>> dt= np.dtype([(’R’,’u1’), (’G’,’u1’), (’B’,’u1’), (’A’,’u1’)]) {’names’: ..., ’formats’: ..., ’offsets’: ..., ’titles’: ..., ’itemsize’: ...} This style has two required and three optional keys. The names and formats keys are required. Their respective values are equal-length lists with the ﬁeld names and the ﬁeld formats. The ﬁeld names must be strings and the ﬁeld formats can be any object accepted by dtype constructor. When the optional keys offsets and titles are provided, their values must each be lists of the same length as the names and formats lists. The offsets value is a list of byte offsets (integers) for each ﬁeld, while the titles value is a list of titles for each ﬁeld (None can be used if no title is desired for that ﬁeld). The titles can be any string or unicode object and will add another entry to the ﬁelds dictionary keyed by the title and referencing the same ﬁeld tuple which will contain the title as an additional tuple member. The itemsize key allows the total size of the dtype to be set, and must be an integer large enough so all the ﬁelds are within the dtype. If the dtype being constructed is aligned, the itemsize must also be divisible by the struct alignment. Example 96 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Data type with ﬁelds r, g, b, a, each being a 8-bit unsigned integer: >>> dt= np.dtype({’names’:[’r’,’g’,’b’,’a’], ... ’formats’: [uint8, uint8, uint8, uint8]}) Data type with ﬁelds r and b (with the given titles), both being 8-bit unsigned integers, the ﬁrst at byte position 0 from the start of the ﬁeld and the second at position 2: >>> dt= np.dtype({’names’:[’r’,’b’],’formats’:[’u1’,’u1’], ... ’offsets’:[0,2], ... ’titles’:[’Red pixel’,’Blue pixel’]}) {’field1’: ..., ’field2’: ..., ...} This usage is discouraged, because it is ambiguous with the other dict-based construction method. If you have a ﬁeld called ‘names’ and a ﬁeld called ‘formats’ there will be a conﬂict. This style allows passing in the fields attribute of a data-type object. obj should contain string or unicode keys that refer to (data-type, offset) or (data-type, offset, title) tuples. Example Data type containing ﬁeld col1 (10-character string at byte position 0), col2 (32-bit ﬂoat at byte posi- tion 10), and col3 (integers at byte position 14): >>> dt= np.dtype({’col1’:(’S10’,0),’col2’: (float32, 10), ’col3’: (int, 14)}) (base_dtype, new_dtype) This usage is discouraged. In NumPy 1.7 and later, it is possible to specify struct dtypes with overlapping ﬁelds, functioning like the ‘union’ type in C. The union mechanism is preferred. Both arguments must be convertible to data-type objects in this case. The base_dtype is the data-type object that the new data-type builds on. This is how you could assign named ﬁelds to any built-in data- type object. Example 32-bit integer, whose ﬁrst two bytes are interpreted as an integer via ﬁeld real, and the following two bytes via ﬁeld imag. >>> dt= np.dtype((np.int32,{’real’:(np.int16,0),’imag’:(np.int16,2)}) 32-bit integer, which is interpreted as consisting of a sub-array of shape (4,) containing 8-bit integers: >>> dt= np.dtype((np.int32, (np.int8,4))) 32-bit integer, containing ﬁelds r, g, b, a that interpret the 4 bytes in the integer as four unsigned integers: >>> dt= np.dtype((’i4’, [(’r’,’u1’),(’g’,’u1’),(’b’,’u1’),(’a’,’u1’)])) 1.3.2 dtype Numpy data type descriptions are instances of the dtype class. 1.3. Data type objects (dtype) 97 NumPy Reference, Release 1.8.1 Attributes The type of the data is described by the following dtype attributes: dtype.type The type object used to instantiate a scalar of this data-type. dtype.kind A character code (one of ‘biufcSUV’) identifying the general kind of data. dtype.char A unique character code for each of the 21 different built-in types. dtype.num A unique number for each of the 21 different built-in types. dtype.str The array-protocol typestring of this data-type object. dtype.type The type object used to instantiate a scalar of this data-type. dtype.kind A character code (one of ‘biufcSUV’) identifying the general kind of data. dtype.char A unique character code for each of the 21 different built-in types. dtype.num A unique number for each of the 21 different built-in types. These are roughly ordered from least-to-most precision. dtype.str The array-protocol typestring of this data-type object. Size of the data is in turn described by: dtype.name A bit-width name for this data-type. dtype.itemsize The element size of this data-type object. dtype.name A bit-width name for this data-type. Un-sized ﬂexible data-type objects do not have this attribute. dtype.itemsize The element size of this data-type object. For 18 of the 21 types this number is ﬁxed by the data-type. For the ﬂexible data-types, this number can be anything. Endianness of this data: dtype.byteorder A character indicating the byte-order of this data-type object. dtype.byteorder A character indicating the byte-order of this data-type object. One of: ‘=’ native ‘<’ little-endian ‘>’ big-endian ‘|’ not applicable All built-in data-type objects have byteorder either ‘=’ or ‘|’. 98 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> dt= np.dtype(’i2’) >>> dt.byteorder ’=’ >>> # endian is not relevant for 8 bit numbers >>> np.dtype(’i1’).byteorder ’|’ >>> # or ASCII strings >>> np.dtype(’S2’).byteorder ’|’ >>> # Even if specific code is given, and it is native >>> # ’=’ is the byteorder >>> import sys >>> sys_is_le= sys.byteorder ==’little’ >>> native_code= sys_is_le and ’<’ or ’>’ >>> swapped_code= sys_is_le and ’>’ or ’<’ >>> dt= np.dtype(native_code+’i2’) >>> dt.byteorder ’=’ >>> # Swapped code shows up as itself >>> dt= np.dtype(swapped_code+’i2’) >>> dt.byteorder == swapped_code True Information about sub-data-types in a record: dtype.fields Dictionary of named ﬁelds deﬁned for this data type, or None. dtype.names Ordered list of ﬁeld names, or None if there are no ﬁelds. dtype.fields Dictionary of named ﬁelds deﬁned for this data type, or None. The dictionary is indexed by keys that are the names of the ﬁelds. Each entry in the dictionary is a tuple fully describing the ﬁeld: (dtype, offset[, title]) If present, the optional title can be any object (if it is a string or unicode then it will also be a key in the ﬁelds dictionary, otherwise it’s meta-data). Notice also that the ﬁrst two elements of the tuple can be passed directly as arguments to the ndarray.getfield and ndarray.setfield methods. See Also: ndarray.getfield, ndarray.setfield Examples >>> dt= np.dtype([(’name’, np.str_, 16), (’grades’, np.float64, (2,))]) >>> print dt.fields {’grades’: (dtype((’float64’,(2,))), 16), ’name’: (dtype(’|S16’), 0)} dtype.names Ordered list of ﬁeld names, or None if there are no ﬁelds. The names are ordered according to increasing byte offset. This can be used, for example, to walk through all of the named ﬁelds in offset order. 1.3. Data type objects (dtype) 99 NumPy Reference, Release 1.8.1 Examples >>> dt= np.dtype([(’name’, np.str_, 16), (’grades’, np.float64, (2,))]) >>> dt.names (’name’, ’grades’) For data types that describe sub-arrays: dtype.subdtype Tuple (item_dtype, shape) if this dtype describes a sub-array, and dtype.shape Shape tuple of the sub-array if this data type describes a sub-array, dtype.subdtype Tuple (item_dtype, shape) if this dtype describes a sub-array, and None otherwise. The shape is the ﬁxed shape of the sub-array described by this data type, and item_dtype the data type of the array. If a ﬁeld whose dtype object has this attribute is retrieved, then the extra dimensions implied by shape are tacked on to the end of the retrieved array. dtype.shape Shape tuple of the sub-array if this data type describes a sub-array, and () otherwise. Attributes providing additional information: dtype.hasobject Boolean indicating whether this dtype contains any reference-counted objects in any ﬁelds or sub-dtypes. dtype.flags Bit-ﬂags describing how this data type is to be interpreted. dtype.isbuiltin Integer indicating how this dtype relates to the built-in dtypes. dtype.isnative Boolean indicating whether the byte order of this dtype is native dtype.descr Array-interface compliant full description of the data-type. dtype.alignment The required alignment (bytes) of this data-type according to the compiler. dtype.hasobject Boolean indicating whether this dtype contains any reference-counted objects in any ﬁelds or sub-dtypes. Recall that what is actually in the ndarray memory representing the Python object is the memory address of that object (a pointer). Special handling may be required, and this attribute is useful for distinguishing data types that may contain arbitrary Python objects and data-types that won’t. dtype.flags Bit-ﬂags describing how this data type is to be interpreted. Bit-masks are in numpy.core.multiarray as the constants ITEM_HASOBJECT, LIST_PICKLE, ITEM_IS_POINTER, NEEDS_INIT, NEEDS_PYAPI, USE_GETITEM, USE_SETITEM. A full explanation of these ﬂags is in C-API documentation; they are largely useful for user-deﬁned data-types. dtype.isbuiltin Integer indicating how this dtype relates to the built-in dtypes. Read-only. 0 if this is a structured array type, with ﬁelds 1 if this is a dtype compiled into numpy (such as ints, ﬂoats etc) 2 if the dtype is for a user-deﬁned numpy type A user-deﬁned type uses the numpy C-API machinery to extend numpy to handle a new array type. See user.user-deﬁned-data-types in the Numpy manual. 100 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> dt= np.dtype(’i2’) >>> dt.isbuiltin 1 >>> dt= np.dtype(’f8’) >>> dt.isbuiltin 1 >>> dt= np.dtype([(’field1’,’f8’)]) >>> dt.isbuiltin 0 dtype.isnative Boolean indicating whether the byte order of this dtype is native to the platform. dtype.descr Array-interface compliant full description of the data-type. The format is that required by the ‘descr’ key in the __array_interface__ attribute. dtype.alignment The required alignment (bytes) of this data-type according to the compiler. More information is available in the C-API section of the manual. Methods Data types have the following method for changing the byte order: dtype.newbyteorder([new_order]) Return a new dtype with a different byte order. dtype.newbyteorder(new_order=’S’) Return a new dtype with a different byte order. Changes are also made in all ﬁelds and sub-arrays of the data type. Parameters new_order : string, optional Byte order to force; a value from the byte order speciﬁcations below. The default value (‘S’) results in swapping the current byte order. new_order codes can be any of: *’S’ - swap dtype from current to opposite endian *{’<’, ’L’} - little endian *{’>’, ’B’} - big endian *{’=’, ’N’} - native order *{’|’, ’I’} - ignore (no change to byte order) The code does a case-insensitive check on the ﬁrst letter of new_order for these alter- natives. For example, any of ‘>’ or ‘B’ or ‘b’ or ‘brian’ are valid to specify big-endian. Returns new_dtype : dtype New dtype object with the given change to the byte order. Notes Changes are also made in all ﬁelds and sub-arrays of the data type. 1.3. Data type objects (dtype) 101 NumPy Reference, Release 1.8.1 Examples >>> import sys >>> sys_is_le= sys.byteorder ==’little’ >>> native_code= sys_is_le and ’<’ or ’>’ >>> swapped_code= sys_is_le and ’>’ or ’<’ >>> native_dt= np.dtype(native_code+’i2’) >>> swapped_dt= np.dtype(swapped_code+’i2’) >>> native_dt.newbyteorder(’S’) == swapped_dt True >>> native_dt.newbyteorder() == swapped_dt True >>> native_dt == swapped_dt.newbyteorder(’S’) True >>> native_dt == swapped_dt.newbyteorder(’=’) True >>> native_dt == swapped_dt.newbyteorder(’N’) True >>> native_dt == native_dt.newbyteorder(’|’) True >>> np.dtype(’>> np.dtype(’>> np.dtype(’>i2’) == native_dt.newbyteorder(’>’) True >>> np.dtype(’>i2’) == native_dt.newbyteorder(’B’) True The following methods implement the pickle protocol: dtype.__reduce__ dtype.__setstate__ dtype.__reduce__() dtype.__setstate__() 1.4 Indexing ndarrays can be indexed using the standard Python x[obj] syntax, where x is the array and obj the selection. There are three kinds of indexing available: record access, basic slicing, advanced indexing. Which one occurs depends on obj. Note: In Python, x[(exp1, exp2, ..., expN)] is equivalent to x[exp1, exp2, ..., expN]; the latter is just syntactic sugar for the former. 1.4.1 Basic Slicing Basic slicing extends Python’s basic concept of slicing to N dimensions. Basic slicing occurs when obj is a slice object (constructed by start:stop:step notation inside of brackets), an integer, or a tuple of slice objects and 102 Chapter 1. Array objects NumPy Reference, Release 1.8.1 integers. Ellipsis and newaxis objects can be interspersed with these as well. In order to remain backward compatible with a common usage in Numeric, basic slicing is also initiated if the selection object is any sequence (such as a list) containing slice objects, the Ellipsis object, or the newaxis object, but no integer arrays or other embedded sequences. The simplest case of indexing with N integers returns an array scalar representing the corresponding item. As in Python, all indices are zero-based: for the i-th index ni, the valid range is 0 ≤ ni < di where di is the i-th element of the shape of the array. Negative indices are interpreted as counting from the end of the array (i.e., if i < 0, it means ni + i). All arrays generated by basic slicing are always views of the original array. The standard rules of sequence slicing apply to basic slicing on a per-dimension basis (including using a step index). Some useful concepts to remember include: • The basic slice syntax is i:j:k where i is the starting index, j is the stopping index, and k is the step (k 6= 0). This selects the m elements (in the corresponding dimension) with index values i, i + k, ..., i + (m - 1) k where m = q + (r 6= 0) and q and r are the quotient and remainder obtained by dividing j - i by k: j - i = q k + r, so that i + (m - 1) k < j. Example >>> x= np.array([0,1,2,3,4,5,6,7,8,9]) >>> x[1:7:2] array([1, 3, 5]) • Negative i and j are interpreted as n + i and n + j where n is the number of elements in the corresponding dimension. Negative k makes stepping go towards smaller indices. Example >>> x[-2:10] array([8, 9]) >>> x[-3:3:-1] array([7, 6, 5, 4]) • Assume n is the number of elements in the dimension being sliced. Then, if i is not given it defaults to 0 for k > 0 and n for k < 0 . If j is not given it defaults to n for k > 0 and -1 for k < 0 . If k is not given it defaults to 1. Note that :: is the same as : and means select all indices along this axis. Example >>> x[5:] array([5, 6, 7, 8, 9]) • If the number of objects in the selection tuple is less than N, then : is assumed for any subsequent dimensions. Example >>> x= np.array([[[1],[2],[3]], [[4],[5],[6]]]) >>> x.shape (2, 3, 1) >>> x[1:2] array([[[4], 1.4. Indexing 103 NumPy Reference, Release 1.8.1 [5], [6]]]) • Ellipsis expand to the number of : objects needed to make a selection tuple of the same length as x.ndim. Only the ﬁrst ellipsis is expanded, any others are interpreted as :. Example >>> x[...,0] array([[1, 2, 3], [4, 5, 6]]) • Each newaxis object in the selection tuple serves to expand the dimensions of the resulting selection by one unit-length dimension. The added dimension is the position of the newaxis object in the selection tuple. Example >>> x[:,np.newaxis,:,:].shape (2, 1, 3, 1) • An integer, i, returns the same values as i:i+1 except the dimensionality of the returned object is reduced by 1. In particular, a selection tuple with the p-th element an integer (and all other entries :) returns the corresponding sub-array with dimension N - 1. If N = 1 then the returned object is an array scalar. These objects are explained in Scalars. • If the selection tuple has all entries : except the p-th entry which is a slice object i:j:k, then the returned array has dimension N formed by concatenating the sub-arrays returned by integer indexing of elements i, i+k, ..., i + (m - 1) k < j, • Basic slicing with more than one non-: entry in the slicing tuple, acts like repeated application of slicing using a single non-: entry, where the non-: entries are successively taken (with all other non-: entries replaced by :). Thus, x[ind1,...,ind2,:] acts like x[ind1][...,ind2,:] under basic slicing. Warning: The above is not true for advanced slicing. • You may use slicing to set values in the array, but (unlike lists) you can never grow the array. The size of the value to be set in x[obj] = value must be (broadcastable) to the same shape as x[obj]. Note: Remember that a slicing tuple can always be constructed as obj and used in the x[obj] notation. Slice objects can be used in the construction in place of the [start:stop:step] notation. For example, x[1:10:5,::-1] can also be implemented as obj = (slice(1,10,5), slice(None,None,-1)); x[obj] . This can be useful for constructing generic code that works on arrays of arbitrary dimension. numpy.newaxis The newaxis object can be used in all slicing operations as discussed above. None can also be used instead of newaxis. 1.4.2 Advanced indexing Advanced indexing is triggered when the selection object, obj, is a non-tuple sequence object, an ndarray (of data type integer or bool), or a tuple with at least one sequence object or ndarray (of data type integer or bool). There are two types of advanced indexing: integer and Boolean. 104 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Advanced indexing always returns a copy of the data (contrast with basic slicing that returns a view). Integer Integer indexing allows selection of arbitrary items in the array based on their N-dimensional index. This kind of selection occurs when advanced indexing is triggered and the selection object is not an array of data type bool. For the discussion below, when the selection object is not a tuple, it will be referred to as if it had been promoted to a 1-tuple, which will be called the selection tuple. The rules of advanced integer-style indexing are: • If the length of the selection tuple is larger than N an error is raised. • All sequences and scalars in the selection tuple are converted to intp indexing arrays. • All selection tuple objects must be convertible to intp arrays, slice objects, or the Ellipsis object. • The ﬁrst Ellipsis object will be expanded, and any other Ellipsis objects will be treated as full slice (:) objects. The expanded Ellipsis object is replaced with as many full slice (:) objects as needed to make the length of the selection tuple N. • If the selection tuple is smaller than N, then as many : objects as needed are added to the end of the selection tuple so that the modiﬁed selection tuple has length N. • All the integer indexing arrays must be broadcastable to the same shape. • The shape of the output (or the needed shape of the object to be used for setting) is the broadcasted shape. • After expanding any ellipses and ﬁlling out any missing : objects in the selection tuple, then let Nt be the number of indexing arrays, and let Ns = N − Nt be the number of slice objects. Note that Nt > 0 (or we wouldn’t be doing advanced integer indexing). • If Ns = 0 then the M-dimensional result is constructed by varying the index tuple (i_1, ..., i_M) over the range of the result shape and for each value of the index tuple (ind_1, ..., ind_M): result[i_1, ..., i_M] == x[ind_1[i_1, ..., i_M], ind_2[i_1, ..., i_M], ..., ind_N[i_1, ..., i_M]] Example Suppose the shape of the broadcasted indexing arrays is 3-dimensional and N is 2. Then the result is found by letting i, j, k run over the shape found by broadcasting ind_1 and ind_2, and each i, j, k yields: result[i,j,k]= x[ind_1[i,j,k], ind_2[i,j,k]] • If Ns > 0, then partial indexing is done. This can be somewhat mind-boggling to understand, but if you think in terms of the shapes of the arrays involved, it can be easier to grasp what happens. In simple cases (i.e. one indexing array and N - 1 slice objects) it does exactly what you would expect (concatenation of repeated application of basic slicing). The rule for partial indexing is that the shape of the result (or the interpreted shape of the object to be used in setting) is the shape of x with the indexed subspace replaced with the broadcasted indexing subspace. If the index subspaces are right next to each other, then the broadcasted indexing space directly replaces all of the indexed subspaces in x. If the indexing subspaces are separated (by slice objects), then the broadcasted indexing space is ﬁrst, followed by the sliced subspace of x. Example Suppose x.shape is (10,20,30) and ind is a (2,3,4)-shaped indexing intp array, then result = x[...,ind,:] has shape (10,2,3,4,30) because the (20,)-shaped subspace has been replaced with a (2,3,4)-shaped broadcasted indexing subspace. If we let i, j, k loop over the (2,3,4)-shaped subspace then 1.4. Indexing 105 NumPy Reference, Release 1.8.1 result[...,i,j,k,:] = x[...,ind[i,j,k],:]. This example produces the same result as x.take(ind, axis=-2). Example Now let x.shape be (10,20,30,40,50) and suppose ind_1 and ind_2 are broadcastable to the shape (2,3,4). Then x[:,ind_1,ind_2] has shape (10,2,3,4,40,50) because the (20,30)-shaped subspace from X has been replaced with the (2,3,4) subspace from the indices. However, x[:,ind_1,:,ind_2] has shape (2,3,4,10,30,50) because there is no unambiguous place to drop in the indexing subspace, thus it is tacked- on to the beginning. It is always possible to use .transpose() to move the subspace anywhere desired. (Note that this example cannot be replicated using take.) Boolean This advanced indexing occurs when obj is an array object of Boolean type (such as may be returned from com- parison operators). It is always equivalent to (but faster than) x[obj.nonzero()] where, as described above, obj.nonzero() returns a tuple (of length obj.ndim) of integer index arrays showing the True elements of obj. The special case when obj.ndim == x.ndim is worth mentioning. In this case x[obj] returns a 1-dimensional array ﬁlled with the elements of x corresponding to the True values of obj. The search order will be C-style (last index varies the fastest). If obj has True values at entries that are outside of the bounds of x, then an index error will be raised. You can also use Boolean arrays as element of the selection tuple. In such instances, they will always be interpreted as nonzero(obj) and the equivalent integer indexing will be done. Warning: The deﬁnition of advanced indexing means that x[(1,2,3),] is fundamentally different than x[(1,2,3)]. The latter is equivalent to x[1,2,3] which will trigger basic selection while the former will trigger advanced indexing. Be sure to understand why this is occurs. Also recognize that x[[1,2,3]] will trigger advanced indexing, whereas x[[1,2,slice(None)]] will trigger basic slicing. 1.4.3 Record Access See Also: Data type objects (dtype), Scalars If the ndarray object is a record array, i.e. its data type is a record data type, the ﬁelds of the array can be accessed by indexing the array with strings, dictionary-like. Indexing x[’field-name’] returns a new view to the array, which is of the same shape as x (except when the ﬁeld is a sub-array) but of data type x.dtype[’field-name’] and contains only the part of the data in the speciﬁed ﬁeld. Also record array scalars can be “indexed” this way. Indexing into a record array can also be done with a list of ﬁeld names, e.g. x[[’field-name1’,’field-name2’]]. Currently this returns a new array containing a copy of the values in the ﬁelds speciﬁed in the list. As of NumPy 1.7, returning a copy is being deprecated in favor of returning a view. A copy will continue to be returned for now, but a FutureWarning will be issued when writing to the copy. If you depend on the current behavior, then we suggest copying the returned array explicitly, i.e. use x[[’ﬁeld-name1’,’ﬁeld-name2’]].copy(). This will work with both past and future versions of NumPy. If the accessed ﬁeld is a sub-array, the dimensions of the sub-array are appended to the shape of the result. 106 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Example >>> x= np.zeros((2,2), dtype=[(’a’, np.int32), (’b’, np.float64, (3,3))]) >>> x[’a’].shape (2, 2) >>> x[’a’].dtype dtype(’int32’) >>> x[’b’].shape (2, 2, 3, 3) >>> x[’b’].dtype dtype(’float64’) 1.4.4 Flat Iterator indexing x.flat returns an iterator that will iterate over the entire array (in C-contiguous style with the last index varying the fastest). This iterator object can also be indexed using basic slicing or advanced indexing as long as the selection object is not a tuple. This should be clear from the fact that x.flat is a 1-dimensional view. It can be used for integer indexing with 1-dimensional C-style-ﬂat indices. The shape of any returned array is therefore the shape of the integer indexing object. 1.5 Iterating Over Arrays The iterator object nditer, introduced in NumPy 1.6, provides many ﬂexible ways to visit all the elements of one or more arrays in a systematic fashion. This page introduces some basic ways to use the object for computations on arrays in Python, then concludes with how one can accelerate the inner loop in Cython. Since the Python exposure of nditer is a relatively straightforward mapping of the C array iterator API, these ideas will also provide help working with array iteration from C or C++. 1.5.1 Single Array Iteration The most basic task that can be done with the nditer is to visit every element of an array. Each element is provided one by one using the standard Python iterator interface. Example >>> a= np.arange(6).reshape(2,3) >>> for x in np.nditer(a): ... print x, ... 0 1 2 3 4 5 An important thing to be aware of for this iteration is that the order is chosen to match the memory layout of the array instead of using a standard C or Fortran ordering. This is done for access efﬁciency, reﬂecting the idea that by default one simply wants to visit each element without concern for a particular ordering. We can see this by iterating over the transpose of our previous array, compared to taking a copy of that transpose in C order. Example >>> a= np.arange(6).reshape(2,3) >>> for x in np.nditer(a.T): 1.5. Iterating Over Arrays 107 NumPy Reference, Release 1.8.1 ... print x, ... 0 1 2 3 4 5 >>> for x in np.nditer(a.T.copy(order=’C’)): ... print x, ... 0 3 1 4 2 5 The elements of both a and a.T get traversed in the same order, namely the order they are stored in memory, whereas the elements of a.T.copy(order=’C’) get visited in a different order because they have been put into a different memory layout. Controlling Iteration Order There are times when it is important to visit the elements of an array in a speciﬁc order, irrespective of the layout of the elements in memory. The nditer object provides an order parameter to control this aspect of iteration. The default, having the behavior described above, is order=’K’ to keep the existing order. This can be overridden with order=’C’ for C order and order=’F’ for Fortran order. Example >>> a= np.arange(6).reshape(2,3) >>> for x in np.nditer(a, order=’F’): ... print x, ... 0 3 1 4 2 5 >>> for x in np.nditer(a.T, order=’C’): ... print x, ... 0 3 1 4 2 5 Modifying Array Values By default, the nditer treats the input array as a read-only object. To modify the array elements, you must specify either read-write or write-only mode. This is controlled with per-operand ﬂags. Regular assignment in Python simply changes a reference in the local or global variable dictionary instead of modifying an existing variable in place. This means that simply assigning to x will not place the value into the element of the array, but rather switch x from being an array element reference to being a reference to the value you assigned. To actually modify the element of the array, x should be indexed with the ellipsis. Example >>> a= np.arange(6).reshape(2,3) >>> a array([[0, 1, 2], [3, 4, 5]]) >>> for x in np.nditer(a, op_flags=[’readwrite’]): ... x[...]=2 * x ... >>> a 108 Chapter 1. Array objects NumPy Reference, Release 1.8.1 array([[ 0, 2, 4], [ 6, 8, 10]]) Using an External Loop In all the examples so far, the elements of a are provided by the iterator one at a time, because all the looping logic is internal to the iterator. While this is simple and convenient, it is not very efﬁcient. A better approach is to move the one-dimensional innermost loop into your code, external to the iterator. This way, NumPy’s vectorized operations can be used on larger chunks of the elements being visited. The nditer will try to provide chunks that are as large as possible to the inner loop. By forcing ‘C’ and ‘F’ order, we get different external loop sizes. This mode is enabled by specifying an iterator ﬂag. Observe that with the default of keeping native memory order, the iterator is able to provide a single one-dimensional chunk, whereas when forcing Fortran order, it has to provide three chunks of two elements each. Example >>> a= np.arange(6).reshape(2,3) >>> for x in np.nditer(a, flags=[’external_loop’]): ... print x, ... [0 1 2 3 4 5] >>> for x in np.nditer(a, flags=[’external_loop’], order=’F’): ... print x, ... [0 3] [1 4] [2 5] Tracking an Index or Multi-Index During iteration, you may want to use the index of the current element in a computation. For example, you may want to visit the elements of an array in memory order, but use a C-order, Fortran-order, or multidimensional index to look up values in a different array. The Python iterator protocol doesn’t have a natural way to query these additional values from the iterator, so we introduce an alternate syntax for iterating with an nditer. This syntax explicitly works with the iterator object itself, so its properties are readily accessible during iteration. With this looping construct, the current value is accessible by indexing into the iterator, and the index being tracked is the property index or multi_index depending on what was requested. The Python interactive interpreter unfortunately prints out the values of expressions inside the while loop during each iteration of the loop. We have modiﬁed the output in the examples using this looping construct in order to be more readable. Example >>> a= np.arange(6).reshape(2,3) >>> it= np.nditer(a, flags=[’f_index’]) >>> while not it.finished: ... print "%d <%d>"% (it[0], it.index), ... it.iternext() 1.5. Iterating Over Arrays 109 NumPy Reference, Release 1.8.1 ... 0 <0> 1 <2> 2 <4> 3 <1> 4 <3> 5 <5> >>> it= np.nditer(a, flags=[’multi_index’]) >>> while not it.finished: ... print "%d <%s>"% (it[0], it.multi_index), ... it.iternext() ... 0 <(0, 0)> 1 <(0, 1)> 2 <(0, 2)> 3 <(1, 0)> 4 <(1, 1)> 5 <(1, 2)> >>> it= np.nditer(a, flags=[’multi_index’], op_flags=[’writeonly’]) >>> while not it.finished: ... it[0]= it.multi_index[1]- it.multi_index[0] ... it.iternext() ... >>> a array([[ 0, 1, 2], [-1, 0, 1]]) Tracking an index or multi-index is incompatible with using an external loop, because it requires a different index value per element. If you try to combine these ﬂags, the nditer object will raise an exception Example >>> a= np.zeros((2,3)) >>> it= np.nditer(a, flags=[’c_index’,’external_loop’]) Traceback (most recent call last): File "", line1, in ValueError: Iterator flag EXTERNAL_LOOP cannot be used if an index or multi-index is being tracked Buffering the Array Elements When forcing an iteration order, we observed that the external loop option may provide the elements in smaller chunks because the elements can’t be visited in the appropriate order with a constant stride. When writing C code, this is generally ﬁne, however in pure Python code this can cause a signiﬁcant reduction in performance. By enabling buffering mode, the chunks provided by the iterator to the inner loop can be made larger, signiﬁcantly reducing the overhead of the Python interpreter. In the example forcing Fortran iteration order, the inner loop gets to see all the elements in one go when buffering is enabled. Example >>> a= np.arange(6).reshape(2,3) >>> for x in np.nditer(a, flags=[’external_loop’], order=’F’): ... print x, ... [0 3] [1 4] [2 5] >>> for x in np.nditer(a, flags=[’external_loop’,’buffered’], order=’F’): ... print x, ... [0 3 1 4 2 5] 110 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Iterating as a Speciﬁc Data Type There are times when it is necessary to treat an array as a different data type than it is stored as. For instance, one may want to do all computations on 64-bit ﬂoats, even if the arrays being manipulated are 32-bit ﬂoats. Except when writing low-level C code, it’s generally better to let the iterator handle the copying or buffering instead of casting the data type yourself in the inner loop. There are two mechanisms which allow this to be done, temporary copies and buffering mode. With temporary copies, a copy of the entire array is made with the new data type, then iteration is done in the copy. Write access is permitted through a mode which updates the original array after all the iteration is complete. The major drawback of temporary copies is that the temporary copy may consume a large amount of memory, particularly if the iteration data type has a larger itemsize than the original one. Buffering mode mitigates the memory usage issue and is more cache-friendly than making temporary copies. Except for special cases, where the whole array is needed at once outside the iterator, buffering is recommended over tem- porary copying. Within NumPy, buffering is used by the ufuncs and other functions to support ﬂexible inputs with minimal memory overhead. In our examples, we will treat the input array with a complex data type, so that we can take square roots of negative numbers. Without enabling copies or buffering mode, the iterator will raise an exception if the data type doesn’t match precisely. Example >>> a= np.arange(6).reshape(2,3)-3 >>> for x in np.nditer(a, op_dtypes=[’complex128’]): ... print np.sqrt(x), ... Traceback (most recent call last): File "", line1, in TypeError: Iterator operand required copying or buffering, but neither copying nor buffering was enabled In copying mode, ‘copy’ is speciﬁed as a per-operand ﬂag. This is done to provide control in a per-operand fashion. Buffering mode is speciﬁed as an iterator ﬂag. Example >>> a= np.arange(6).reshape(2,3)-3 >>> for x in np.nditer(a, op_flags=[’readonly’,’copy’], ... op_dtypes=[’complex128’]): ... print np.sqrt(x), ... 1.73205080757j 1.41421356237j 1j 0j (1+0j) (1.41421356237+0j) >>> for x in np.nditer(a, flags=[’buffered’], op_dtypes=[’complex128’]): ... print np.sqrt(x), ... 1.73205080757j 1.41421356237j 1j 0j (1+0j) (1.41421356237+0j) The iterator uses NumPy’s casting rules to determine whether a speciﬁc conversion is permitted. By default, it enforces ‘safe’ casting. This means, for example, that it will raise an exception if you try to treat a 64-bit ﬂoat array as a 32-bit ﬂoat array. In many cases, the rule ‘same_kind’ is the most reasonable rule to use, since it will allow conversion from 64 to 32-bit ﬂoat, but not from ﬂoat to int or from complex to ﬂoat. Example 1.5. Iterating Over Arrays 111 NumPy Reference, Release 1.8.1 >>> a= np.arange(6.) >>> for x in np.nditer(a, flags=[’buffered’], op_dtypes=[’float32’]): ... print x, ... Traceback (most recent call last): File "", line1, in TypeError: Iterator operand 0 dtype could not be cast from dtype(’float64’) to dtype(’float32’) according to the rule ’safe’ >>> for x in np.nditer(a, flags=[’buffered’], op_dtypes=[’float32’], ... casting=’same_kind’): ... print x, ... 0.0 1.0 2.0 3.0 4.0 5.0 >>> for x in np.nditer(a, flags=[’buffered’], op_dtypes=[’int32’], casting=’same_kind’): ... print x, ... Traceback (most recent call last): File "", line1, in TypeError: Iterator operand 0 dtype could not be cast from dtype(’float64’) to dtype(’int32’) according to the rule ’same_kind’ One thing to watch out for is conversions back to the original data type when using a read-write or write-only operand. A common case is to implement the inner loop in terms of 64-bit ﬂoats, and use ‘same_kind’ casting to allow the other ﬂoating-point types to be processed as well. While in read-only mode, an integer array could be provided, read-write mode will raise an exception because conversion back to the array would violate the casting rule. Example >>> a= np.arange(6) >>> for x in np.nditer(a, flags=[’buffered’], op_flags=[’readwrite’], ... op_dtypes=[’float64’], casting=’same_kind’): ... x[...]=x/ 2.0 ... Traceback (most recent call last): File "", line2, in TypeError: Iterator requested dtype could not be cast from dtype(’float64’) to dtype(’int64’), the operand 0 dtype, according to the rule ’same_kind’ 1.5.2 Broadcasting Array Iteration NumPy has a set of rules for dealing with arrays that have differing shapes which are applied whenever functions take multiple operands which combine element-wise. This is called broadcasting. The nditer object can apply these rules for you when you need to write such a function. As an example, we print out the result of broadcasting a one and a two dimensional array together. Example >>> a= np.arange(3) >>> b= np.arange(6).reshape(2,3) >>> for x, y in np.nditer([a,b]): ... print "%d:%d"% (x,y), ... 0:0 1:1 2:2 0:3 1:4 2:5 112 Chapter 1. Array objects NumPy Reference, Release 1.8.1 When a broadcasting error occurs, the iterator raises an exception which includes the input shapes to help diagnose the problem. Example >>> a= np.arange(2) >>> b= np.arange(6).reshape(2,3) >>> for x, y in np.nditer([a,b]): ... print "%d:%d"% (x,y), ... Traceback (most recent call last): File "", line1, in ValueError: operands could not be broadcast together with shapes (2) (2,3) Iterator-Allocated Output Arrays A common case in NumPy functions is to have outputs allocated based on the broadcasting of the input, and addition- ally have an optional parameter called ‘out’ where the result will be placed when it is provided. The nditer object provides a convenient idiom that makes it very easy to support this mechanism. We’ll show how this works by creating a function square which squares its input. Let’s start with a minimal function deﬁnition excluding ‘out’ parameter support. Example >>> def square(a): ... it= np.nditer([a, None]) ... for x, y in it: ... y[...]=x *x ... return it.operands[1] ... >>> square([1,2,3]) array([1, 4, 9]) By default, the nditer uses the ﬂags ‘allocate’ and ‘writeonly’ for operands that are passed in as None. This means we were able to provide just the two operands to the iterator, and it handled the rest. When adding the ‘out’ parameter, we have to explicitly provide those ﬂags, because if someone passes in an array as ‘out’, the iterator will default to ‘readonly’, and our inner loop would fail. The reason ‘readonly’ is the default for input arrays is to prevent confusion about unintentionally triggering a reduction operation. If the default were ‘readwrite’, any broadcasting operation would also trigger a reduction, a topic which is covered later in this document. While we’re at it, let’s also introduce the ‘no_broadcast’ ﬂag, which will prevent the output from being broadcast. This is important, because we only want one input value for each output. Aggregating more than one input value is a reduction operation which requires special handling. It would already raise an error because reductions must be explicitly enabled in an iterator ﬂag, but the error message that results from disabling broadcasting is much more understandable for end-users. To see how to generalize the square function to a reduction, look at the sum of squares function in the section about Cython. For completeness, we’ll also add the ‘external_loop’ and ‘buffered’ ﬂags, as these are what you will typically want for performance reasons. Example 1.5. Iterating Over Arrays 113 NumPy Reference, Release 1.8.1 >>> def square(a, out=None): ... it= np.nditer([a, out], ... flags=[’external_loop’,’buffered’], ... op_flags=[[’readonly’], ... [’writeonly’,’allocate’,’no_broadcast’]]) ... for x, y in it: ... y[...]=x *x ... return it.operands[1] ... >>> square([1,2,3]) array([1, 4, 9]) >>> b= np.zeros((3,)) >>> square([1,2,3], out=b) array([ 1., 4., 9.]) >>> b array([ 1., 4., 9.]) >>> square(np.arange(6).reshape(2,3), out=b) Traceback (most recent call last): File "", line1, in File "", line4, in square ValueError: non-broadcastable output operand with shape (3) doesn’t match the broadcast shape (2,3) Outer Product Iteration Any binary operation can be extended to an array operation in an outer product fashion like in outer, and the nditer object provides a way to accomplish this by explicitly mapping the axes of the operands. It is also possible to do this with newaxis indexing, but we will show you how to directly use the nditer op_axes parameter to accomplish this with no intermediate views. We’ll do a simple outer product, placing the dimensions of the ﬁrst operand before the dimensions of the second operand. The op_axes parameter needs one list of axes for each operand, and provides a mapping from the iterator’s axes to the axes of the operand. Suppose the ﬁrst operand is one dimensional and the second operand is two dimensional. The iterator will have three dimensions, so op_axes will have two 3-element lists. The ﬁrst list picks out the one axis of the ﬁrst operand, and is -1 for the rest of the iterator axes, with a ﬁnal result of [0, -1, -1]. The second list picks out the two axes of the second operand, but shouldn’t overlap with the axes picked out in the ﬁrst operand. Its list is [-1, 0, 1]. The output operand maps onto the iterator axes in the standard manner, so we can provide None instead of constructing another list. The operation in the inner loop is a straightforward multiplication. Everything to do with the outer product is handled by the iterator setup. Example >>> a= np.arange(3) >>> b= np.arange(8).reshape(2,4) >>> it= np.nditer([a, b, None], flags=[’external_loop’], ... op_axes=[[0,-1,-1], [-1,0,1], None]) >>> for x, y, z in it: ... z[...]=x *y ... >>> it.operands[2] array([[[ 0, 0, 0, 0], 114 Chapter 1. Array objects NumPy Reference, Release 1.8.1 [ 0, 0, 0, 0]], [[ 0, 1, 2, 3], [ 4, 5, 6, 7]], [[ 0, 2, 4, 6], [ 8, 10, 12, 14]]]) Reduction Iteration Whenever a writeable operand has fewer elements than the full iteration space, that operand is undergoing a reduction. The nditer object requires that any reduction operand be ﬂagged as read-write, and only allows reductions when ‘reduce_ok’ is provided as an iterator ﬂag. For a simple example, consider taking the sum of all elements in an array. Example >>> a= np.arange(24).reshape(2,3,4) >>> b= np.array(0) >>> for x, y in np.nditer([a, b], flags=[’reduce_ok’,’external_loop’], ... op_flags=[[’readonly’], [’readwrite’]]): ... y[...]+=x ... >>> b array(276) >>> np.sum(a) 276 Things are a little bit more tricky when combining reduction and allocated operands. Before iteration is started, any reduction operand must be initialized to its starting values. Here’s how we can do this, taking sums along the last axis of a. Example >>> a= np.arange(24).reshape(2,3,4) >>> it= np.nditer([a, None], flags=[’reduce_ok’,’external_loop’], ... op_flags=[[’readonly’], [’readwrite’,’allocate’]], ... op_axes=[None,[0,1,-1]]) >>> it.operands[1][...]=0 >>> for x, y in it: ... y[...]+=x ... >>> it.operands[1] array([[ 6, 22, 38], [54, 70, 86]]) >>> np.sum(a, axis=2) array([[ 6, 22, 38], [54, 70, 86]]) To do buffered reduction requires yet another adjustment during the setup. Normally the iterator construction involves copying the ﬁrst buffer of data from the readable arrays into the buffer. Any reduction operand is readable, so it may be read into a buffer. Unfortunately, initialization of the operand after this buffering operation is complete will not be reﬂected in the buffer that the iteration starts with, and garbage results will be produced. 1.5. Iterating Over Arrays 115 NumPy Reference, Release 1.8.1 The iterator ﬂag “delay_bufalloc” is there to allow iterator-allocated reduction operands to exist together with buffer- ing. When this ﬂag is set, the iterator will leave its buffers uninitialized until it receives a reset, after which it will be ready for regular iteration. Here’s how the previous example looks if we also enable buffering. Example >>> a= np.arange(24).reshape(2,3,4) >>> it= np.nditer([a, None], flags=[’reduce_ok’,’external_loop’, ... ’buffered’,’delay_bufalloc’], ... op_flags=[[’readonly’], [’readwrite’,’allocate’]], ... op_axes=[None,[0,1,-1]]) >>> it.operands[1][...]=0 >>> it.reset() >>> for x, y in it: ... y[...]+=x ... >>> it.operands[1] array([[ 6, 22, 38], [54, 70, 86]]) 1.5.3 Putting the Inner Loop in Cython Those who want really good performance out of their low level operations should strongly consider directly using the iteration API provided in C, but for those who are not comfortable with C or C++, Cython is a good middle ground with reasonable performance tradeoffs. For the nditer object, this means letting the iterator take care of broadcasting, dtype conversion, and buffering, while giving the inner loop to Cython. For our example, we’ll create a sum of squares function. To start, let’s implement this function in straightforward Python. We want to support an ‘axis’ parameter similar to the numpy sum function, so we will need to construct a list for the op_axes parameter. Here’s how this looks. Example >>> def axis_to_axeslist(axis, ndim): ... if axis is None: ... return [-1]* ndim ... else: ... if type(axis) is not tuple: ... axis= (axis,) ... axeslist=[1]* ndim ... for i in axis: ... axeslist[i]=-1 ... ax=0 ... for i in range(ndim): ... if axeslist[i] !=-1: ... axeslist[i]= ax ... ax+=1 ... return axeslist ... >>> def sum_squares_py(arr, axis=None, out=None): ... axeslist= axis_to_axeslist(axis, arr.ndim) ... it= np.nditer([arr, out], flags=[’reduce_ok’,’external_loop’, ... ’buffered’,’delay_bufalloc’], ... op_flags=[[’readonly’], [’readwrite’,’allocate’]], ... op_axes=[None, axeslist], 116 Chapter 1. Array objects NumPy Reference, Release 1.8.1 ... op_dtypes=[’float64’,’float64’]) ... it.operands[1][...]=0 ... it.reset() ... for x, y in it: ... y[...]+=x *x ... return it.operands[1] ... >>> a= np.arange(6).reshape(2,3) >>> sum_squares_py(a) array(55.0) >>> sum_squares_py(a, axis=-1) array([ 5., 50.]) To Cython-ize this function, we replace the inner loop (y[...] += x*x) with Cython code that’s specialized for the ﬂoat64 dtype. With the ‘external_loop’ ﬂag enabled, the arrays provided to the inner loop will always be one-dimensional, so very little checking needs to be done. Here’s the listing of sum_squares.pyx: import numpy as np cimport numpy as np cimport cython def axis_to_axeslist(axis, ndim): if axis is None: return [-1] * ndim else: if type(axis) is not tuple: axis = (axis,) axeslist = [1] * ndim for i in axis: axeslist[i] = -1 ax = 0 for i in range(ndim): if axeslist[i] != -1: axeslist[i] = ax ax += 1 return axeslist @cython.boundscheck(False) def sum_squares_cy(arr, axis=None, out=None): cdef np.ndarray[double] x cdef np.ndarray[double] y cdef int size cdef double value axeslist = axis_to_axeslist(axis, arr.ndim) it = np.nditer([arr, out], flags=[’reduce_ok’, ’external_loop’, ’buffered’, ’delay_bufalloc’], op_flags=[[’readonly’], [’readwrite’, ’allocate’]], op_axes=[None, axeslist], op_dtypes=[’float64’, ’float64’]) it.operands[1][...] = 0 it.reset() for xarr, yarr in it: x = xarr y = yarr size = x.shape[0] 1.5. Iterating Over Arrays 117 NumPy Reference, Release 1.8.1 for i in range(size): value = x[i] y[i] = y[i] + value * value return it.operands[1] On this machine, building the .pyx ﬁle into a module looked like the following, but you may have to ﬁnd some Cython tutorials to tell you the speciﬁcs for your system conﬁguration.: $ cython sum_squares.pyx $ gcc -shared -pthread -fPIC -fwrapv -O2 -Wall -I/usr/include/python2.7 -fno-strict-aliasing -o sum_squares.so sum_squares.c Running this from the Python interpreter produces the same answers as our native Python/NumPy code did. Example >>> from sum_squares import sum_squares_cy >>> a= np.arange(6).reshape(2,3) >>> sum_squares_cy(a) array(55.0) >>> sum_squares_cy(a, axis=-1) array([ 5., 50.]) Doing a little timing in IPython shows that the reduced overhead and memory allocation of the Cython inner loop is providing a very nice speedup over both the straightforward Python code and an expression using NumPy’s built-in sum function.: >>> a= np.random.rand(1000,1000) >>> timeit sum_squares_py(a, axis=-1) 10 loops, best of 3: 37.1 ms per loop >>> timeit np.sum(a*a, axis=-1) 10 loops, best of 3: 20.9 ms per loop >>> timeit sum_squares_cy(a, axis=-1) 100 loops, best of 3: 11.8 ms per loop >>> np.all(sum_squares_cy(a, axis=-1) == np.sum(a*a, axis=-1)) True >>> np.all(sum_squares_py(a, axis=-1) == np.sum(a*a, axis=-1)) True 1.6 Standard array subclasses The ndarray in NumPy is a “new-style” Python built-in-type. Therefore, it can be inherited from (in Python or in C) if desired. Therefore, it can form a foundation for many useful classes. Often whether to sub-class the array object or to simply use the core array component as an internal part of a new class is a difﬁcult decision, and can be simply a matter of choice. NumPy has several tools for simplifying how your new object interacts with other array objects, and so the choice may not be signiﬁcant in the end. One way to simplify the question is by asking yourself if the object you are interested in can be replaced as a single array or does it really require two or more arrays at its core. Note that asarray always returns the base-class ndarray. If you are conﬁdent that your use of the array object can handle any subclass of an ndarray, then asanyarray can be used to allow subclasses to propagate more cleanly through your subroutine. In principal a subclass could redeﬁne any aspect of the array and therefore, under strict 118 Chapter 1. Array objects NumPy Reference, Release 1.8.1 guidelines, asanyarray would rarely be useful. However, most subclasses of the arrayobject will not redeﬁne certain aspects of the array object such as the buffer interface, or the attributes of the array. One important example, however, of why your subroutine may not be able to handle an arbitrary subclass of an array is that matrices redeﬁne the “*” operator to be matrix-multiplication, rather than element-by-element multiplication. 1.6.1 Special attributes and methods See Also: Subclassing ndarray Numpy provides several hooks that subclasses of ndarray can customize: numpy.__array_finalize__(self) This method is called whenever the system internally allocates a new array from obj, where obj is a subclass (subtype) of the ndarray. It can be used to change attributes of self after construction (so as to ensure a 2-d matrix for example), or to update meta-information from the “parent.” Subclasses inherit a default implementation of this method that does nothing. numpy.__array_prepare__(array, context=None) At the beginning of every ufunc, this method is called on the input object with the highest array priority, or the output object if one was speciﬁed. The output array is passed in and whatever is returned is passed to the ufunc. Subclasses inherit a default implementation of this method which simply returns the output array unmodiﬁed. Subclasses may opt to use this method to transform the output array into an instance of the subclass and update metadata before returning the array to the ufunc for computation. numpy.__array_wrap__(array, context=None) At the end of every ufunc, this method is called on the input object with the highest array priority, or the output object if one was speciﬁed. The ufunc-computed array is passed in and whatever is returned is passed to the user. Subclasses inherit a default implementation of this method, which transforms the array into a new instance of the object’s class. Subclasses may opt to use this method to transform the output array into an instance of the subclass and update metadata before returning the array to the user. numpy.__array_priority__ The value of this attribute is used to determine what type of object to return in situations where there is more than one possibility for the Python type of the returned object. Subclasses inherit a default value of 1.0 for this attribute. numpy.__array__([dtype]) If a class having the __array__ method is used as the output object of an ufunc, results will be written to the object returned by __array__. 1.6.2 Matrix objects matrix objects inherit from the ndarray and therefore, they have the same attributes and methods of ndarrays. There are six important differences of matrix objects, however, that may lead to unexpected results when you use matrices but expect them to act like arrays: 1. Matrix objects can be created using a string notation to allow Matlab-style syntax where spaces separate columns and semicolons (‘;’) separate rows. 2. Matrix objects are always two-dimensional. This has far-reaching implications, in that m.ravel() is still two- dimensional (with a 1 in the ﬁrst dimension) and item selection returns two-dimensional objects so that sequence behavior is fundamentally different than arrays. 1.6. Standard array subclasses 119 NumPy Reference, Release 1.8.1 3. Matrix objects over-ride multiplication to be matrix-multiplication. Make sure you understand this for func- tions that you may want to receive matrices. Especially in light of the fact that asanyarray(m) returns a matrix when m is a matrix. 4. Matrix objects over-ride power to be matrix raised to a power. The same warning about using power inside a function that uses asanyarray(...) to get an array object holds for this fact. 5. The default __array_priority__ of matrix objects is 10.0, and therefore mixed operations with ndarrays always produce matrices. 6. Matrices have special attributes which make calculations easier. These are matrix.T transpose matrix.H hermitian (conjugate) transpose matrix.I inverse matrix.A base array matrix.T transpose matrix.H hermitian (conjugate) transpose matrix.I inverse matrix.A base array Warning: Matrix objects over-ride multiplication, ‘*’, and power, ‘**’, to be matrix-multiplication and matrix power, respectively. If your subroutine can accept sub-classes and you do not convert to base- class arrays, then you must use the ufuncs multiply and power to be sure that you are performing the correct operation for all inputs. The matrix class is a Python subclass of the ndarray and can be used as a reference for how to construct your own subclass of the ndarray. Matrices can be created from other matrices, strings, and anything else that can be converted to an ndarray . The name “mat “is an alias for “matrix “in NumPy. matrix Returns a matrix from an array-like object, or from a string of data. asmatrix(data[, dtype]) Interpret the input as a matrix. bmat(obj[, ldict, gdict]) Build a matrix object from a string, nested sequence, or array. class numpy.matrix Returns a matrix from an array-like object, or from a string of data. A matrix is a specialized 2-D array that retains its 2-D nature through operations. It has certain special operators, such as *(matrix multiplication) and ** (matrix power). Parameters data : array_like or string If data is a string, it is interpreted as a matrix with commas or spaces separating columns, and semicolons separating rows. dtype : data-type Data-type of the output matrix. copy : bool 120 Chapter 1. Array objects NumPy Reference, Release 1.8.1 If data is already an ndarray, then this ﬂag determines whether the data is copied (the default), or whether a view is constructed. See Also: array Examples >>> a= np.matrix(’1 2; 3 4’) >>> print a [[1 2] [3 4]] >>> np.matrix([[1,2], [3,4]]) matrix([[1, 2], [3, 4]]) Attributes A base array A1 1-d base array H hermitian (conjugate) transpose I inverse T transpose base Base object if memory is from some other object. ctypes An object to simplify the interaction of the array with the ctypes module. data Python buffer object pointing to the start of the array’s data. dtype Data-type of the array’s elements. flags Information about the memory layout of the array. flat A 1-D iterator over the array. imag The imaginary part of the array. itemsize Length of one array element in bytes. nbytes Total bytes consumed by the elements of the array. ndim Number of array dimensions. real The real part of the array. shape Tuple of array dimensions. size Number of elements in the array. strides Tuple of bytes to step in each dimension when traversing an array. matrix.A base array matrix.A1 1-d base array matrix.H hermitian (conjugate) transpose matrix.I inverse matrix.T transpose matrix.base Base object if memory is from some other object. 1.6. Standard array subclasses 121 NumPy Reference, Release 1.8.1 Examples The base of an array that owns its memory is None: >>> 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 matrix.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 c : Python object Possessing attributes data, shape, strides, etc. See Also: numpy.ctypeslib 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): •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 ﬂags 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]. •shape (c_intp*self.ndim): A ctypes array of length self.ndim where the basetype is the C-integer corresponding to dtype(‘p’) on this platform. This base-type could be c_int, c_long, or c_longlong depending on the platform. The c_intp type is deﬁned accordingly in numpy.ctypeslib. The ctypes array contains the shape of the underlying array. •strides (c_intp*self.ndim): 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. •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 ﬂoating-point data: self.data_as(ctypes.POINTER(ctypes.c_double)). •shape_as(obj): Return the shape tuple as an array of some other c-types type. For example: self.shape_as(ctypes.c_short). •strides_as(obj): Return the strides tuple as an array of some other c-types type. For example: self.strides_as(ctypes.c_longlong). 122 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Be careful using the ctypes attribute - especially on temporary arrays or arrays constructed on the ﬂy. For example, calling (a+b).ctypes.data_as(ctypes.c_void_p) returns a pointer to memory that is invalid because the array created as (a+b) is deallocated before the next Python statement. You can avoid this problem using either c=a+b or ct=(a+b).ctypes. In the latter case, ct will hold a reference to the array until ct is deleted or re-assigned. 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 ctypes >>> x array([[0, 1], [2, 3]]) >>> x.ctypes.data 30439712 >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents c_long(0) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents c_longlong(4294967296L) >>> x.ctypes.shape >>> x.ctypes.shape_as(ctypes.c_long) >>> x.ctypes.strides >>> x.ctypes.strides_as(ctypes.c_longlong) matrix.data Python buffer object pointing to the start of the array’s data. matrix.dtype Data-type of the array’s elements. Parameters None Returns d : numpy dtype object See Also: numpy.dtype Examples >>> x array([[0, 1], [2, 3]]) >>> x.dtype dtype(’int32’) >>> type(x.dtype) matrix.flags Information about the memory layout of the array. 1.6. Standard array subclasses 123 NumPy Reference, Release 1.8.1 Notes The flags object can be accessed dictionary-like (as in a.flags[’WRITEABLE’]), or by using low- ercased attribute names (as in a.flags.writeable). Short ﬂag names are only supported in dictionary access. Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED ﬂags can be changed by the user, via direct assignment to the attribute or dictionary entry, or by calling ndarray.setflags. The array ﬂags cannot be set arbitrarily: •UPDATEIFCOPY 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 arbi- trary 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. 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. OWN- DATA (O) The array owns the memory it uses or borrows it from another object. WRITE- ABLE (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. UP- DATEIF- COPY (U) This array is a copy of some other array. When this array is deallocated, 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. 124 Chapter 1. Array objects NumPy Reference, Release 1.8.1 matrix.flat A 1-D iterator over the array. This is a numpy.flatiter instance, which acts similarly to, but is not a subclass of, Python’s built-in iterator object. See Also: flatten Return a copy of the array collapsed into one dimension. flatiter Examples >>> x= np.arange(1,7).reshape(2,3) >>> x array([[1, 2, 3], [4, 5, 6]]) >>> x.flat[3] 4 >>> x.T array([[1, 4], [2, 5], [3, 6]]) >>> x.T.flat[3] 5 >>> type(x.flat) An assignment example: >>> x.flat=3; x array([[3, 3, 3], [3, 3, 3]]) >>> x.flat[[1,4]]=1; x array([[3, 1, 3], [3, 1, 3]]) matrix.imag The imaginary part of the array. Examples >>> x= np.sqrt([1+0j,0+1j]) >>> x.imag array([ 0. , 0.70710678]) >>> x.imag.dtype dtype(’float64’) matrix.itemsize Length of one array element in bytes. Examples >>> x= np.array([1,2,3], dtype=np.float64) >>> x.itemsize 8 >>> x= np.array([1,2,3], dtype=np.complex128) 1.6. Standard array subclasses 125 NumPy Reference, Release 1.8.1 >>> x.itemsize 16 matrix.nbytes Total bytes consumed by the elements of the array. Notes Does not include memory consumed by non-element attributes of the array object. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.nbytes 480 >>> np.prod(x.shape) * x.itemsize 480 matrix.ndim Number of array dimensions. Examples >>> x= np.array([1,2,3]) >>> x.ndim 1 >>> y= np.zeros((2,3,4)) >>> y.ndim 3 matrix.real The real part of the array. See Also: numpy.real equivalent function Examples >>> x= np.sqrt([1+0j,0+1j]) >>> x.real array([ 1. , 0.70710678]) >>> x.real.dtype dtype(’float64’) matrix.shape Tuple of array dimensions. Notes May be used to “reshape” the array, as long as this would not require a change in the total number of elements Examples >>> x= np.array([1,2,3,4]) >>> x.shape (4,) >>> y= np.zeros((2,3,4)) 126 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> y.shape (2, 3, 4) >>> y.shape=(3,8) >>> y array([[ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.]]) >>> y.shape=(3,6) Traceback (most recent call last): File "", line1, in ValueError: total size of new array must be unchanged matrix.size Number of elements in the array. Equivalent to np.prod(a.shape), i.e., the product of the array’s dimensions. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.size 30 >>> np.prod(x.shape) 30 matrix.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 “ndarray.rst” ﬁle in the NumPy reference guide. See Also: numpy.lib.stride_tricks.as_strided 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 >>> y= np.reshape(np.arange(2 *3*4), (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]]]) 1.6. Standard array subclasses 127 NumPy Reference, Release 1.8.1 >>> y.strides (48, 16, 4) >>> y[1,1,1] 17 >>> offset=sum(y.strides * np.array((1,1,1))) >>> offset/y.itemsize 17 >>> x= np.reshape(np.arange(5 *6*7*8), (5,6,7,8)).transpose(2,3,1,0) >>> x.strides (32, 4, 224, 1344) >>> i= np.array([3,5,2,2]) >>> offset= sum(i * x.strides) >>> x[3,5,2,2] 813 >>> offset/x.itemsize 813 Methods all([axis, out]) Test whether all matrix elements along a given axis evaluate to True. any([axis, out]) Test whether any array element along a given axis evaluates to True. argmax([axis, out]) Indices of the maximum values along an axis. argmin([axis, out]) Return the indices of the minimum values along an axis. argpartition(kth[, axis, kind, order]) Returns the indices that would partition this array. argsort([axis, kind, order]) Returns the indices that would sort this array. astype(dtype[, order, casting, subok, copy]) Copy of the array, cast to a speciﬁed 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(a_min, a_max[, out]) Return an array whose values are limited to [a_min, a_max]. compress(condition[, axis, out]) Return selected slices of this array along given axis. conj() Complex-conjugate all elements. conjugate() Return the complex conjugate, element-wise. copy([order]) Return a copy of the array. cumprod([axis, dtype, out]) Return the cumulative product of the elements along the given axis. cumsum([axis, dtype, out]) Return the cumulative sum of the elements along the given axis. diagonal([offset, axis1, axis2]) Return speciﬁed diagonals. dot(b[, out]) Dot product of two arrays. dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. dumps() Returns the pickle of the array as a string. fill(value) Fill the array with a scalar value. flatten([order]) Return a copy of the array collapsed into one dimension. getA() Return self as an ndarray object. getA1() Return self as a ﬂattened ndarray. getH() Returns the (complex) conjugate transpose of self. getI() Returns the (multiplicative) inverse of invertible self. getT() Returns the transpose of the matrix. getfield(dtype[, offset]) Returns a ﬁeld of the given array as a certain type. item(*args) Copy an element of an array to a standard Python scalar and return it. itemset(*args) Insert scalar into an array (scalar is cast to array’s dtype, if possible) max([axis, out]) Return the maximum value along an axis. mean([axis, dtype, out]) Returns the average of the matrix elements along the given axis. min([axis, out]) Return the minimum value along an axis. Continued on next page 128 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Table 1.40 – continued from previous page newbyteorder([new_order]) Return the array with the same data viewed with a different byte order. nonzero() Return the indices of the elements that are non-zero. partition(kth[, axis, kind, order]) Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. prod([axis, dtype, out]) Return the product of the array elements over the given axis. ptp([axis, out]) Peak-to-peak (maximum - minimum) value along the given axis. put(indices, values[, mode]) Set a.flat[n] = values[n] for all n in indices. ravel([order]) Return a ﬂattened array. repeat(repeats[, axis]) Repeat elements of an array. reshape(shape[, order]) Returns an array containing the same data with a new shape. resize(new_shape[, refcheck]) Change shape and size of array in-place. round([decimals, out]) Return a with 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. setfield(val, dtype[, offset]) Put a value into a speciﬁed place in a ﬁeld deﬁned by a data-type. setflags([write, align, uic]) Set array ﬂags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. sort([axis, kind, order]) Sort an array, in-place. squeeze([axis]) Remove single-dimensional entries from the shape of a. std([axis, dtype, out, ddof]) Return the standard deviation of the array elements along the given axis. sum([axis, dtype, out]) Returns the sum of the matrix elements, along the given axis. swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. take(indices[, axis, out, mode]) Return an array formed from the elements of a at the given indices. tofile(ﬁd[, sep, format]) Write array to a ﬁle as text or binary (default). tolist() Return the matrix as a (possibly nested) list. tostring([order]) Construct a Python string containing the raw data bytes in the 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. var([axis, dtype, out, ddof]) Returns the variance of the matrix elements, along the given axis. view([dtype, type]) New view of array with the same data. matrix.all(axis=None, out=None) Test whether all matrix elements along a given axis evaluate to True. Parameters See ‘numpy.all‘ for complete descriptions See Also: numpy.all Notes This is the same as ndarray.all, but it returns a matrix object. Examples >>> x= np.matrix(np.arange(12).reshape((3,4))); x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> y= x[0]; y matrix([[0, 1, 2, 3]]) >>> (x == y) matrix([[ True, True, True, True], [False, False, False, False], [False, False, False, False]], dtype=bool) >>> (x == y).all() 1.6. Standard array subclasses 129 NumPy Reference, Release 1.8.1 False >>> (x == y).all(0) matrix([[False, False, False, False]], dtype=bool) >>> (x == y).all(1) matrix([[ True], [False], [False]], dtype=bool) matrix.any(axis=None, out=None) Test whether any array element along a given axis evaluates to True. Refer to numpy.any for full documentation. Parameters axis : int, optional Axis along which logical OR is performed out : ndarray, optional Output to existing array instead of creating new one, must have same shape as expected output Returns any : bool, ndarray Returns a single bool if axis is None; otherwise, returns ndarray matrix.argmax(axis=None, out=None) Indices of the maximum values along an axis. Parameters See ‘numpy.argmax‘ for complete descriptions See Also: numpy.argmax Notes This is the same as ndarray.argmax, but returns a matrix object where ndarray.argmax would return an ndarray. Examples >>> x= np.matrix(np.arange(12).reshape((3,4))); x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> x.argmax() 11 >>> x.argmax(0) matrix([[2, 2, 2, 2]]) >>> x.argmax(1) matrix([[3], [3], [3]]) matrix.argmin(axis=None, out=None) Return the indices of the minimum values along an axis. Parameters See ‘numpy.argmin‘ for complete descriptions. 130 Chapter 1. Array objects NumPy Reference, Release 1.8.1 See Also: numpy.argmin Notes This is the same as ndarray.argmin, but returns a matrix object where ndarray.argmin would return an ndarray. Examples >>> x=-np.matrix(np.arange(12).reshape((3,4))); x matrix([[ 0, -1, -2, -3], [ -4, -5, -6, -7], [ -8, -9, -10, -11]]) >>> x.argmin() 11 >>> x.argmin(0) matrix([[2, 2, 2, 2]]) >>> x.argmin(1) matrix([[3], [3], [3]]) matrix.argpartition(kth, axis=-1, kind=’introselect’, order=None) Returns the indices that would partition this array. Refer to numpy.argpartition for full documentation. New in version 1.8.0. See Also: numpy.argpartition equivalent function matrix.argsort(axis=-1, kind=’quicksort’, order=None) Returns the indices that would sort this array. Refer to numpy.argsort for full documentation. See Also: numpy.argsort equivalent function matrix.astype(dtype, order=’K’, casting=’unsafe’, subok=True, copy=True) Copy of the array, cast to a speciﬁed type. Parameters dtype : str 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 1.6. Standard array subclasses 131 NumPy Reference, Release 1.8.1 Controls what kind of data casting may occur. Defaults to ‘unsafe’ for backwards com- patibility. • ‘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 ﬂoat64 to ﬂoat32, are allowed. • ‘unsafe’ means any data conversions may be done. subok : bool, optional If True, then sub-classes will be passed-through (default), otherwise the returned array will be forced to be a base-class array. copy : bool, optional By default, astype always returns a newly allocated array. If this is set to false, and the dtype, order, and subok requirements are satisﬁed, the input array is returned instead of a copy. Returns arr_t : ndarray Unless copy is False and the other conditions for returning the input array are satisﬁed (see description for copy input paramter), 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 ﬂoat or int. To avoid this, one should use a.real.astype(t). Examples >>> x= np.array([1,2, 2.5]) >>> x array([ 1. , 2. , 2.5]) >>> x.astype(int) array([1, 2, 2]) matrix.byteswap(inplace) Swap the bytes of the array elements Toggle between low-endian and big-endian data representation by returning a byteswapped array, option- ally swapped in-place. Parameters inplace : bool, optional If True, swap bytes in-place, default is False. Returns out : ndarray The byteswapped array. If inplace is True, this is a view to self. 132 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> A= np.array([1, 256, 8755], dtype=np.int16) >>> map(hex, A) [’0x1’, ’0x100’, ’0x2233’] >>> A.byteswap(True) array([ 256, 1, 13090], dtype=int16) >>> map(hex, A) [’0x100’, ’0x1’, ’0x3322’] Arrays of strings are not swapped >>> A= np.array([’ceg’,’fac’]) >>> A.byteswap() array([’ceg’, ’fac’], dtype=’|S3’) matrix.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. See Also: numpy.choose equivalent function matrix.clip(a_min, a_max, out=None) Return an array whose values are limited to [a_min, a_max]. Refer to numpy.clip for full documentation. See Also: numpy.clip equivalent function matrix.compress(condition, axis=None, out=None) Return selected slices of this array along given axis. Refer to numpy.compress for full documentation. See Also: numpy.compress equivalent function matrix.conj() Complex-conjugate all elements. Refer to numpy.conjugate for full documentation. See Also: numpy.conjugate equivalent function matrix.conjugate() Return the complex conjugate, element-wise. 1.6. Standard array subclasses 133 NumPy Reference, Release 1.8.1 Refer to numpy.conjugate for full documentation. See Also: numpy.conjugate equivalent function matrix.copy(order=’C’) Return a copy of the array. 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 :func:numpy.copy are very similar, but have different default values for their order= arguments.) See Also: numpy.copy, numpy.copyto Examples >>> 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 matrix.cumprod(axis=None, dtype=None, out=None) Return the cumulative product of the elements along the given axis. Refer to numpy.cumprod for full documentation. See Also: numpy.cumprod equivalent function matrix.cumsum(axis=None, dtype=None, out=None) Return the cumulative sum of the elements along the given axis. Refer to numpy.cumsum for full documentation. See Also: numpy.cumsum equivalent function 134 Chapter 1. Array objects NumPy Reference, Release 1.8.1 matrix.diagonal(offset=0, axis1=0, axis2=1) Return speciﬁed diagonals. Refer to numpy.diagonal for full documentation. See Also: numpy.diagonal equivalent function matrix.dot(b, out=None) Dot product of two arrays. Refer to numpy.dot for full documentation. See Also: numpy.dot equivalent function Examples >>> a= np.eye(2) >>> b= np.ones((2,2)) * 2 >>> a.dot(b) array([[ 2., 2.], [ 2., 2.]]) This array method can be conveniently chained: >>> a.dot(b).dot(b) array([[ 8., 8.], [ 8., 8.]]) matrix.dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. The array can be read back with pickle.load or numpy.load. Parameters ﬁle : str A string naming the dump ﬁle. matrix.dumps() Returns the pickle of the array as a string. pickle.loads or numpy.loads will convert the string back to an array. Parameters None matrix.fill(value) Fill the array with a scalar value. Parameters value : scalar All elements of a will be assigned this value. Examples 1.6. Standard array subclasses 135 NumPy Reference, Release 1.8.1 >>> a= np.array([1,2]) >>> a.fill(0) >>> a array([0, 0]) >>> a= np.empty(2) >>> a.fill(1) >>> a array([ 1., 1.]) matrix.flatten(order=’C’) Return a copy of the array collapsed into one dimension. Parameters order : {‘C’, ‘F’, ‘A’}, optional Whether to ﬂatten in C (row-major), Fortran (column-major) order, or preserve the C/Fortran ordering from a. The default is ‘C’. Returns y : ndarray A copy of the input array, ﬂattened to one dimension. See Also: ravel Return a ﬂattened array. flat A 1-D ﬂat iterator over the array. Examples >>> a= np.array([[1,2], [3,4]]) >>> a.flatten() array([1, 2, 3, 4]) >>> a.flatten(’F’) array([1, 3, 2, 4]) matrix.getA() Return self as an ndarray object. Equivalent to np.asarray(self). Parameters None Returns ret : ndarray self as an ndarray Examples >>> x= np.matrix(np.arange(12).reshape((3,4))); x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> x.getA() array([[ 0, 1, 2, 3], 136 Chapter 1. Array objects NumPy Reference, Release 1.8.1 [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) matrix.getA1() Return self as a ﬂattened ndarray. Equivalent to np.asarray(x).ravel() Parameters None Returns ret : ndarray self, 1-D, as an ndarray Examples >>> x= np.matrix(np.arange(12).reshape((3,4))); x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> x.getA1() array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) matrix.getH() Returns the (complex) conjugate transpose of self. Equivalent to np.transpose(self) if self is real-valued. Parameters None Returns ret : matrix object complex conjugate transpose of self Examples >>> x= np.matrix(np.arange(12).reshape((3,4))) >>> z=x-1j *x; z matrix([[ 0. +0.j, 1. -1.j, 2. -2.j, 3. -3.j], [ 4. -4.j, 5. -5.j, 6. -6.j, 7. -7.j], [ 8. -8.j, 9. -9.j, 10.-10.j, 11.-11.j]]) >>> z.getH() matrix([[ 0. +0.j, 4. +4.j, 8. +8.j], [ 1. +1.j, 5. +5.j, 9. +9.j], [ 2. +2.j, 6. +6.j, 10.+10.j], [ 3. +3.j, 7. +7.j, 11.+11.j]]) matrix.getI() Returns the (multiplicative) inverse of invertible self. Parameters None Returns ret : matrix object If self is non-singular, ret is such that ret * self == self * ret == np.matrix(np.eye(self[0,:].size) all return True. 1.6. Standard array subclasses 137 NumPy Reference, Release 1.8.1 Raises numpy.linalg.LinAlgError: Singular matrix If self is singular. See Also: linalg.inv Examples >>> m= np.matrix(’[1, 2; 3, 4]’); m matrix([[1, 2], [3, 4]]) >>> m.getI() matrix([[-2. , 1. ], [ 1.5, -0.5]]) >>> m.getI() * m matrix([[ 1., 0.], [ 0., 1.]]) matrix.getT() Returns the transpose of the matrix. Does not conjugate! For the complex conjugate transpose, use getH. Parameters None Returns ret : matrix object The (non-conjugated) transpose of the matrix. See Also: transpose, getH Examples >>> m= np.matrix(’[1, 2; 3, 4]’) >>> m matrix([[1, 2], [3, 4]]) >>> m.getT() matrix([[1, 3], [2, 4]]) matrix.getfield(dtype, offset=0) Returns a ﬁeld of the given array as a certain type. A ﬁeld 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 ﬁts 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 dtype : str or dtype The data type of the view. The dtype size of the view can not be larger than that of the array itself. offset : int 138 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Number of bytes to skip before beginning the element view. Examples >>> 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.]]) matrix.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 ﬂat index into the array, specifying which ele- ment 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 z : Standard Python scalar object A copy of the speciﬁed 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 ﬁelds are deﬁned, 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 >>> x= np.random.randint(9, size=(3,3)) >>> x array([[3, 1, 7], [2, 8, 3], [8, 5, 3]]) >>> x.item(3) 2 >>> x.item(7) 5 >>> x.item((0,1)) 1.6. Standard array subclasses 139 NumPy Reference, Release 1.8.1 1 >>> x.item((2,2)) 3 matrix.itemset(*args) Insert scalar into an array (scalar is cast to array’s dtype, if possible) There must be at least 1 argument, and deﬁne the last argument as item. Then, a.itemset(*args) is equivalent to but faster than a[args] = item. The item should be a scalar value and args must select a single item in the array a. Parameters *args : Arguments If one argument: a scalar, only used in case a is of size 1. If two arguments: the last argument is the value to be set and must be a scalar, the ﬁrst argument speciﬁes a single array element location. It is either an int or a tuple. Notes Compared to indexing syntax, itemset provides some speed increase for placing a scalar into a particular location in an ndarray, if you must do this. However, generally this is discouraged: among other problems, it complicates the appearance of the code. Also, when using itemset (and item) inside a loop, be sure to assign the methods to a local variable to avoid the attribute look-up at each loop iteration. Examples >>> x= np.random.randint(9, size=(3,3)) >>> x array([[3, 1, 7], [2, 8, 3], [8, 5, 3]]) >>> x.itemset(4,0) >>> x.itemset((2,2),9) >>> x array([[3, 1, 7], [2, 0, 3], [8, 5, 9]]) matrix.max(axis=None, out=None) Return the maximum value along an axis. Parameters See ‘amax‘ for complete descriptions See Also: amax, ndarray.max Notes This is the same as ndarray.max, but returns a matrix object where ndarray.max would return an ndarray. Examples >>> x= np.matrix(np.arange(12).reshape((3,4))); x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> x.max() 140 Chapter 1. Array objects NumPy Reference, Release 1.8.1 11 >>> x.max(0) matrix([[ 8, 9, 10, 11]]) >>> x.max(1) matrix([[ 3], [ 7], [11]]) matrix.mean(axis=None, dtype=None, out=None) Returns the average of the matrix elements along the given axis. Refer to numpy.mean for full documentation. See Also: numpy.mean Notes Same as ndarray.mean except that, where that returns an ndarray, this returns a matrix object. Examples >>> x= np.matrix(np.arange(12).reshape((3,4))) >>> x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> x.mean() 5.5 >>> x.mean(0) matrix([[ 4., 5., 6., 7.]]) >>> x.mean(1) matrix([[ 1.5], [ 5.5], [ 9.5]]) matrix.min(axis=None, out=None) Return the minimum value along an axis. Parameters See ‘amin‘ for complete descriptions. See Also: amin, ndarray.min Notes This is the same as ndarray.min, but returns a matrix object where ndarray.min would return an ndarray. Examples >>> x=-np.matrix(np.arange(12).reshape((3,4))); x matrix([[ 0, -1, -2, -3], [ -4, -5, -6, -7], [ -8, -9, -10, -11]]) >>> x.min() -11 >>> x.min(0) 1.6. Standard array subclasses 141 NumPy Reference, Release 1.8.1 matrix([[ -8, -9, -10, -11]]) >>> x.min(1) matrix([[ -3], [ -7], [-11]]) matrix.newbyteorder(new_order=’S’) Return the array with the same data viewed with a different byte order. Equivalent to: arr.view(arr.dtype.newbytorder(new_order)) Changes are also made in all ﬁelds and sub-arrays of the array data type. Parameters new_order : string, optional Byte order to force; a value from the byte order speciﬁcations above. new_order codes can be any of: *’S’ - swap dtype from current to opposite endian *{’<’, ’L’} - little endian *{’>’, ’B’} - big endian *{’=’, ’N’} - native order *{’|’, ’I’} - ignore (no change to byte order) The default value (‘S’) results in swapping the current byte order. The code does a case-insensitive check on the ﬁrst letter of new_order for the alternatives above. For example, any of ‘B’ or ‘b’ or ‘biggish’ are valid to specify big-endian. Returns new_arr : array New array object with the dtype reﬂecting given change to the byte order. matrix.nonzero() Return the indices of the elements that are non-zero. Refer to numpy.nonzero for full documentation. See Also: numpy.nonzero equivalent function matrix.partition(kth, axis=-1, kind=’introselect’, order=None) Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. All elements smaller than the kth element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undeﬁned. New in version 1.8.0. Parameters kth : int or sequence of ints Element index to partition by. The kth element value will be in its ﬁnal sorted position and all smaller elements will be moved before it and all equal or greater elements behind it. The order all elements in the partitions is undeﬁned. If provided with a sequence of kth it will partition all elements indexed by kth of them into their sorted position at once. axis : int, optional 142 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Axis along which to sort. Default is -1, which means sort along the last axis. kind : {‘introselect’}, optional Selection algorithm. Default is ‘introselect’. order : list, optional When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. See Also: numpy.partition Return a parititioned copy of an array. argpartition Indirect partition. sort Full sort. Notes See np.partition for notes on the different algorithms. Examples >>> a= np.array([3,4,2,1]) >>> a.partition(a,3) >>> a array([2, 1, 3, 4]) >>> a.partition((1,3)) array([1, 2, 3, 4]) matrix.prod(axis=None, dtype=None, out=None) Return the product of the array elements over the given axis. Refer to prod for full documentation. See Also: prod, ndarray.prod Notes Same as ndarray.prod, except, where that returns an ndarray, this returns a matrix object instead. Examples >>> x= np.matrix(np.arange(12).reshape((3,4))); x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> x.prod() 0 >>> x.prod(0) matrix([[ 0, 45, 120, 231]]) >>> x.prod(1) matrix([[ 0], [ 840], [7920]]) 1.6. Standard array subclasses 143 NumPy Reference, Release 1.8.1 matrix.ptp(axis=None, out=None) Peak-to-peak (maximum - minimum) value along the given axis. Refer to numpy.ptp for full documentation. See Also: numpy.ptp Notes Same as ndarray.ptp, except, where that would return an ndarray object, this returns a matrix object. Examples >>> x= np.matrix(np.arange(12).reshape((3,4))); x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> x.ptp() 11 >>> x.ptp(0) matrix([[8, 8, 8, 8]]) >>> x.ptp(1) matrix([[3], [3], [3]]) matrix.put(indices, values, mode=’raise’) Set a.flat[n] = values[n] for all n in indices. Refer to numpy.put for full documentation. See Also: numpy.put equivalent function matrix.ravel([order ]) Return a ﬂattened array. Refer to numpy.ravel for full documentation. See Also: numpy.ravel equivalent function ndarray.flat a ﬂat iterator on the array. matrix.repeat(repeats, axis=None) Repeat elements of an array. Refer to numpy.repeat for full documentation. See Also: 144 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.repeat equivalent function matrix.reshape(shape, order=’C’) Returns an array containing the same data with a new shape. Refer to numpy.reshape for full documentation. See Also: numpy.reshape equivalent function matrix.resize(new_shape, refcheck=True) Change shape and size of array in-place. Parameters new_shape : tuple of ints, or n ints Shape of resized array. refcheck : bool, optional If False, reference count will not be checked. Default is True. Returns None Raises ValueError If a does not own its own data or references or views to it exist, and the data memory must be changed. SystemError If the order keyword argument is speciﬁed. This behaviour is a bug in NumPy. See Also: resize Return a new array with the speciﬁed shape. Notes This reallocates space for the data area if necessary. Only contiguous arrays (data elements consecutive in memory) can be resized. The purpose of the reference count check is to make sure you do not use this array as a buffer for another Python object and then reallocate the memory. However, reference counts can increase in other ways so if you are sure that you have not shared the memory for this array with another Python object, then you may safely set refcheck to False. Examples Shrinking an array: array is ﬂattened (in the order that the data are stored in memory), resized, and re- shaped: >>> a= np.array([[0,1], [2,3]], order=’C’) >>> a.resize((2,1)) >>> a 1.6. Standard array subclasses 145 NumPy Reference, Release 1.8.1 array([[0], [1]]) >>> a= np.array([[0,1], [2,3]], order=’F’) >>> a.resize((2,1)) >>> a array([[0], [2]]) Enlarging an array: as above, but missing entries are ﬁlled with zeros: >>> b= np.array([[0,1], [2,3]]) >>> b.resize(2,3)# new_shape parameter doesn’t have to be a tuple >>> b array([[0, 1, 2], [3, 0, 0]]) Referencing an array prevents resizing... >>> c=a >>> a.resize((1,1)) Traceback (most recent call last): ... ValueError: cannot resize an array that has been referenced ... Unless refcheck is False: >>> a.resize((1,1), refcheck=False) >>> a array([[0]]) >>> c array([[0]]) matrix.round(decimals=0, out=None) Return a with each element rounded to the given number of decimals. Refer to numpy.around for full documentation. See Also: numpy.around equivalent function matrix.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 See Also: numpy.searchsorted equivalent function matrix.setfield(val, dtype, offset=0) Put a value into a speciﬁed place in a ﬁeld deﬁned by a data-type. Place val into a‘s ﬁeld deﬁned by dtype and beginning offset bytes into the ﬁeld. Parameters val : object 146 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Value to be placed in ﬁeld. dtype : dtype object Data-type of the ﬁeld in which to place val. offset : int, optional The number of bytes into the ﬁeld at which to place val. Returns None See Also: getfield Examples >>> 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]]) >>> x array([[ 1.00000000e+000, 1.48219694e-323, 1.48219694e-323], [ 1.48219694e-323, 1.00000000e+000, 1.48219694e-323], [ 1.48219694e-323, 1.48219694e-323, 1.00000000e+000]]) >>> x.setfield(np.eye(3), np.int32) >>> x array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]]) matrix.setflags(write=None, align=None, uic=None) Set array ﬂags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. These Boolean-valued ﬂags affect how numpy interprets the memory area used by a (see Notes below). The ALIGNED ﬂag can only be set to True if the data is actually aligned according to the type. The UPDATEIFCOPY ﬂag can never be set to True. The ﬂag 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 write : bool, optional Describes whether or not a can be written to. align : bool, optional Describes whether or not a is aligned properly for its type. uic : bool, optional Describes whether or not a is a copy of another “base” array. 1.6. Standard array subclasses 147 NumPy Reference, Release 1.8.1 Notes Array ﬂags provide information about how the memory area used for the array is to be interpreted. There are 6 Boolean ﬂags in use, only three of which can be changed by the user: UPDATEIFCOPY, WRITE- ABLE, 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 com- piler); UPDATEIFCOPY (U) this array is a copy of some other array (referenced by .base). When this array is deallocated, the base array will be updated with the contents of this array. All ﬂags can be accessed using their ﬁrst (upper case) letter as well as the full name. Examples >>> 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 UPDATEIFCOPY : False >>> y.setflags(write=0, align=0) >>> y.flags C_CONTIGUOUS : True F_CONTIGUOUS : False OWNDATA : True WRITEABLE : False ALIGNED : False UPDATEIFCOPY : False >>> y.setflags(uic=1) Traceback (most recent call last): File "", line1, in ValueError: cannot set UPDATEIFCOPY flag to True matrix.sort(axis=-1, kind=’quicksort’, order=None) Sort an array, in-place. Parameters axis : int, optional Axis along which to sort. Default is -1, which means sort along the last axis. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional Sorting algorithm. Default is ‘quicksort’. order : list, optional When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. See Also: numpy.sort Return a sorted copy of an array. 148 Chapter 1. Array objects NumPy Reference, Release 1.8.1 argsort Indirect sort. lexsort Indirect stable sort on multiple keys. searchsorted Find elements in sorted array. partition Partial sort. Notes See sort for notes on the different sorting algorithms. Examples >>> a= np.array([[1,4], [3,1]]) >>> a.sort(axis=1) >>> a array([[1, 4], [1, 3]]) >>> a.sort(axis=0) >>> a array([[1, 3], [1, 4]]) Use the order keyword to specify a ﬁeld to use when sorting a structured array: >>> a= np.array([(’a’,2), (’c’,1)], dtype=[(’x’,’S1’), (’y’, int)]) >>> a.sort(order=’y’) >>> a array([(’c’, 1), (’a’, 2)], dtype=[(’x’, ’|S1’), (’y’, ’>> x= np.matrix(np.arange(12).reshape((3,4))) >>> x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> x.std() 3.4520525295346629 >>> x.std(0) matrix([[ 3.26598632, 3.26598632, 3.26598632, 3.26598632]]) >>> x.std(1) matrix([[ 1.11803399], [ 1.11803399], [ 1.11803399]]) matrix.sum(axis=None, dtype=None, out=None) Returns the sum of the matrix elements, along the given axis. Refer to numpy.sum for full documentation. See Also: numpy.sum Notes This is the same as ndarray.sum, except that where an ndarray would be returned, a matrix object is returned instead. Examples >>> x= np.matrix([[1,2], [4,3]]) >>> x.sum() 10 >>> x.sum(axis=1) matrix([[3], [7]]) >>> x.sum(axis=1, dtype=’float’) matrix([[ 3.], [ 7.]]) >>> out= np.zeros((1,2), dtype=’float’) >>> x.sum(axis=1, dtype=’float’, out=out) matrix([[ 3.], [ 7.]]) matrix.swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. Refer to numpy.swapaxes for full documentation. See Also: numpy.swapaxes equivalent function matrix.take(indices, axis=None, out=None, mode=’raise’) Return an array formed from the elements of a at the given indices. Refer to numpy.take for full documentation. See Also: 150 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.take equivalent function matrix.tofile(ﬁd, sep=”“, format=”%s”) Write array to a ﬁle as text or binary (default). Data is always written in ‘C’ order, independent of the order of a. The data produced by this method can be recovered using the function fromﬁle(). Parameters ﬁd : ﬁle or str An open ﬁle object, or a string containing a ﬁlename. sep : str Separator between array items for text output. If “” (empty), a binary ﬁle is written, equivalent to file.write(a.tostring()). format : str Format string for text ﬁle output. Each entry in the array is formatted to text by ﬁrst converting it to the closest Python type, and then using “format” % item. Notes This is a convenience function for quick storage of array data. Information on endianness and precision is lost, so this method is not a good choice for ﬁles intended to archive data or transport data between machines with different endianness. Some of these problems can be overcome by outputting the data as text ﬁles, at the expense of speed and ﬁle size. matrix.tolist() Return the matrix as a (possibly nested) list. See ndarray.tolist for full documentation. See Also: ndarray.tolist Examples >>> x= np.matrix(np.arange(12).reshape((3,4))); x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> x.tolist() [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]] matrix.tostring(order=’C’) Construct a Python string containing the raw data bytes in the array. Constructs a Python string showing a copy of the raw contents of data memory. The string can be produced in either ‘C’ or ‘Fortran’, or ‘Any’ order (the default is ‘C’-order). ‘Any’ order means C-order unless the F_CONTIGUOUS ﬂag in the array is set, in which case it means ‘Fortran’ order. Parameters order : {‘C’, ‘F’, None}, optional Order of the data for multidimensional arrays: C, Fortran, or the same as for the original array. 1.6. Standard array subclasses 151 NumPy Reference, Release 1.8.1 Returns s : str A Python string exhibiting a copy of a‘s raw data. Examples >>> x= np.array([[0,1], [2,3]]) >>> x.tostring() ’\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00’ >>> x.tostring(’C’) ==x.tostring() True >>> x.tostring(’F’) ’\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00’ matrix.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. See Also: numpy.trace equivalent function matrix.transpose(*axes) Returns a view of the array with axes transposed. For a 1-D array, this has no effect. (To change between column and row vectors, ﬁrst cast the 1-D ar- ray into a matrix object.) For a 2-D array, this is the usual matrix transpose. For an n-D array, if axes are given, their order indicates how the axes are permuted (see Examples). If axes are not provided and a.shape = (i[0], i[1], ... i[n-2], i[n-1]), then a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0]). 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 a‘s i-th axis becomes a.transpose()‘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 out : ndarray View of a, with axes suitably permuted. See Also: ndarray.T Array property returning the array transposed. Examples >>> a= np.array([[1,2], [3,4]]) >>> a array([[1, 2], [3, 4]]) 152 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> 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]]) matrix.var(axis=None, dtype=None, out=None, ddof=0) Returns the variance of the matrix elements, along the given axis. Refer to numpy.var for full documentation. See Also: numpy.var Notes This is the same as ndarray.var, except that where an ndarray would be returned, a matrix object is returned instead. Examples >>> x= np.matrix(np.arange(12).reshape((3,4))) >>> x matrix([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> x.var() 11.916666666666666 >>> x.var(0) matrix([[ 10.66666667, 10.66666667, 10.66666667, 10.66666667]]) >>> x.var(1) matrix([[ 1.25], [ 1.25], [ 1.25]]) matrix.view(dtype=None, type=None) New view of array with the same data. Parameters dtype : data-type or ndarray sub-class, optional Data-type descriptor of the returned view, e.g., ﬂoat32 or int16. The default, None, results in the view having the same data-type as a. This argument can also be speciﬁed as an ndarray sub-class, which then speciﬁes the type of the returned object (this is equivalent to setting the type parameter). type : Python type, optional Type of the returned view, e.g., ndarray or matrix. Again, the default None results in type preservation. Notes a.view() is used two different ways: 1.6. Standard array subclasses 153 NumPy Reference, Release 1.8.1 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 reinter- pretation of the memory. For a.view(some_dtype), if some_dtype has a different number of bytes per entry than the pre- vious dtype (for example, converting a regular array to a structured array), then the behavior of the view cannot be predicted just from the superﬁcial 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 deﬁned as a slice or transpose, etc., the view may give different results. Examples >>> x= np.array([(1,2)], dtype=[(’a’, np.int8), (’b’, np.int8)]) Viewing array data using a different type and dtype: >>> y=x.view(dtype=np.int16, type=np.matrix) >>> y matrix([[513]], dtype=int16) >>> print type(y) Creating a view on a structured array so it can be used in calculations >>> x= np.array([(1,2),(3,4)], dtype=[(’a’, np.int8), (’b’, np.int8)]) >>> xv=x.view(dtype=np.int8).reshape(-1,2) >>> xv array([[1, 2], [3, 4]], dtype=int8) >>> xv.mean(0) array([ 2., 3.]) Making changes to the view changes the underlying array >>> xv[0,1]= 20 >>> print x [(1, 20) (3, 4)] Using a view to convert an array to a record array: >>> z=x.view(np.recarray) >>> z.a array([1], dtype=int8) Views share data: >>> x[0]=(9, 10) >>> z[0] (9, 10) Views that change the dtype size (bytes per entry) should normally be avoided on arrays deﬁned by slices, transposes, fortran-ordering, etc.: >>> x= np.array([[1,2,3],[4,5,6]], dtype=np.int16) >>> y= x[:,0:2] >>> y array([[1, 2], [4, 5]], dtype=int16) 154 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> y.view(dtype=[(’width’, np.int16), (’length’, np.int16)]) Traceback (most recent call last): File "", line1, in ValueError: new type not compatible with array. >>> z=y.copy() >>> z.view(dtype=[(’width’, np.int16), (’length’, np.int16)]) array([[(1, 2)], [(4, 5)]], dtype=[(’width’, ’>> x= np.array([[1,2], [3,4]]) >>> m= np.asmatrix(x) >>> x[0,0]=5 >>> m matrix([[5, 2], [3, 4]]) numpy.bmat(obj, ldict=None, gdict=None) Build a matrix object from a string, nested sequence, or array. Parameters obj : str or array_like Input data. Names of variables in the current scope may be referenced, even if obj is a string. Returns out : matrix Returns a matrix object, which is a specialized 2-D array. See Also: matrix Examples >>> A= np.mat(’1 1; 1 1’) >>> B= np.mat(’2 2; 2 2’) >>> C= np.mat(’3 4; 5 6’) >>> D= np.mat(’7 8; 9 0’) 1.6. Standard array subclasses 155 NumPy Reference, Release 1.8.1 All the following expressions construct the same block matrix: >>> np.bmat([[A, B], [C, D]]) matrix([[1, 1, 2, 2], [1, 1, 2, 2], [3, 4, 7, 8], [5, 6, 9, 0]]) >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) matrix([[1, 1, 2, 2], [1, 1, 2, 2], [3, 4, 7, 8], [5, 6, 9, 0]]) >>> np.bmat(’A,B; C,D’) matrix([[1, 1, 2, 2], [1, 1, 2, 2], [3, 4, 7, 8], [5, 6, 9, 0]]) Example 1: Matrix creation from a string >>> a=mat(’1 2 3; 4 5 3’) >>> print (a*a.T).I [[ 0.2924 -0.1345] [-0.1345 0.0819]] Example 2: Matrix creation from nested sequence >>> mat([[1,5,10],[1.0,3,4j]]) matrix([[ 1.+0.j, 5.+0.j, 10.+0.j], [ 1.+0.j, 3.+0.j, 0.+4.j]]) Example 3: Matrix creation from an array >>> mat(random.rand(3,3)).T matrix([[ 0.7699, 0.7922, 0.3294], [ 0.2792, 0.0101, 0.9219], [ 0.3398, 0.7571, 0.8197]]) 1.6.3 Memory-mapped ﬁle arrays Memory-mapped ﬁles are useful for reading and/or modifying small segments of a large ﬁle with regular layout, without reading the entire ﬁle into memory. A simple subclass of the ndarray uses a memory-mapped ﬁle for the data buffer of the array. For small ﬁles, the over-head of reading the entire ﬁle into memory is typically not signiﬁcant, however for large ﬁles using memory mapping can save considerable resources. Memory-mapped-ﬁle arrays have one additional method (besides those they inherit from the ndarray): .flush() which must be called manually by the user to ensure that any changes to the array actually get written to disk. Note: Memory-mapped arrays use the the Python memory-map object which (prior to Python 2.5) does not allow ﬁles to be larger than a certain size depending on the platform. This size is always < 2GB even on 64-bit systems. memmap Create a memory-map to an array stored in a binary ﬁle on disk. memmap.flush() Write any changes in the array to the ﬁle on disk. class numpy.memmap Create a memory-map to an array stored in a binary ﬁle on disk. 156 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Memory-mapped ﬁles are used for accessing small segments of large ﬁles on disk, without reading the entire ﬁle into memory. Numpy’s memmap’s are array-like objects. This differs from Python’s mmap module, which uses ﬁle-like objects. This subclass of ndarray has some unpleasant interactions with some operations, because it doesn’t quite ﬁt properly as a subclass. An alternative to using this subclass is to create the mmap object yourself, then create an ndarray with ndarray.__new__ directly, passing the object created in its ‘buffer=’ parameter. This class may at some point be turned into a factory function which returns a view into an mmap buffer. Parameters ﬁlename : str or ﬁle-like object The ﬁle name or ﬁle object to be used as the array data buffer. dtype : data-type, optional The data-type used to interpret the ﬁle contents. Default is uint8. mode : {‘r+’, ‘r’, ‘w+’, ‘c’}, optional The ﬁle is opened in this mode: ‘r’ Open existing ﬁle for reading only. ‘r+’ Open existing ﬁle for reading and writing. ‘w+’ Create or overwrite existing ﬁle for reading and writing. ‘c’ Copy-on-write: assignments affect data in memory, but changes are not saved to disk. The ﬁle on disk is read-only. Default is ‘r+’. offset : int, optional In the ﬁle, array data starts at this offset. Since offset is measured in bytes, it should normally be a multiple of the byte-size of dtype. When mode != ’r’, even posi- tive offsets beyond end of ﬁle are valid; The ﬁle will be extended to accommodate the additional data. The default offset is 0. shape : tuple, optional The desired shape of the array. If mode == ’r’ and the number of remaining bytes after offset is not a multiple of the byte-size of dtype, you must specify shape. By default, the returned array will be 1-D with the number of elements determined by ﬁle size and data-type. order : {‘C’, ‘F’}, optional Specify the order of the ndarray memory layout: C (row-major) or Fortran (column- major). This only has an effect if the shape is greater than 1-D. The default order is ‘C’. Notes The memmap object can be used anywhere an ndarray is accepted. Given a memmap fp, isinstance(fp, numpy.ndarray) returns True. Memory-mapped arrays use the Python memory-map object which (prior to Python 2.5) does not allow ﬁles to be larger than a certain size depending on the platform. This size is always < 2GB even on 64-bit systems. Examples >>> data= np.arange(12, dtype=’float32’) >>> data.resize((3,4)) 1.6. Standard array subclasses 157 NumPy Reference, Release 1.8.1 This example uses a temporary ﬁle so that doctest doesn’t write ﬁles to your directory. You would use a ‘normal’ ﬁlename. >>> from tempfile import mkdtemp >>> import os.path as path >>> filename= path.join(mkdtemp(),’newfile.dat’) Create a memmap with dtype and shape that matches our data: >>> fp= np.memmap(filename, dtype=’float32’, mode=’w+’, shape=(3,4)) >>> fp memmap([[ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.]], dtype=float32) Write data to memmap array: >>> fp[:]= data[:] >>> fp memmap([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]], dtype=float32) >>> fp.filename == path.abspath(filename) True Deletion ﬂushes memory changes to disk before removing the object: >>> del fp Load the memmap and verify data was stored: >>> newfp= np.memmap(filename, dtype=’float32’, mode=’r’, shape=(3,4)) >>> newfp memmap([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]], dtype=float32) Read-only memmap: >>> fpr= np.memmap(filename, dtype=’float32’, mode=’r’, shape=(3,4)) >>> fpr.flags.writeable False Copy-on-write memmap: >>> fpc= np.memmap(filename, dtype=’float32’, mode=’c’, shape=(3,4)) >>> fpc.flags.writeable True It’s possible to assign to copy-on-write array, but values are only written into the memory copy of the array, and not written to disk: >>> fpc memmap([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]], dtype=float32) >>> fpc[0,:]=0 >>> fpc memmap([[ 0., 0., 0., 0.], 158 Chapter 1. Array objects NumPy Reference, Release 1.8.1 [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]], dtype=float32) File on disk is unchanged: >>> fpr memmap([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]], dtype=float32) Offset into a memmap: >>> fpo= np.memmap(filename, dtype=’float32’, mode=’r’, offset=16) >>> fpo memmap([ 4., 5., 6., 7., 8., 9., 10., 11.], dtype=float32) Attributes ﬁlename (str) Path to the mapped ﬁle. offset (int) Offset position in the ﬁle. mode (str) File mode. Methods flush() Write any changes in the array to the ﬁle on disk. memmap.flush() Write any changes in the array to the ﬁle on disk. For further information, see memmap. Parameters None See Also: memmap close Close the memmap ﬁle. memmap.flush() Write any changes in the array to the ﬁle on disk. For further information, see memmap. Parameters None See Also: memmap Example: >>> a= memmap(’newfile.dat’, dtype=float, mode=’w+’, shape=1000) >>> a[10]= 10.0 >>> a[30]= 30.0 >>> del a >>> b= fromfile(’newfile.dat’, dtype=float) >>> print b[10], b[30] 10.0 30.0 1.6. Standard array subclasses 159 NumPy Reference, Release 1.8.1 >>> a= memmap(’newfile.dat’, dtype=float) >>> print a[10], a[30] 10.0 30.0 1.6.4 Character arrays (numpy.char) See Also: Creating character arrays (numpy.char) Note: The chararray class exists for backwards compatibility with Numarray, it is not recommended for new development. Starting from numpy 1.4, if one needs arrays of strings, it is recommended to use arrays of dtype object_, string_ or unicode_, and use the free functions in the numpy.char module for fast vectorized string operations. These are enhanced arrays of either string_ type or unicode_ type. These arrays inherit from the ndarray, but specially-deﬁne the operations +,*, and % on a (broadcasting) element-by-element basis. These operations are not available on the standard ndarray of character type. In addition, the chararray has all of the standard string (and unicode) methods, executing them on an element-by-element basis. Perhaps the easiest way to create a chararray is to use self.view(chararray) where self is an ndarray of str or unicode data-type. However, a chararray can also be created using the numpy.chararray constructor, or via the numpy.char.array function: chararray Provides a convenient view on arrays of string and unicode values. core.defchararray.array(obj[, itemsize, ...]) Create a chararray. class numpy.chararray Provides a convenient view on arrays of string and unicode values. Note: The chararray class exists for backwards compatibility with Numarray, it is not recommended for new development. Starting from numpy 1.4, if one needs arrays of strings, it is recommended to use arrays of dtype object_, string_ or unicode_, and use the free functions in the numpy.char module for fast vectorized string operations. Versus a regular Numpy array of type str or unicode, this class adds the following functionality: 1.values automatically have whitespace removed from the end when indexed 2.comparison operators automatically remove whitespace from the end when comparing values 3.vectorized string operations are provided as methods (e.g. endswith) and inﬁx operators (e.g. "+", "*", "%") chararrays should be created using numpy.char.array or numpy.char.asarray, rather than this con- structor directly. This constructor creates the array, using buffer (with offset and strides) if it is not None. If buffer is None, then constructs a new array with strides in “C order”, unless both len(shape) >= 2 and order=’Fortran’, in which case strides is in “Fortran order”. Parameters shape : tuple Shape of the array. itemsize : int, optional 160 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Length of each array element, in number of characters. Default is 1. unicode : bool, optional Are the array elements of type unicode (True) or string (False). Default is False. buffer : int, optional Memory address of the start of the array data. Default is None, in which case a new array is created. offset : int, optional Fixed stride displacement from the beginning of an axis? Default is 0. Needs to be >=0. strides : array_like of ints, optional Strides for the array (see ndarray.strides for full description). Default is None. order : {‘C’, ‘F’}, optional The order in which the array data is stored in memory: ‘C’ -> “row major” order (the default), ‘F’ -> “column major” (Fortran) order. Examples >>> charar= np.chararray((3,3)) >>> charar[:]=’a’ >>> charar chararray([[’a’, ’a’, ’a’], [’a’, ’a’, ’a’], [’a’, ’a’, ’a’]], dtype=’|S1’) >>> charar= np.chararray(charar.shape, itemsize=5) >>> charar[:]=’abc’ >>> charar chararray([[’abc’, ’abc’, ’abc’], [’abc’, ’abc’, ’abc’], [’abc’, ’abc’, ’abc’]], dtype=’|S5’) Attributes T Same as self.transpose(), except that self is returned if self.ndim < 2. base Base object if memory is from some other object. ctypes An object to simplify the interaction of the array with the ctypes module. data Python buffer object pointing to the start of the array’s data. dtype Data-type of the array’s elements. flags Information about the memory layout of the array. flat A 1-D iterator over the array. imag The imaginary part of the array. itemsize Length of one array element in bytes. nbytes Total bytes consumed by the elements of the array. ndim Number of array dimensions. real The real part of the array. shape Tuple of array dimensions. size Number of elements in the array. strides Tuple of bytes to step in each dimension when traversing an array. 1.6. Standard array subclasses 161 NumPy Reference, Release 1.8.1 chararray.T Same as self.transpose(), except that self is returned if self.ndim < 2. Examples >>> x= np.array([[1.,2.],[3.,4.]]) >>> x array([[ 1., 2.], [ 3., 4.]]) >>> x.T array([[ 1., 3.], [ 2., 4.]]) >>> x= np.array([1.,2.,3.,4.]) >>> x array([ 1., 2., 3., 4.]) >>> x.T array([ 1., 2., 3., 4.]) chararray.base Base object if memory is from some other object. Examples The base of an array that owns its memory is None: >>> 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 chararray.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 c : Python object Possessing attributes data, shape, strides, etc. See Also: numpy.ctypeslib 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): •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 ﬂags and data-type of this array should be respected when passing this attribute to arbitrary 162 Chapter 1. Array objects NumPy Reference, Release 1.8.1 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]. •shape (c_intp*self.ndim): A ctypes array of length self.ndim where the basetype is the C-integer corresponding to dtype(‘p’) on this platform. This base-type could be c_int, c_long, or c_longlong depending on the platform. The c_intp type is deﬁned accordingly in numpy.ctypeslib. The ctypes array contains the shape of the underlying array. •strides (c_intp*self.ndim): 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. •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 ﬂoating-point data: self.data_as(ctypes.POINTER(ctypes.c_double)). •shape_as(obj): Return the shape tuple as an array of some other c-types type. For example: self.shape_as(ctypes.c_short). •strides_as(obj): Return the strides tuple as an array of some other c-types type. For example: self.strides_as(ctypes.c_longlong). Be careful using the ctypes attribute - especially on temporary arrays or arrays constructed on the ﬂy. For example, calling (a+b).ctypes.data_as(ctypes.c_void_p) returns a pointer to memory that is invalid because the array created as (a+b) is deallocated before the next Python statement. You can avoid this problem using either c=a+b or ct=(a+b).ctypes. In the latter case, ct will hold a reference to the array until ct is deleted or re-assigned. 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 ctypes >>> x array([[0, 1], [2, 3]]) >>> x.ctypes.data 30439712 >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents c_long(0) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents c_longlong(4294967296L) >>> x.ctypes.shape >>> x.ctypes.shape_as(ctypes.c_long) >>> x.ctypes.strides >>> x.ctypes.strides_as(ctypes.c_longlong) chararray.data Python buffer object pointing to the start of the array’s data. 1.6. Standard array subclasses 163 NumPy Reference, Release 1.8.1 chararray.dtype Data-type of the array’s elements. Parameters None Returns d : numpy dtype object See Also: numpy.dtype Examples >>> x array([[0, 1], [2, 3]]) >>> x.dtype dtype(’int32’) >>> type(x.dtype) chararray.flags Information about the memory layout of the array. Notes The flags object can be accessed dictionary-like (as in a.flags[’WRITEABLE’]), or by using low- ercased attribute names (as in a.flags.writeable). Short ﬂag names are only supported in dictionary access. Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED ﬂags can be changed by the user, via direct assignment to the attribute or dictionary entry, or by calling ndarray.setflags. The array ﬂags cannot be set arbitrarily: •UPDATEIFCOPY 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 arbi- trary 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. 164 Chapter 1. Array objects NumPy Reference, Release 1.8.1 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. OWN- DATA (O) The array owns the memory it uses or borrows it from another object. WRITE- ABLE (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. UP- DATEIF- COPY (U) This array is a copy of some other array. When this array is deallocated, 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. chararray.flat A 1-D iterator over the array. This is a numpy.flatiter instance, which acts similarly to, but is not a subclass of, Python’s built-in iterator object. See Also: flatten Return a copy of the array collapsed into one dimension. flatiter Examples >>> x= np.arange(1,7).reshape(2,3) >>> x array([[1, 2, 3], [4, 5, 6]]) >>> x.flat[3] 4 >>> x.T array([[1, 4], [2, 5], [3, 6]]) 1.6. Standard array subclasses 165 NumPy Reference, Release 1.8.1 >>> x.T.flat[3] 5 >>> type(x.flat) An assignment example: >>> x.flat=3; x array([[3, 3, 3], [3, 3, 3]]) >>> x.flat[[1,4]]=1; x array([[3, 1, 3], [3, 1, 3]]) chararray.imag The imaginary part of the array. Examples >>> x= np.sqrt([1+0j,0+1j]) >>> x.imag array([ 0. , 0.70710678]) >>> x.imag.dtype dtype(’float64’) chararray.itemsize Length of one array element in bytes. Examples >>> x= np.array([1,2,3], dtype=np.float64) >>> x.itemsize 8 >>> x= np.array([1,2,3], dtype=np.complex128) >>> x.itemsize 16 chararray.nbytes Total bytes consumed by the elements of the array. Notes Does not include memory consumed by non-element attributes of the array object. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.nbytes 480 >>> np.prod(x.shape) * x.itemsize 480 chararray.ndim Number of array dimensions. Examples >>> x= np.array([1,2,3]) >>> x.ndim 1 166 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> y= np.zeros((2,3,4)) >>> y.ndim 3 chararray.real The real part of the array. See Also: numpy.real equivalent function Examples >>> x= np.sqrt([1+0j,0+1j]) >>> x.real array([ 1. , 0.70710678]) >>> x.real.dtype dtype(’float64’) chararray.shape Tuple of array dimensions. Notes May be used to “reshape” the array, as long as this would not require a change in the total number of elements Examples >>> x= np.array([1,2,3,4]) >>> x.shape (4,) >>> y= np.zeros((2,3,4)) >>> y.shape (2, 3, 4) >>> y.shape=(3,8) >>> y array([[ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.]]) >>> y.shape=(3,6) Traceback (most recent call last): File "", line1, in ValueError: total size of new array must be unchanged chararray.size Number of elements in the array. Equivalent to np.prod(a.shape), i.e., the product of the array’s dimensions. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.size 30 >>> np.prod(x.shape) 30 1.6. Standard array subclasses 167 NumPy Reference, Release 1.8.1 chararray.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 “ndarray.rst” ﬁle in the NumPy reference guide. See Also: numpy.lib.stride_tricks.as_strided 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 >>> y= np.reshape(np.arange(2 *3*4), (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]]]) >>> y.strides (48, 16, 4) >>> y[1,1,1] 17 >>> offset=sum(y.strides * np.array((1,1,1))) >>> offset/y.itemsize 17 >>> x= np.reshape(np.arange(5 *6*7*8), (5,6,7,8)).transpose(2,3,1,0) >>> x.strides (32, 4, 224, 1344) >>> i= np.array([3,5,2,2]) >>> offset= sum(i * x.strides) >>> x[3,5,2,2] 813 >>> offset/x.itemsize 813 Methods astype(dtype[, order, casting, subok, copy]) Copy of the array, cast to a speciﬁed type. copy([order]) Return a copy of the array. Continued on next page 168 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Table 1.45 – continued from previous page count(sub[, start, end]) Returns an array with the number of non-overlapping occurrences of substring sub in the range [start, end]. decode([encoding, errors]) Calls str.decode element-wise. dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. dumps() Returns the pickle of the array as a string. encode([encoding, errors]) Calls str.encode element-wise. endswith(sufﬁx[, start, end]) Returns a boolean array which is True where the string element expandtabs([tabsize]) Return a copy of each string element where all tab characters are replaced by one or more spaces. fill(value) Fill the array with a scalar value. find(sub[, start, end]) For each element, return the lowest index in the string where substring sub is found. flatten([order]) Return a copy of the array collapsed into one dimension. getfield(dtype[, offset]) Returns a ﬁeld of the given array as a certain type. index(sub[, start, end]) Like find, but raises ValueError when the substring is not found. isalnum() Returns true for each element if all characters in the string are alphanumeric and there is at least one character, false otherwise. isalpha() Returns true for each element if all characters in the string are alphabetic and there is at least one character, false otherwise. isdecimal() For each element in self, return True if there are only isdigit() Returns true for each element if all characters in the string are digits and there is at least one character, false otherwise. islower() Returns true for each element if all cased characters in the string are lowercase and there is at least one cased character, false otherwise. isnumeric() For each element in self, return True if there are only isspace() Returns true for each element if there are only whitespace characters in the string and there is at least one character, false otherwise. istitle() Returns true for each element if the element is a titlecased string and there is at least one character, false otherwise. isupper() Returns true for each element if all cased characters in the string are uppercase and there is at least one character, false otherwise. item(*args) Copy an element of an array to a standard Python scalar and return it. join(seq) Return a string which is the concatenation of the strings in the sequence seq. ljust(width[, ﬁllchar]) Return an array with the elements of self left-justiﬁed in a string of length width. lower() Return an array with the elements of self converted to lowercase. lstrip([chars]) For each element in self, return a copy with the leading characters removed. nonzero() Return the indices of the elements that are non-zero. put(indices, values[, mode]) Set a.flat[n] = values[n] for all n in indices. ravel([order]) Return a ﬂattened array. repeat(repeats[, axis]) Repeat elements of an array. replace(old, new[, count]) For each element in self, return a copy of the string with all occurrences of substring old replaced by new. reshape(shape[, order]) Returns an array containing the same data with a new shape. resize(new_shape[, refcheck]) Change shape and size of array in-place. rfind(sub[, start, end]) For each element in self, return the highest index in the string where substring sub is found, such that sub is contained within [start, end]. rindex(sub[, start, end]) Like rfind, but raises ValueError when the substring sub is rjust(width[, ﬁllchar]) Return an array with the elements of self right-justiﬁed in a string of length width. rsplit([sep, maxsplit]) For each element in self, return a list of the words in the string, using sep as the delimiter string. rstrip([chars]) For each element in self, return a copy with the trailing characters removed. searchsorted(v[, side, sorter]) Find indices where elements of v should be inserted in a to maintain order. setfield(val, dtype[, offset]) Put a value into a speciﬁed place in a ﬁeld deﬁned by a data-type. setflags([write, align, uic]) Set array ﬂags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. sort([axis, kind, order]) Sort an array, in-place. split([sep, maxsplit]) For each element in self, return a list of the words in the string, using sep as the delimiter string. splitlines([keepends]) For each element in self, return a list of the lines in the element, breaking at line boundaries. squeeze([axis]) Remove single-dimensional entries from the shape of a. startswith(preﬁx[, start, end]) Returns a boolean array which is True where the string element strip([chars]) For each element in self, return a copy with the leading and trailing characters removed. swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. swapcase() For each element in self, return a copy of the string with uppercase characters converted to lowercase and vice versa. take(indices[, axis, out, mode]) Return an array formed from the elements of a at the given indices. Continued on next page 1.6. Standard array subclasses 169 NumPy Reference, Release 1.8.1 Table 1.45 – continued from previous page title() For each element in self, return a titlecased version of the string: words start with uppercase characters, all remaining cased characters are lowercase. tofile(ﬁd[, sep, format]) Write array to a ﬁle as text or binary (default). tolist() Return the array as a (possibly nested) list. tostring([order]) Construct a Python string containing the raw data bytes in the array. translate(table[, deletechars]) For each element in self, return a copy of the string where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table. transpose(*axes) Returns a view of the array with axes transposed. upper() Return an array with the elements of self converted to uppercase. view([dtype, type]) New view of array with the same data. zfill(width) Return the numeric string left-ﬁlled with zeros in a string of length width. chararray.astype(dtype, order=’K’, casting=’unsafe’, subok=True, copy=True) Copy of the array, cast to a speciﬁed type. Parameters dtype : str 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 com- patibility. • ‘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 ﬂoat64 to ﬂoat32, are allowed. • ‘unsafe’ means any data conversions may be done. subok : bool, optional If True, then sub-classes will be passed-through (default), otherwise the returned array will be forced to be a base-class array. copy : bool, optional By default, astype always returns a newly allocated array. If this is set to false, and the dtype, order, and subok requirements are satisﬁed, the input array is returned instead of a copy. Returns arr_t : ndarray Unless copy is False and the other conditions for returning the input array are satisﬁed (see description for copy input paramter), arr_t is a new array of the same shape as the input array, with dtype, order given by dtype, order. Raises ComplexWarning 170 Chapter 1. Array objects NumPy Reference, Release 1.8.1 When casting from complex to ﬂoat or int. To avoid this, one should use a.real.astype(t). Examples >>> x= np.array([1,2, 2.5]) >>> x array([ 1. , 2. , 2.5]) >>> x.astype(int) array([1, 2, 2]) chararray.copy(order=’C’) Return a copy of the array. 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 :func:numpy.copy are very similar, but have different default values for their order= arguments.) See Also: numpy.copy, numpy.copyto Examples >>> 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 chararray.count(sub, start=0, end=None) Returns an array with the number of non-overlapping occurrences of substring sub in the range [start, end]. See Also: char.count chararray.decode(encoding=None, errors=None) Calls str.decode element-wise. See Also: char.decode 1.6. Standard array subclasses 171 NumPy Reference, Release 1.8.1 chararray.dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. The array can be read back with pickle.load or numpy.load. Parameters ﬁle : str A string naming the dump ﬁle. chararray.dumps() Returns the pickle of the array as a string. pickle.loads or numpy.loads will convert the string back to an array. Parameters None chararray.encode(encoding=None, errors=None) Calls str.encode element-wise. See Also: char.encode chararray.endswith(sufﬁx, start=0, end=None) Returns a boolean array which is True where the string element in self ends with sufﬁx, otherwise False. See Also: char.endswith chararray.expandtabs(tabsize=8) Return a copy of each string element where all tab characters are replaced by one or more spaces. See Also: char.expandtabs chararray.fill(value) Fill the array with a scalar value. Parameters value : scalar All elements of a will be assigned this value. Examples >>> a= np.array([1,2]) >>> a.fill(0) >>> a array([0, 0]) >>> a= np.empty(2) >>> a.fill(1) >>> a array([ 1., 1.]) chararray.find(sub, start=0, end=None) For each element, return the lowest index in the string where substring sub is found. See Also: char.find chararray.flatten(order=’C’) Return a copy of the array collapsed into one dimension. 172 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Parameters order : {‘C’, ‘F’, ‘A’}, optional Whether to ﬂatten in C (row-major), Fortran (column-major) order, or preserve the C/Fortran ordering from a. The default is ‘C’. Returns y : ndarray A copy of the input array, ﬂattened to one dimension. See Also: ravel Return a ﬂattened array. flat A 1-D ﬂat iterator over the array. Examples >>> a= np.array([[1,2], [3,4]]) >>> a.flatten() array([1, 2, 3, 4]) >>> a.flatten(’F’) array([1, 3, 2, 4]) chararray.getfield(dtype, offset=0) Returns a ﬁeld of the given array as a certain type. A ﬁeld 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 ﬁts 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 dtype : str or dtype The data type of the view. The dtype size of the view can not be larger than that of the array itself. offset : int Number of bytes to skip before beginning the element view. Examples >>> 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.]]) 1.6. Standard array subclasses 173 NumPy Reference, Release 1.8.1 chararray.index(sub, start=0, end=None) Like find, but raises ValueError when the substring is not found. See Also: char.index chararray.isalnum() Returns true for each element if all characters in the string are alphanumeric and there is at least one character, false otherwise. See Also: char.isalnum chararray.isalpha() Returns true for each element if all characters in the string are alphabetic and there is at least one character, false otherwise. See Also: char.isalpha chararray.isdecimal() For each element in self, return True if there are only decimal characters in the element. See Also: char.isdecimal chararray.isdigit() Returns true for each element if all characters in the string are digits and there is at least one character, false otherwise. See Also: char.isdigit chararray.islower() Returns true for each element if all cased characters in the string are lowercase and there is at least one cased character, false otherwise. See Also: char.islower chararray.isnumeric() For each element in self, return True if there are only numeric characters in the element. See Also: char.isnumeric chararray.isspace() Returns true for each element if there are only whitespace characters in the string and there is at least one character, false otherwise. See Also: char.isspace chararray.istitle() Returns true for each element if the element is a titlecased string and there is at least one character, false otherwise. See Also: 174 Chapter 1. Array objects NumPy Reference, Release 1.8.1 char.istitle chararray.isupper() Returns true for each element if all cased characters in the string are uppercase and there is at least one character, false otherwise. See Also: char.isupper chararray.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 ﬂat index into the array, specifying which ele- ment 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 z : Standard Python scalar object A copy of the speciﬁed 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 ﬁelds are deﬁned, 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 >>> x= np.random.randint(9, size=(3,3)) >>> x array([[3, 1, 7], [2, 8, 3], [8, 5, 3]]) >>> x.item(3) 2 >>> x.item(7) 5 >>> x.item((0,1)) 1 >>> x.item((2,2)) 3 chararray.join(seq) Return a string which is the concatenation of the strings in the sequence seq. See Also: char.join 1.6. Standard array subclasses 175 NumPy Reference, Release 1.8.1 chararray.ljust(width, ﬁllchar=’ ‘) Return an array with the elements of self left-justiﬁed in a string of length width. See Also: char.ljust chararray.lower() Return an array with the elements of self converted to lowercase. See Also: char.lower chararray.lstrip(chars=None) For each element in self, return a copy with the leading characters removed. See Also: char.lstrip chararray.nonzero() Return the indices of the elements that are non-zero. Refer to numpy.nonzero for full documentation. See Also: numpy.nonzero equivalent function chararray.put(indices, values, mode=’raise’) Set a.flat[n] = values[n] for all n in indices. Refer to numpy.put for full documentation. See Also: numpy.put equivalent function chararray.ravel([order ]) Return a ﬂattened array. Refer to numpy.ravel for full documentation. See Also: numpy.ravel equivalent function ndarray.flat a ﬂat iterator on the array. chararray.repeat(repeats, axis=None) Repeat elements of an array. Refer to numpy.repeat for full documentation. See Also: numpy.repeat equivalent function 176 Chapter 1. Array objects NumPy Reference, Release 1.8.1 chararray.replace(old, new, count=None) For each element in self, return a copy of the string with all occurrences of substring old replaced by new. See Also: char.replace chararray.reshape(shape, order=’C’) Returns an array containing the same data with a new shape. Refer to numpy.reshape for full documentation. See Also: numpy.reshape equivalent function chararray.resize(new_shape, refcheck=True) Change shape and size of array in-place. Parameters new_shape : tuple of ints, or n ints Shape of resized array. refcheck : bool, optional If False, reference count will not be checked. Default is True. Returns None Raises ValueError If a does not own its own data or references or views to it exist, and the data memory must be changed. SystemError If the order keyword argument is speciﬁed. This behaviour is a bug in NumPy. See Also: resize Return a new array with the speciﬁed shape. Notes This reallocates space for the data area if necessary. Only contiguous arrays (data elements consecutive in memory) can be resized. The purpose of the reference count check is to make sure you do not use this array as a buffer for another Python object and then reallocate the memory. However, reference counts can increase in other ways so if you are sure that you have not shared the memory for this array with another Python object, then you may safely set refcheck to False. Examples Shrinking an array: array is ﬂattened (in the order that the data are stored in memory), resized, and re- shaped: 1.6. Standard array subclasses 177 NumPy Reference, Release 1.8.1 >>> a= np.array([[0,1], [2,3]], order=’C’) >>> a.resize((2,1)) >>> a array([[0], [1]]) >>> a= np.array([[0,1], [2,3]], order=’F’) >>> a.resize((2,1)) >>> a array([[0], [2]]) Enlarging an array: as above, but missing entries are ﬁlled with zeros: >>> b= np.array([[0,1], [2,3]]) >>> b.resize(2,3)# new_shape parameter doesn’t have to be a tuple >>> b array([[0, 1, 2], [3, 0, 0]]) Referencing an array prevents resizing... >>> c=a >>> a.resize((1,1)) Traceback (most recent call last): ... ValueError: cannot resize an array that has been referenced ... Unless refcheck is False: >>> a.resize((1,1), refcheck=False) >>> a array([[0]]) >>> c array([[0]]) chararray.rfind(sub, start=0, end=None) For each element in self, return the highest index in the string where substring sub is found, such that sub is contained within [start, end]. See Also: char.rfind chararray.rindex(sub, start=0, end=None) Like rfind, but raises ValueError when the substring sub is not found. See Also: char.rindex chararray.rjust(width, ﬁllchar=’ ‘) Return an array with the elements of self right-justiﬁed in a string of length width. See Also: char.rjust chararray.rsplit(sep=None, maxsplit=None) For each element in self, return a list of the words in the string, using sep as the delimiter string. See Also: 178 Chapter 1. Array objects NumPy Reference, Release 1.8.1 char.rsplit chararray.rstrip(chars=None) For each element in self, return a copy with the trailing characters removed. See Also: char.rstrip chararray.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 See Also: numpy.searchsorted equivalent function chararray.setfield(val, dtype, offset=0) Put a value into a speciﬁed place in a ﬁeld deﬁned by a data-type. Place val into a‘s ﬁeld deﬁned by dtype and beginning offset bytes into the ﬁeld. Parameters val : object Value to be placed in ﬁeld. dtype : dtype object Data-type of the ﬁeld in which to place val. offset : int, optional The number of bytes into the ﬁeld at which to place val. Returns None See Also: getfield Examples >>> 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]]) >>> x array([[ 1.00000000e+000, 1.48219694e-323, 1.48219694e-323], [ 1.48219694e-323, 1.00000000e+000, 1.48219694e-323], [ 1.48219694e-323, 1.48219694e-323, 1.00000000e+000]]) >>> x.setfield(np.eye(3), np.int32) >>> x array([[ 1., 0., 0.], 1.6. Standard array subclasses 179 NumPy Reference, Release 1.8.1 [ 0., 1., 0.], [ 0., 0., 1.]]) chararray.setflags(write=None, align=None, uic=None) Set array ﬂags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. These Boolean-valued ﬂags affect how numpy interprets the memory area used by a (see Notes below). The ALIGNED ﬂag can only be set to True if the data is actually aligned according to the type. The UPDATEIFCOPY ﬂag can never be set to True. The ﬂag 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 write : bool, optional Describes whether or not a can be written to. align : bool, optional Describes whether or not a is aligned properly for its type. uic : bool, optional Describes whether or not a is a copy of another “base” array. Notes Array ﬂags provide information about how the memory area used for the array is to be interpreted. There are 6 Boolean ﬂags in use, only three of which can be changed by the user: UPDATEIFCOPY, WRITE- ABLE, 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 com- piler); UPDATEIFCOPY (U) this array is a copy of some other array (referenced by .base). When this array is deallocated, the base array will be updated with the contents of this array. All ﬂags can be accessed using their ﬁrst (upper case) letter as well as the full name. Examples >>> 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 UPDATEIFCOPY : False >>> y.setflags(write=0, align=0) >>> y.flags C_CONTIGUOUS : True F_CONTIGUOUS : False OWNDATA : True WRITEABLE : False ALIGNED : False UPDATEIFCOPY : False 180 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> y.setflags(uic=1) Traceback (most recent call last): File "", line1, in ValueError: cannot set UPDATEIFCOPY flag to True chararray.sort(axis=-1, kind=’quicksort’, order=None) Sort an array, in-place. Parameters axis : int, optional Axis along which to sort. Default is -1, which means sort along the last axis. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional Sorting algorithm. Default is ‘quicksort’. order : list, optional When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. See Also: numpy.sort Return a sorted copy of an array. argsort Indirect sort. lexsort Indirect stable sort on multiple keys. searchsorted Find elements in sorted array. partition Partial sort. Notes See sort for notes on the different sorting algorithms. Examples >>> a= np.array([[1,4], [3,1]]) >>> a.sort(axis=1) >>> a array([[1, 4], [1, 3]]) >>> a.sort(axis=0) >>> a array([[1, 3], [1, 4]]) Use the order keyword to specify a ﬁeld to use when sorting a structured array: >>> a= np.array([(’a’,2), (’c’,1)], dtype=[(’x’,’S1’), (’y’, int)]) >>> a.sort(order=’y’) >>> a array([(’c’, 1), (’a’, 2)], dtype=[(’x’, ’|S1’), (’y’, ’>> a= np.array([1,2]) >>> a.tolist() [1, 2] >>> a= np.array([[1,2], [3,4]]) 1.6. Standard array subclasses 183 NumPy Reference, Release 1.8.1 >>> list(a) [array([1, 2]), array([3, 4])] >>> a.tolist() [[1, 2], [3, 4]] chararray.tostring(order=’C’) Construct a Python string containing the raw data bytes in the array. Constructs a Python string showing a copy of the raw contents of data memory. The string can be produced in either ‘C’ or ‘Fortran’, or ‘Any’ order (the default is ‘C’-order). ‘Any’ order means C-order unless the F_CONTIGUOUS ﬂag in the array is set, in which case it means ‘Fortran’ order. Parameters order : {‘C’, ‘F’, None}, optional Order of the data for multidimensional arrays: C, Fortran, or the same as for the original array. Returns s : str A Python string exhibiting a copy of a‘s raw data. Examples >>> x= np.array([[0,1], [2,3]]) >>> x.tostring() ’\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00’ >>> x.tostring(’C’) ==x.tostring() True >>> x.tostring(’F’) ’\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00’ chararray.translate(table, deletechars=None) For each element in self, return a copy of the string where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table. See Also: char.translate chararray.transpose(*axes) Returns a view of the array with axes transposed. For a 1-D array, this has no effect. (To change between column and row vectors, ﬁrst cast the 1-D ar- ray into a matrix object.) For a 2-D array, this is the usual matrix transpose. For an n-D array, if axes are given, their order indicates how the axes are permuted (see Examples). If axes are not provided and a.shape = (i[0], i[1], ... i[n-2], i[n-1]), then a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0]). 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 a‘s i-th axis becomes a.transpose()‘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) 184 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Returns out : ndarray View of a, with axes suitably permuted. See Also: ndarray.T Array property returning the array transposed. Examples >>> 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]]) chararray.upper() Return an array with the elements of self converted to uppercase. See Also: char.upper chararray.view(dtype=None, type=None) New view of array with the same data. Parameters dtype : data-type or ndarray sub-class, optional Data-type descriptor of the returned view, e.g., ﬂoat32 or int16. The default, None, results in the view having the same data-type as a. This argument can also be speciﬁed as an ndarray sub-class, which then speciﬁes the type of the returned object (this is equivalent to setting the type parameter). type : Python type, optional Type of the returned view, e.g., ndarray or matrix. Again, the default None results in type preservation. 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 reinter- pretation of the memory. For a.view(some_dtype), if some_dtype has a different number of bytes per entry than the pre- vious dtype (for example, converting a regular array to a structured array), then the behavior of the view 1.6. Standard array subclasses 185 NumPy Reference, Release 1.8.1 cannot be predicted just from the superﬁcial 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 deﬁned as a slice or transpose, etc., the view may give different results. Examples >>> x= np.array([(1,2)], dtype=[(’a’, np.int8), (’b’, np.int8)]) Viewing array data using a different type and dtype: >>> y=x.view(dtype=np.int16, type=np.matrix) >>> y matrix([[513]], dtype=int16) >>> print type(y) Creating a view on a structured array so it can be used in calculations >>> x= np.array([(1,2),(3,4)], dtype=[(’a’, np.int8), (’b’, np.int8)]) >>> xv=x.view(dtype=np.int8).reshape(-1,2) >>> xv array([[1, 2], [3, 4]], dtype=int8) >>> xv.mean(0) array([ 2., 3.]) Making changes to the view changes the underlying array >>> xv[0,1]= 20 >>> print x [(1, 20) (3, 4)] Using a view to convert an array to a record array: >>> z=x.view(np.recarray) >>> z.a array([1], dtype=int8) Views share data: >>> x[0]=(9, 10) >>> z[0] (9, 10) Views that change the dtype size (bytes per entry) should normally be avoided on arrays deﬁned by slices, transposes, fortran-ordering, etc.: >>> x= np.array([[1,2,3],[4,5,6]], dtype=np.int16) >>> y= x[:,0:2] >>> y array([[1, 2], [4, 5]], dtype=int16) >>> y.view(dtype=[(’width’, np.int16), (’length’, np.int16)]) Traceback (most recent call last): File "", line1, in ValueError: new type not compatible with array. >>> z=y.copy() >>> z.view(dtype=[(’width’, np.int16), (’length’, np.int16)]) array([[(1, 2)], [(4, 5)]], dtype=[(’width’, ’’, ‘=’}, optional Byte-order for all ﬁelds. aligned : bool, optional Align the ﬁelds in memory as the C-compiler would. strides : tuple of ints, optional Buffer (buf) is interpreted according to these strides (strides deﬁne how many bytes each array element, row, column, etc. occupy in memory). offset : int, optional Start reading buffer (buf) from this offset onwards. order : {‘C’, ‘F’}, optional Row-major or column-major order. See Also: rec.fromrecords Construct a record array from data. record fundamental data-type for recarray. format_parser determine a data-type from formats, names, titles. Notes This constructor can be compared to empty: it creates a new record array but does not ﬁll it with data. To create a record array from data, use one of the following methods: 1.Create a standard ndarray and convert it to a record array, using arr.view(np.recarray) 2.Use the buf keyword. 3.Use np.rec.fromrecords. Examples Create an array with two ﬁelds, x and y: >>> x= np.array([(1.0,2), (3.0,4)], dtype=[(’x’, float), (’y’, int)]) >>> x array([(1.0, 2), (3.0, 4)], dtype=[(’x’, ’>> x[’x’] array([ 1., 3.]) View the array as a record array: >>> x=x.view(np.recarray) 1.6. Standard array subclasses 189 NumPy Reference, Release 1.8.1 >>> x.x array([ 1., 3.]) >>> x.y array([2, 4]) Create a new, empty record array: >>> np.recarray((2,), ... dtype=[(’x’, int), (’y’, float), (’z’, int)]) rec.array([(-1073741821, 1.2249118382103472e-301, 24547520), (3471280, 1.2134086255804012e-316, 0)], dtype=[(’x’, ’>> x= np.array([[1.,2.],[3.,4.]]) >>> x array([[ 1., 2.], [ 3., 4.]]) >>> x.T array([[ 1., 3.], [ 2., 4.]]) >>> x= np.array([1.,2.,3.,4.]) >>> x array([ 1., 2., 3., 4.]) >>> x.T array([ 1., 2., 3., 4.]) recarray.base Base object if memory is from some other object. Examples The base of an array that owns its memory is None: 190 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> 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 recarray.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 c : Python object Possessing attributes data, shape, strides, etc. See Also: numpy.ctypeslib 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): •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 ﬂags 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]. •shape (c_intp*self.ndim): A ctypes array of length self.ndim where the basetype is the C-integer corresponding to dtype(‘p’) on this platform. This base-type could be c_int, c_long, or c_longlong depending on the platform. The c_intp type is deﬁned accordingly in numpy.ctypeslib. The ctypes array contains the shape of the underlying array. •strides (c_intp*self.ndim): 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. •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 ﬂoating-point data: self.data_as(ctypes.POINTER(ctypes.c_double)). •shape_as(obj): Return the shape tuple as an array of some other c-types type. For example: self.shape_as(ctypes.c_short). •strides_as(obj): Return the strides tuple as an array of some other c-types type. For example: self.strides_as(ctypes.c_longlong). Be careful using the ctypes attribute - especially on temporary arrays or arrays constructed on the ﬂy. For example, calling (a+b).ctypes.data_as(ctypes.c_void_p) returns a pointer to memory that 1.6. Standard array subclasses 191 NumPy Reference, Release 1.8.1 is invalid because the array created as (a+b) is deallocated before the next Python statement. You can avoid this problem using either c=a+b or ct=(a+b).ctypes. In the latter case, ct will hold a reference to the array until ct is deleted or re-assigned. 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 ctypes >>> x array([[0, 1], [2, 3]]) >>> x.ctypes.data 30439712 >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents c_long(0) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents c_longlong(4294967296L) >>> x.ctypes.shape >>> x.ctypes.shape_as(ctypes.c_long) >>> x.ctypes.strides >>> x.ctypes.strides_as(ctypes.c_longlong) recarray.data Python buffer object pointing to the start of the array’s data. recarray.dtype Data-type of the array’s elements. Parameters None Returns d : numpy dtype object See Also: numpy.dtype Examples >>> x array([[0, 1], [2, 3]]) >>> x.dtype dtype(’int32’) >>> type(x.dtype) recarray.flags Information about the memory layout of the array. 192 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Notes The flags object can be accessed dictionary-like (as in a.flags[’WRITEABLE’]), or by using low- ercased attribute names (as in a.flags.writeable). Short ﬂag names are only supported in dictionary access. Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED ﬂags can be changed by the user, via direct assignment to the attribute or dictionary entry, or by calling ndarray.setflags. The array ﬂags cannot be set arbitrarily: •UPDATEIFCOPY 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 arbi- trary 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. 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. OWN- DATA (O) The array owns the memory it uses or borrows it from another object. WRITE- ABLE (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. UP- DATEIF- COPY (U) This array is a copy of some other array. When this array is deallocated, 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. 1.6. Standard array subclasses 193 NumPy Reference, Release 1.8.1 recarray.flat A 1-D iterator over the array. This is a numpy.flatiter instance, which acts similarly to, but is not a subclass of, Python’s built-in iterator object. See Also: flatten Return a copy of the array collapsed into one dimension. flatiter Examples >>> x= np.arange(1,7).reshape(2,3) >>> x array([[1, 2, 3], [4, 5, 6]]) >>> x.flat[3] 4 >>> x.T array([[1, 4], [2, 5], [3, 6]]) >>> x.T.flat[3] 5 >>> type(x.flat) An assignment example: >>> x.flat=3; x array([[3, 3, 3], [3, 3, 3]]) >>> x.flat[[1,4]]=1; x array([[3, 1, 3], [3, 1, 3]]) recarray.imag The imaginary part of the array. Examples >>> x= np.sqrt([1+0j,0+1j]) >>> x.imag array([ 0. , 0.70710678]) >>> x.imag.dtype dtype(’float64’) recarray.itemsize Length of one array element in bytes. Examples >>> x= np.array([1,2,3], dtype=np.float64) >>> x.itemsize 8 >>> x= np.array([1,2,3], dtype=np.complex128) 194 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> x.itemsize 16 recarray.nbytes Total bytes consumed by the elements of the array. Notes Does not include memory consumed by non-element attributes of the array object. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.nbytes 480 >>> np.prod(x.shape) * x.itemsize 480 recarray.ndim Number of array dimensions. Examples >>> x= np.array([1,2,3]) >>> x.ndim 1 >>> y= np.zeros((2,3,4)) >>> y.ndim 3 recarray.real The real part of the array. See Also: numpy.real equivalent function Examples >>> x= np.sqrt([1+0j,0+1j]) >>> x.real array([ 1. , 0.70710678]) >>> x.real.dtype dtype(’float64’) recarray.shape Tuple of array dimensions. Notes May be used to “reshape” the array, as long as this would not require a change in the total number of elements Examples >>> x= np.array([1,2,3,4]) >>> x.shape (4,) >>> y= np.zeros((2,3,4)) 1.6. Standard array subclasses 195 NumPy Reference, Release 1.8.1 >>> y.shape (2, 3, 4) >>> y.shape=(3,8) >>> y array([[ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.]]) >>> y.shape=(3,6) Traceback (most recent call last): File "", line1, in ValueError: total size of new array must be unchanged recarray.size Number of elements in the array. Equivalent to np.prod(a.shape), i.e., the product of the array’s dimensions. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.size 30 >>> np.prod(x.shape) 30 recarray.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 “ndarray.rst” ﬁle in the NumPy reference guide. See Also: numpy.lib.stride_tricks.as_strided 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 >>> y= np.reshape(np.arange(2 *3*4), (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]]]) 196 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> y.strides (48, 16, 4) >>> y[1,1,1] 17 >>> offset=sum(y.strides * np.array((1,1,1))) >>> offset/y.itemsize 17 >>> x= np.reshape(np.arange(5 *6*7*8), (5,6,7,8)).transpose(2,3,1,0) >>> x.strides (32, 4, 224, 1344) >>> i= np.array([3,5,2,2]) >>> offset= sum(i * x.strides) >>> x[3,5,2,2] 813 >>> offset/x.itemsize 813 Methods all([axis, out]) Returns True if all elements evaluate to True. any([axis, out]) Returns True if any of the elements of a evaluate to True. argmax([axis, out]) Return indices of the maximum values along the given axis. argmin([axis, out]) Return indices of the minimum values along the given axis of a. argpartition(kth[, axis, kind, order]) Returns the indices that would partition this array. argsort([axis, kind, order]) Returns the indices that would sort this array. astype(dtype[, order, casting, subok, copy]) Copy of the array, cast to a speciﬁed 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(a_min, a_max[, out]) Return an array whose values are limited to [a_min, a_max]. compress(condition[, axis, out]) Return selected slices of this array along given axis. conj() Complex-conjugate all elements. conjugate() Return the complex conjugate, element-wise. copy([order]) Return a copy of the array. cumprod([axis, dtype, out]) Return the cumulative product of the elements along the given axis. cumsum([axis, dtype, out]) Return the cumulative sum of the elements along the given axis. diagonal([offset, axis1, axis2]) Return speciﬁed diagonals. dot(b[, out]) Dot product of two arrays. dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. dumps() Returns the pickle of the array as a string. field(attr[, val]) fill(value) Fill the array with a scalar value. flatten([order]) Return a copy of the array collapsed into one dimension. getfield(dtype[, offset]) Returns a ﬁeld of the given array as a certain type. item(*args) Copy an element of an array to a standard Python scalar and return it. itemset(*args) Insert scalar into an array (scalar is cast to array’s dtype, if possible) max([axis, out]) Return the maximum along a given axis. mean([axis, dtype, out]) Returns the average of the array elements along given axis. min([axis, out]) Return the minimum along a given axis. newbyteorder([new_order]) Return the array with the same data viewed with a different byte order. nonzero() Return the indices of the elements that are non-zero. partition(kth[, axis, kind, order]) Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. prod([axis, dtype, out]) Return the product of the array elements over the given axis Continued on next page 1.6. Standard array subclasses 197 NumPy Reference, Release 1.8.1 Table 1.48 – continued from previous page ptp([axis, out]) Peak to peak (maximum - minimum) value along a given axis. put(indices, values[, mode]) Set a.flat[n] = values[n] for all n in indices. ravel([order]) Return a ﬂattened array. repeat(repeats[, axis]) Repeat elements of an array. reshape(shape[, order]) Returns an array containing the same data with a new shape. resize(new_shape[, refcheck]) Change shape and size of array in-place. round([decimals, out]) Return a with 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. setfield(val, dtype[, offset]) Put a value into a speciﬁed place in a ﬁeld deﬁned by a data-type. setflags([write, align, uic]) Set array ﬂags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. sort([axis, kind, order]) Sort an array, in-place. squeeze([axis]) Remove single-dimensional entries from the shape of a. std([axis, dtype, out, ddof]) Returns the standard deviation of the array elements along given axis. sum([axis, dtype, out]) Return the sum of the array elements over the given axis. swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. take(indices[, axis, out, mode]) Return an array formed from the elements of a at the given indices. tofile(ﬁd[, sep, format]) Write array to a ﬁle as text or binary (default). tolist() Return the array as a (possibly nested) list. tostring([order]) Construct a Python string containing the raw data bytes in the 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. var([axis, dtype, out, ddof]) Returns the variance of the array elements, along given axis. view([dtype, type]) recarray.all(axis=None, out=None) Returns True if all elements evaluate to True. Refer to numpy.all for full documentation. See Also: numpy.all equivalent function recarray.any(axis=None, out=None) Returns True if any of the elements of a evaluate to True. Refer to numpy.any for full documentation. See Also: numpy.any equivalent function recarray.argmax(axis=None, out=None) Return indices of the maximum values along the given axis. Refer to numpy.argmax for full documentation. See Also: numpy.argmax equivalent function 198 Chapter 1. Array objects NumPy Reference, Release 1.8.1 recarray.argmin(axis=None, out=None) Return indices of the minimum values along the given axis of a. Refer to numpy.argmin for detailed documentation. See Also: numpy.argmin equivalent function recarray.argpartition(kth, axis=-1, kind=’introselect’, order=None) Returns the indices that would partition this array. Refer to numpy.argpartition for full documentation. New in version 1.8.0. See Also: numpy.argpartition equivalent function recarray.argsort(axis=-1, kind=’quicksort’, order=None) Returns the indices that would sort this array. Refer to numpy.argsort for full documentation. See Also: numpy.argsort equivalent function recarray.astype(dtype, order=’K’, casting=’unsafe’, subok=True, copy=True) Copy of the array, cast to a speciﬁed type. Parameters dtype : str 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 com- patibility. • ‘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 ﬂoat64 to ﬂoat32, are allowed. • ‘unsafe’ means any data conversions may be done. subok : bool, optional 1.6. Standard array subclasses 199 NumPy Reference, Release 1.8.1 If True, then sub-classes will be passed-through (default), otherwise the returned array will be forced to be a base-class array. copy : bool, optional By default, astype always returns a newly allocated array. If this is set to false, and the dtype, order, and subok requirements are satisﬁed, the input array is returned instead of a copy. Returns arr_t : ndarray Unless copy is False and the other conditions for returning the input array are satisﬁed (see description for copy input paramter), 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 ﬂoat or int. To avoid this, one should use a.real.astype(t). Examples >>> x= np.array([1,2, 2.5]) >>> x array([ 1. , 2. , 2.5]) >>> x.astype(int) array([1, 2, 2]) recarray.byteswap(inplace) Swap the bytes of the array elements Toggle between low-endian and big-endian data representation by returning a byteswapped array, option- ally swapped in-place. Parameters inplace : bool, optional If True, swap bytes in-place, default is False. Returns out : ndarray The byteswapped array. If inplace is True, this is a view to self. Examples >>> A= np.array([1, 256, 8755], dtype=np.int16) >>> map(hex, A) [’0x1’, ’0x100’, ’0x2233’] >>> A.byteswap(True) array([ 256, 1, 13090], dtype=int16) >>> map(hex, A) [’0x100’, ’0x1’, ’0x3322’] Arrays of strings are not swapped >>> A= np.array([’ceg’,’fac’]) >>> A.byteswap() 200 Chapter 1. Array objects NumPy Reference, Release 1.8.1 array([’ceg’, ’fac’], dtype=’|S3’) recarray.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. See Also: numpy.choose equivalent function recarray.clip(a_min, a_max, out=None) Return an array whose values are limited to [a_min, a_max]. Refer to numpy.clip for full documentation. See Also: numpy.clip equivalent function recarray.compress(condition, axis=None, out=None) Return selected slices of this array along given axis. Refer to numpy.compress for full documentation. See Also: numpy.compress equivalent function recarray.conj() Complex-conjugate all elements. Refer to numpy.conjugate for full documentation. See Also: numpy.conjugate equivalent function recarray.conjugate() Return the complex conjugate, element-wise. Refer to numpy.conjugate for full documentation. See Also: numpy.conjugate equivalent function recarray.copy(order=’C’) Return a copy of the array. Parameters order : {‘C’, ‘F’, ‘A’, ‘K’}, optional 1.6. Standard array subclasses 201 NumPy Reference, Release 1.8.1 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 :func:numpy.copy are very similar, but have different default values for their order= arguments.) See Also: numpy.copy, numpy.copyto Examples >>> 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 recarray.cumprod(axis=None, dtype=None, out=None) Return the cumulative product of the elements along the given axis. Refer to numpy.cumprod for full documentation. See Also: numpy.cumprod equivalent function recarray.cumsum(axis=None, dtype=None, out=None) Return the cumulative sum of the elements along the given axis. Refer to numpy.cumsum for full documentation. See Also: numpy.cumsum equivalent function recarray.diagonal(offset=0, axis1=0, axis2=1) Return speciﬁed diagonals. Refer to numpy.diagonal for full documentation. See Also: numpy.diagonal equivalent function 202 Chapter 1. Array objects NumPy Reference, Release 1.8.1 recarray.dot(b, out=None) Dot product of two arrays. Refer to numpy.dot for full documentation. See Also: numpy.dot equivalent function Examples >>> a= np.eye(2) >>> b= np.ones((2,2)) * 2 >>> a.dot(b) array([[ 2., 2.], [ 2., 2.]]) This array method can be conveniently chained: >>> a.dot(b).dot(b) array([[ 8., 8.], [ 8., 8.]]) recarray.dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. The array can be read back with pickle.load or numpy.load. Parameters ﬁle : str A string naming the dump ﬁle. recarray.dumps() Returns the pickle of the array as a string. pickle.loads or numpy.loads will convert the string back to an array. Parameters None recarray.field(attr, val=None) recarray.fill(value) Fill the array with a scalar value. Parameters value : scalar All elements of a will be assigned this value. Examples >>> a= np.array([1,2]) >>> a.fill(0) >>> a array([0, 0]) >>> a= np.empty(2) >>> a.fill(1) >>> a array([ 1., 1.]) 1.6. Standard array subclasses 203 NumPy Reference, Release 1.8.1 recarray.flatten(order=’C’) Return a copy of the array collapsed into one dimension. Parameters order : {‘C’, ‘F’, ‘A’}, optional Whether to ﬂatten in C (row-major), Fortran (column-major) order, or preserve the C/Fortran ordering from a. The default is ‘C’. Returns y : ndarray A copy of the input array, ﬂattened to one dimension. See Also: ravel Return a ﬂattened array. flat A 1-D ﬂat iterator over the array. Examples >>> a= np.array([[1,2], [3,4]]) >>> a.flatten() array([1, 2, 3, 4]) >>> a.flatten(’F’) array([1, 3, 2, 4]) recarray.getfield(dtype, offset=0) Returns a ﬁeld of the given array as a certain type. A ﬁeld 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 ﬁts 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 dtype : str or dtype The data type of the view. The dtype size of the view can not be larger than that of the array itself. offset : int Number of bytes to skip before beginning the element view. Examples >>> 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: 204 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> x.getfield(np.float64, offset=8) array([[ 1., 0.], [ 0., 4.]]) recarray.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 ﬂat index into the array, specifying which ele- ment 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 z : Standard Python scalar object A copy of the speciﬁed 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 ﬁelds are deﬁned, 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 >>> x= np.random.randint(9, size=(3,3)) >>> x array([[3, 1, 7], [2, 8, 3], [8, 5, 3]]) >>> x.item(3) 2 >>> x.item(7) 5 >>> x.item((0,1)) 1 >>> x.item((2,2)) 3 recarray.itemset(*args) Insert scalar into an array (scalar is cast to array’s dtype, if possible) There must be at least 1 argument, and deﬁne the last argument as item. Then, a.itemset(*args) is equivalent to but faster than a[args] = item. The item should be a scalar value and args must select a single item in the array a. Parameters *args : Arguments 1.6. Standard array subclasses 205 NumPy Reference, Release 1.8.1 If one argument: a scalar, only used in case a is of size 1. If two arguments: the last argument is the value to be set and must be a scalar, the ﬁrst argument speciﬁes a single array element location. It is either an int or a tuple. Notes Compared to indexing syntax, itemset provides some speed increase for placing a scalar into a particular location in an ndarray, if you must do this. However, generally this is discouraged: among other problems, it complicates the appearance of the code. Also, when using itemset (and item) inside a loop, be sure to assign the methods to a local variable to avoid the attribute look-up at each loop iteration. Examples >>> x= np.random.randint(9, size=(3,3)) >>> x array([[3, 1, 7], [2, 8, 3], [8, 5, 3]]) >>> x.itemset(4,0) >>> x.itemset((2,2),9) >>> x array([[3, 1, 7], [2, 0, 3], [8, 5, 9]]) recarray.max(axis=None, out=None) Return the maximum along a given axis. Refer to numpy.amax for full documentation. See Also: numpy.amax equivalent function recarray.mean(axis=None, dtype=None, out=None) Returns the average of the array elements along given axis. Refer to numpy.mean for full documentation. See Also: numpy.mean equivalent function recarray.min(axis=None, out=None) Return the minimum along a given axis. Refer to numpy.amin for full documentation. See Also: numpy.amin equivalent function recarray.newbyteorder(new_order=’S’) Return the array with the same data viewed with a different byte order. Equivalent to: 206 Chapter 1. Array objects NumPy Reference, Release 1.8.1 arr.view(arr.dtype.newbytorder(new_order)) Changes are also made in all ﬁelds and sub-arrays of the array data type. Parameters new_order : string, optional Byte order to force; a value from the byte order speciﬁcations above. new_order codes can be any of: *’S’ - swap dtype from current to opposite endian *{’<’, ’L’} - little endian *{’>’, ’B’} - big endian *{’=’, ’N’} - native order *{’|’, ’I’} - ignore (no change to byte order) The default value (‘S’) results in swapping the current byte order. The code does a case-insensitive check on the ﬁrst letter of new_order for the alternatives above. For example, any of ‘B’ or ‘b’ or ‘biggish’ are valid to specify big-endian. Returns new_arr : array New array object with the dtype reﬂecting given change to the byte order. recarray.nonzero() Return the indices of the elements that are non-zero. Refer to numpy.nonzero for full documentation. See Also: numpy.nonzero equivalent function recarray.partition(kth, axis=-1, kind=’introselect’, order=None) Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. All elements smaller than the kth element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undeﬁned. New in version 1.8.0. Parameters kth : int or sequence of ints Element index to partition by. The kth element value will be in its ﬁnal sorted position and all smaller elements will be moved before it and all equal or greater elements behind it. The order all elements in the partitions is undeﬁned. If provided with a sequence of kth it will partition all elements indexed by kth of them into their sorted position at once. axis : int, optional Axis along which to sort. Default is -1, which means sort along the last axis. kind : {‘introselect’}, optional Selection algorithm. Default is ‘introselect’. order : list, optional When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. 1.6. Standard array subclasses 207 NumPy Reference, Release 1.8.1 See Also: numpy.partition Return a parititioned copy of an array. argpartition Indirect partition. sort Full sort. Notes See np.partition for notes on the different algorithms. Examples >>> a= np.array([3,4,2,1]) >>> a.partition(a,3) >>> a array([2, 1, 3, 4]) >>> a.partition((1,3)) array([1, 2, 3, 4]) recarray.prod(axis=None, dtype=None, out=None) Return the product of the array elements over the given axis Refer to numpy.prod for full documentation. See Also: numpy.prod equivalent function recarray.ptp(axis=None, out=None) Peak to peak (maximum - minimum) value along a given axis. Refer to numpy.ptp for full documentation. See Also: numpy.ptp equivalent function recarray.put(indices, values, mode=’raise’) Set a.flat[n] = values[n] for all n in indices. Refer to numpy.put for full documentation. See Also: numpy.put equivalent function recarray.ravel([order ]) Return a ﬂattened array. Refer to numpy.ravel for full documentation. See Also: 208 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.ravel equivalent function ndarray.flat a ﬂat iterator on the array. recarray.repeat(repeats, axis=None) Repeat elements of an array. Refer to numpy.repeat for full documentation. See Also: numpy.repeat equivalent function recarray.reshape(shape, order=’C’) Returns an array containing the same data with a new shape. Refer to numpy.reshape for full documentation. See Also: numpy.reshape equivalent function recarray.resize(new_shape, refcheck=True) Change shape and size of array in-place. Parameters new_shape : tuple of ints, or n ints Shape of resized array. refcheck : bool, optional If False, reference count will not be checked. Default is True. Returns None Raises ValueError If a does not own its own data or references or views to it exist, and the data memory must be changed. SystemError If the order keyword argument is speciﬁed. This behaviour is a bug in NumPy. See Also: resize Return a new array with the speciﬁed shape. Notes This reallocates space for the data area if necessary. Only contiguous arrays (data elements consecutive in memory) can be resized. 1.6. Standard array subclasses 209 NumPy Reference, Release 1.8.1 The purpose of the reference count check is to make sure you do not use this array as a buffer for another Python object and then reallocate the memory. However, reference counts can increase in other ways so if you are sure that you have not shared the memory for this array with another Python object, then you may safely set refcheck to False. Examples Shrinking an array: array is ﬂattened (in the order that the data are stored in memory), resized, and re- shaped: >>> a= np.array([[0,1], [2,3]], order=’C’) >>> a.resize((2,1)) >>> a array([[0], [1]]) >>> a= np.array([[0,1], [2,3]], order=’F’) >>> a.resize((2,1)) >>> a array([[0], [2]]) Enlarging an array: as above, but missing entries are ﬁlled with zeros: >>> b= np.array([[0,1], [2,3]]) >>> b.resize(2,3)# new_shape parameter doesn’t have to be a tuple >>> b array([[0, 1, 2], [3, 0, 0]]) Referencing an array prevents resizing... >>> c=a >>> a.resize((1,1)) Traceback (most recent call last): ... ValueError: cannot resize an array that has been referenced ... Unless refcheck is False: >>> a.resize((1,1), refcheck=False) >>> a array([[0]]) >>> c array([[0]]) recarray.round(decimals=0, out=None) Return a with each element rounded to the given number of decimals. Refer to numpy.around for full documentation. See Also: numpy.around equivalent function recarray.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 210 Chapter 1. Array objects NumPy Reference, Release 1.8.1 See Also: numpy.searchsorted equivalent function recarray.setfield(val, dtype, offset=0) Put a value into a speciﬁed place in a ﬁeld deﬁned by a data-type. Place val into a‘s ﬁeld deﬁned by dtype and beginning offset bytes into the ﬁeld. Parameters val : object Value to be placed in ﬁeld. dtype : dtype object Data-type of the ﬁeld in which to place val. offset : int, optional The number of bytes into the ﬁeld at which to place val. Returns None See Also: getfield Examples >>> 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]]) >>> x array([[ 1.00000000e+000, 1.48219694e-323, 1.48219694e-323], [ 1.48219694e-323, 1.00000000e+000, 1.48219694e-323], [ 1.48219694e-323, 1.48219694e-323, 1.00000000e+000]]) >>> x.setfield(np.eye(3), np.int32) >>> x array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]]) recarray.setflags(write=None, align=None, uic=None) Set array ﬂags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. These Boolean-valued ﬂags affect how numpy interprets the memory area used by a (see Notes below). The ALIGNED ﬂag can only be set to True if the data is actually aligned according to the type. The UPDATEIFCOPY ﬂag can never be set to True. The ﬂag 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.) 1.6. Standard array subclasses 211 NumPy Reference, Release 1.8.1 Parameters write : bool, optional Describes whether or not a can be written to. align : bool, optional Describes whether or not a is aligned properly for its type. uic : bool, optional Describes whether or not a is a copy of another “base” array. Notes Array ﬂags provide information about how the memory area used for the array is to be interpreted. There are 6 Boolean ﬂags in use, only three of which can be changed by the user: UPDATEIFCOPY, WRITE- ABLE, 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 com- piler); UPDATEIFCOPY (U) this array is a copy of some other array (referenced by .base). When this array is deallocated, the base array will be updated with the contents of this array. All ﬂags can be accessed using their ﬁrst (upper case) letter as well as the full name. Examples >>> 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 UPDATEIFCOPY : False >>> y.setflags(write=0, align=0) >>> y.flags C_CONTIGUOUS : True F_CONTIGUOUS : False OWNDATA : True WRITEABLE : False ALIGNED : False UPDATEIFCOPY : False >>> y.setflags(uic=1) Traceback (most recent call last): File "", line1, in ValueError: cannot set UPDATEIFCOPY flag to True recarray.sort(axis=-1, kind=’quicksort’, order=None) Sort an array, in-place. Parameters axis : int, optional Axis along which to sort. Default is -1, which means sort along the last axis. 212 Chapter 1. Array objects NumPy Reference, Release 1.8.1 kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional Sorting algorithm. Default is ‘quicksort’. order : list, optional When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. See Also: numpy.sort Return a sorted copy of an array. argsort Indirect sort. lexsort Indirect stable sort on multiple keys. searchsorted Find elements in sorted array. partition Partial sort. Notes See sort for notes on the different sorting algorithms. Examples >>> a= np.array([[1,4], [3,1]]) >>> a.sort(axis=1) >>> a array([[1, 4], [1, 3]]) >>> a.sort(axis=0) >>> a array([[1, 3], [1, 4]]) Use the order keyword to specify a ﬁeld to use when sorting a structured array: >>> a= np.array([(’a’,2), (’c’,1)], dtype=[(’x’,’S1’), (’y’, int)]) >>> a.sort(order=’y’) >>> a array([(’c’, 1), (’a’, 2)], dtype=[(’x’, ’|S1’), (’y’, ’>> a= np.array([1,2]) >>> a.tolist() [1, 2] >>> a= np.array([[1,2], [3,4]]) >>> list(a) [array([1, 2]), array([3, 4])] >>> a.tolist() [[1, 2], [3, 4]] recarray.tostring(order=’C’) Construct a Python string containing the raw data bytes in the array. Constructs a Python string showing a copy of the raw contents of data memory. The string can be produced in either ‘C’ or ‘Fortran’, or ‘Any’ order (the default is ‘C’-order). ‘Any’ order means C-order unless the F_CONTIGUOUS ﬂag in the array is set, in which case it means ‘Fortran’ order. Parameters order : {‘C’, ‘F’, None}, optional Order of the data for multidimensional arrays: C, Fortran, or the same as for the original array. Returns s : str A Python string exhibiting a copy of a‘s raw data. Examples >>> x= np.array([[0,1], [2,3]]) >>> x.tostring() ’\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00’ >>> x.tostring(’C’) ==x.tostring() True 1.6. Standard array subclasses 215 NumPy Reference, Release 1.8.1 >>> x.tostring(’F’) ’\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00’ recarray.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. See Also: numpy.trace equivalent function recarray.transpose(*axes) Returns a view of the array with axes transposed. For a 1-D array, this has no effect. (To change between column and row vectors, ﬁrst cast the 1-D ar- ray into a matrix object.) For a 2-D array, this is the usual matrix transpose. For an n-D array, if axes are given, their order indicates how the axes are permuted (see Examples). If axes are not provided and a.shape = (i[0], i[1], ... i[n-2], i[n-1]), then a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0]). 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 a‘s i-th axis becomes a.transpose()‘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 out : ndarray View of a, with axes suitably permuted. See Also: ndarray.T Array property returning the array transposed. Examples >>> 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]]) 216 Chapter 1. Array objects NumPy Reference, Release 1.8.1 recarray.var(axis=None, dtype=None, out=None, ddof=0) Returns the variance of the array elements, along given axis. Refer to numpy.var for full documentation. See Also: numpy.var equivalent function recarray.view(dtype=None, type=None) class numpy.record A data-type scalar that allows ﬁeld access as attribute lookup. Attributes T transpose base base object data pointer to start of data dtype dtype object flags integer value of ﬂags flat a 1-d view of scalar imag imaginary part of scalar itemsize length of one element in bytes nbytes length of item in bytes ndim number of array dimensions real real part of scalar shape tuple of array dimensions size number of elements in the gentype strides tuple of bytes steps in each dimension record.T transpose record.base base object record.data pointer to start of data record.dtype dtype object record.flags integer value of ﬂags record.flat a 1-d view of scalar record.imag imaginary part of scalar record.itemsize length of one element in bytes 1.6. Standard array subclasses 217 NumPy Reference, Release 1.8.1 record.nbytes length of item in bytes record.ndim number of array dimensions record.real real part of scalar record.shape tuple of array dimensions record.size number of elements in the gentype record.strides tuple of bytes steps in each dimension Methods all Not implemented (virtual attribute) any Not implemented (virtual attribute) argmax Not implemented (virtual attribute) argmin Not implemented (virtual attribute) argsort Not implemented (virtual attribute) astype Not implemented (virtual attribute) byteswap Not implemented (virtual attribute) choose Not implemented (virtual attribute) clip Not implemented (virtual attribute) compress Not implemented (virtual attribute) conj conjugate Not implemented (virtual attribute) copy Not implemented (virtual attribute) cumprod Not implemented (virtual attribute) cumsum Not implemented (virtual attribute) diagonal Not implemented (virtual attribute) dump Not implemented (virtual attribute) dumps Not implemented (virtual attribute) fill Not implemented (virtual attribute) flatten Not implemented (virtual attribute) getfield item Not implemented (virtual attribute) itemset Not implemented (virtual attribute) max Not implemented (virtual attribute) mean Not implemented (virtual attribute) min Not implemented (virtual attribute) newbyteorder([new_order]) Return a new dtype with a different byte order. nonzero Not implemented (virtual attribute) pprint() Pretty-print all ﬁelds. prod Not implemented (virtual attribute) ptp Not implemented (virtual attribute) put Not implemented (virtual attribute) ravel Not implemented (virtual attribute) repeat Not implemented (virtual attribute) Continued on next page 218 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Table 1.50 – continued from previous page reshape Not implemented (virtual attribute) resize Not implemented (virtual attribute) round Not implemented (virtual attribute) searchsorted Not implemented (virtual attribute) setfield setflags Not implemented (virtual attribute) sort Not implemented (virtual attribute) squeeze Not implemented (virtual attribute) std Not implemented (virtual attribute) sum Not implemented (virtual attribute) swapaxes Not implemented (virtual attribute) take Not implemented (virtual attribute) tofile Not implemented (virtual attribute) tolist Not implemented (virtual attribute) tostring Not implemented (virtual attribute) trace Not implemented (virtual attribute) transpose Not implemented (virtual attribute) var Not implemented (virtual attribute) view Not implemented (virtual attribute) record.all() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.any() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.argmax() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.argmin() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The 1.6. Standard array subclasses 219 NumPy Reference, Release 1.8.1 record.argsort() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.astype() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.byteswap() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.choose() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.clip() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.compress() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.conj() record.conjugate() Not implemented (virtual attribute) 220 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.copy() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.cumprod() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.cumsum() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.diagonal() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.dump() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.dumps() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The 1.6. Standard array subclasses 221 NumPy Reference, Release 1.8.1 record.fill() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.flatten() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.getfield() record.item() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.itemset() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.max() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.mean() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.min() Not implemented (virtual attribute) 222 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.newbyteorder(new_order=’S’) Return a new dtype with a different byte order. Changes are also made in all ﬁelds and sub-arrays of the data type. The new_order code can be any from the following: •{‘<’, ‘L’} - little endian •{‘>’, ‘B’} - big endian •{‘=’, ‘N’} - native order •‘S’ - swap dtype from current to opposite endian •{‘|’, ‘I’} - ignore (no change to byte order) Parameters new_order : str, optional Byte order to force; a value from the byte order speciﬁcations above. The default value (‘S’) results in swapping the current byte order. The code does a case-insensitive check on the ﬁrst letter of new_order for the alternatives above. For example, any of ‘B’ or ‘b’ or ‘biggish’ are valid to specify big-endian. Returns new_dtype : dtype New dtype object with the given change to the byte order. record.nonzero() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.pprint() Pretty-print all ﬁelds. record.prod() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.ptp() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. 1.6. Standard array subclasses 223 NumPy Reference, Release 1.8.1 See Also: The record.put() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.ravel() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.repeat() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.reshape() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.resize() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.round() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.searchsorted() Not implemented (virtual attribute) 224 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.setfield() record.setflags() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.sort() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.squeeze() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.std() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.sum() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.swapaxes() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: 1.6. Standard array subclasses 225 NumPy Reference, Release 1.8.1 The record.take() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.tofile() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.tolist() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.tostring() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.trace() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.transpose() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The record.var() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. 226 Chapter 1. Array objects NumPy Reference, Release 1.8.1 See Also: The record.view() Not implemented (virtual attribute) Class generic exists solely to derive numpy scalars from, and possesses, albeit unimplemented, all the attributes of the ndarray class so as to provide a uniform API. See Also: The 1.6.6 Masked arrays (numpy.ma) See Also: Masked arrays 1.6.7 Standard container class For backward compatibility and as a standard “container “class, the UserArray from Numeric has been brought over to NumPy and named numpy.lib.user_array.container The container class is a Python class whose self.array attribute is an ndarray. Multiple inheritance is probably easier with numpy.lib.user_array.container than with the ndarray itself and so it is included by default. It is not documented here beyond mentioning its existence because you are encouraged to use the ndarray class directly if you can. numpy.lib.user_array.container(data[, ...]) class numpy.lib.user_array.container(data, dtype=None, copy=True) Methods astype(typecode) byteswap() copy() tostring() container.astype(typecode) container.byteswap() container.copy() container.tostring() 1.6. Standard array subclasses 227 NumPy Reference, Release 1.8.1 1.6.8 Array Iterators Iterators are a powerful concept for array processing. Essentially, iterators implement a generalized for-loop. If myiter is an iterator object, then the Python code: for val in myiter: ... some code involving val ... calls val = myiter.next() repeatedly until StopIteration is raised by the iterator. There are several ways to iterate over an array that may be useful: default iteration, ﬂat iteration, and N-dimensional enumeration. Default iteration The default iterator of an ndarray object is the default Python iterator of a sequence type. Thus, when the array object itself is used as an iterator. The default behavior is equivalent to: for i in range(arr.shape[0]): val= arr[i] This default iterator selects a sub-array of dimension N − 1 from the array. This can be a useful construct for deﬁning recursive algorithms. To loop over the entire array requires N for-loops. >>> a= arange(24).reshape(3,2,4)+10 >>> for val in a: ... print ’item:’, val item: [[10 11 12 13] [14 15 16 17]] item: [[18 19 20 21] [22 23 24 25]] item: [[26 27 28 29] [30 31 32 33]] Flat iteration ndarray.flat A 1-D iterator over the array. ndarray.flat A 1-D iterator over the array. This is a numpy.flatiter instance, which acts similarly to, but is not a subclass of, Python’s built-in iterator object. See Also: flatten Return a copy of the array collapsed into one dimension. flatiter Examples >>> x= np.arange(1,7).reshape(2,3) >>> x 228 Chapter 1. Array objects NumPy Reference, Release 1.8.1 array([[1, 2, 3], [4, 5, 6]]) >>> x.flat[3] 4 >>> x.T array([[1, 4], [2, 5], [3, 6]]) >>> x.T.flat[3] 5 >>> type(x.flat) An assignment example: >>> x.flat=3; x array([[3, 3, 3], [3, 3, 3]]) >>> x.flat[[1,4]]=1; x array([[3, 1, 3], [3, 1, 3]]) As mentioned previously, the ﬂat attribute of ndarray objects returns an iterator that will cycle over the entire array in C-style contiguous order. >>> for i, val in enumerate(a.flat): ... if i%5 ==0: print i, val 0 10 5 15 10 20 15 25 20 30 Here, I’ve used the built-in enumerate iterator to return the iterator index as well as the value. N-dimensional enumeration ndenumerate(arr) Multidimensional index iterator. class numpy.ndenumerate(arr) Multidimensional index iterator. Return an iterator yielding pairs of array coordinates and values. Parameters a : ndarray Input array. See Also: ndindex, flatiter Examples >>> a= np.array([[1,2], [3,4]]) >>> for index, x in np.ndenumerate(a): ... print index, x 1.6. Standard array subclasses 229 NumPy Reference, Release 1.8.1 (0, 0) 1 (0, 1) 2 (1, 0) 3 (1, 1) 4 Methods next() Standard iterator method, returns the index tuple and array value. ndenumerate.next() Standard iterator method, returns the index tuple and array value. Returns coords : tuple of ints The indices of the current iteration. val : scalar The array element of the current iteration. Sometimes it may be useful to get the N-dimensional index while iterating. The ndenumerate iterator can achieve this. >>> for i, val in ndenumerate(a): ... if sum(i)%5 ==0: print i, val (0, 0, 0) 10 (1, 1, 3) 25 (2, 0, 3) 29 (2, 1, 2) 32 Iterator for broadcasting broadcast Produce an object that mimics broadcasting. class numpy.broadcast Produce an object that mimics broadcasting. Parameters in1, in2, ... : array_like Input parameters. Returns b : broadcast object Broadcast the input parameters against one another, and return an object that encapsu- lates the result. Amongst others, it has shape and nd properties, and may be used as an iterator. Examples Manually adding two vectors, using broadcasting: >>> x= np.array([[1], [2], [3]]) >>> y= np.array([4,5,6]) >>> b= np.broadcast(x, y) 230 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> out= np.empty(b.shape) >>> out.flat= [u+v for (u,v) in b] >>> out array([[ 5., 6., 7.], [ 6., 7., 8.], [ 7., 8., 9.]]) Compare against built-in broadcasting: >>> x+y array([[5, 6, 7], [6, 7, 8], [7, 8, 9]]) Attributes index current index in broadcasted result iters tuple of iterators along self‘s “components.” shape Shape of broadcasted result. size Total size of broadcasted result. broadcast.index current index in broadcasted result Examples >>> x= np.array([[1], [2], [3]]) >>> y= np.array([4,5,6]) >>> b= np.broadcast(x, y) >>> b.index 0 >>> b.next(), b.next(), b.next() ((1, 4), (1, 5), (1, 6)) >>> b.index 3 broadcast.iters tuple of iterators along self‘s “components.” Returns a tuple of numpy.flatiter objects, one for each “component” of self. See Also: numpy.flatiter Examples >>> x= np.array([1,2,3]) >>> y= np.array([[4], [5], [6]]) >>> b= np.broadcast(x, y) >>> row, col=b.iters >>> row.next(), col.next() (1, 4) broadcast.shape Shape of broadcasted result. 1.6. Standard array subclasses 231 NumPy Reference, Release 1.8.1 Examples >>> x= np.array([1,2,3]) >>> y= np.array([[4], [5], [6]]) >>> b= np.broadcast(x, y) >>> b.shape (3, 3) broadcast.size Total size of broadcasted result. Examples >>> x= np.array([1,2,3]) >>> y= np.array([[4], [5], [6]]) >>> b= np.broadcast(x, y) >>> b.size 9 Methods next x.next() -> the next value, or raise StopIteration reset() Reset the broadcasted result’s iterator(s). broadcast.next x.next() -> the next value, or raise StopIteration broadcast.reset() Reset the broadcasted result’s iterator(s). Parameters None Returns None Examples >>> x= np.array([1,2,3]) >>> y= np.array([[4], [5], [6]] >>> b= np.broadcast(x, y) >>> b.index 0 >>> b.next(), b.next(), b.next() ((1, 4), (2, 4), (3, 4)) >>> b.index 3 >>> b.reset() >>> b.index 0 The general concept of broadcasting is also available from Python using the broadcast iterator. This object takes N objects as inputs and returns an iterator that returns tuples providing each of the input sequence elements in the broadcasted result. >>> for val in broadcast([[1,0],[2,3]],[0,1]): ... print val (1, 0) (0, 1) 232 Chapter 1. Array objects NumPy Reference, Release 1.8.1 (2, 0) (3, 1) 1.7 Masked arrays Masked arrays are arrays that may have missing or invalid entries. The numpy.ma module provides a nearly work- alike replacement for numpy that supports data arrays with masks. 1.7.1 The numpy.ma module Rationale Masked arrays are arrays that may have missing or invalid entries. The numpy.ma module provides a nearly work- alike replacement for numpy that supports data arrays with masks. What is a masked array? In many circumstances, datasets can be incomplete or tainted by the presence of invalid data. For example, a sensor may have failed to record a data, or recorded an invalid value. The numpy.ma module provides a convenient way to address this issue, by introducing masked arrays. A masked array is the combination of a standard numpy.ndarray and a mask. A mask is either nomask, indicating that no value of the associated array is invalid, or an array of booleans that determines for each element of the associated array whether the value is valid or not. When an element of the mask is False, the corresponding element of the associated array is valid and is said to be unmasked. When an element of the mask is True, the corresponding element of the associated array is said to be masked (invalid). The package ensures that masked entries are not used in computations. As an illustration, let’s consider the following dataset: >>> import numpy as np >>> import numpy.ma as ma >>> x= np.array([1,2,3,-1,5]) We wish to mark the fourth entry as invalid. The easiest is to create a masked array: >>> mx= ma.masked_array(x, mask=[0,0,0,1,0]) We can now compute the mean of the dataset, without taking the invalid data into account: >>> mx.mean() 2.75 The numpy.ma module The main feature of the numpy.ma module is the MaskedArray class, which is a subclass of numpy.ndarray. The class, its attributes and methods are described in more details in the MaskedArray class section. The numpy.ma module can be used as an addition to numpy: >>> import numpy as np >>> import numpy.ma as ma 1.7. Masked arrays 233 NumPy Reference, Release 1.8.1 To create an array with the second element invalid, we would do: >>> y= ma.array([1,2,3], mask=[0,1,0]) To create a masked array where all values close to 1.e20 are invalid, we would do: >>> z= masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20) For a complete discussion of creation methods for masked arrays please see section Constructing masked arrays. 1.7.2 Using numpy.ma Constructing masked arrays There are several ways to construct a masked array. • A ﬁrst possibility is to directly invoke the MaskedArray class. • A second possibility is to use the two masked array constructors, array and masked_array. array(data[, dtype, copy, order, mask, ...]) An array class with possibly masked values. masked_array An array class with possibly masked values. numpy.ma.array(data, dtype=None, copy=False, order=False, mask=False, ﬁll_value=None, keep_mask=True, hard_mask=False, shrink=True, subok=True, ndmin=0) An array class with possibly masked values. Masked values of True exclude the corresponding element from any computation. Construction: x= MaskedArray(data, mask=nomask, dtype=None, copy=False, subok=True, ndmin=0, fill_value=None, keep_mask=True, hard_mask=None, shrink=True) Parameters data : array_like Input data. mask : sequence, optional Mask. Must be convertible to an array of booleans with the same shape as data. True indicates a masked (i.e. invalid) data. dtype : dtype, optional Data type of the output. If dtype is None, the type of the data argument (data.dtype) is used. If dtype is not None and different from data.dtype, a copy is performed. copy : bool, optional Whether to copy the input data (True), or to use a reference instead. Default is False. subok : bool, optional Whether to return a subclass of MaskedArray if possible (True) or a plain MaskedArray. Default is True. ndmin : int, optional 234 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Minimum number of dimensions. Default is 0. ﬁll_value : scalar, optional Value used to ﬁll in the masked values when necessary. If None, a default based on the data-type is used. keep_mask : bool, optional Whether to combine mask with the mask of the input data, if any (True), or to use only mask for the output (False). Default is True. hard_mask : bool, optional Whether to use a hard mask or not. With a hard mask, masked values cannot be un- masked. Default is False. shrink : bool, optional Whether to force compression of an empty mask. Default is True. numpy.ma.masked_array alias of MaskedArray • A third option is to take the view of an existing array. In that case, the mask of the view is set to nomask if the array has no named ﬁelds, or an array of boolean with the same structure as the array otherwise. >>> x= np.array([1,2,3]) >>> x.view(ma.MaskedArray) masked_array(data = [1 2 3], mask = False, fill_value = 999999) >>> x= np.array([(1, 1.), (2, 2.)], dtype=[(’a’,int), (’b’, float)]) >>> x.view(ma.MaskedArray) masked_array(data = [(1, 1.0) (2, 2.0)], mask = [(False, False) (False, False)], fill_value = (999999, 1e+20), dtype = [(’a’, ’>> x= np.arange(10.).reshape(2,5) >>> x array([[ 0., 1., 2., 3., 4.], [ 5., 6., 7., 8., 9.]]) >>> np.ma.asarray(x) masked_array(data = [[ 0. 1. 2. 3. 4.] [ 5. 6. 7. 8. 9.]], mask = False, fill_value = 1e+20) >>> type(np.ma.asarray(x)) numpy.ma.asanyarray(a, dtype=None) Convert the input to a masked array, conserving subclasses. If a is a subclass of MaskedArray, its class is conserved. No copy is performed if the input is already an ndarray. Parameters a : array_like Input data, in any form that can be converted to an array. dtype : dtype, optional By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional Whether to use row-major (‘C’) or column-major (‘FORTRAN’) memory representa- tion. Default is ‘C’. 236 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Returns out : MaskedArray MaskedArray interpretation of a. See Also: asarray Similar to asanyarray, but does not conserve subclass. Examples >>> x= np.arange(10.).reshape(2,5) >>> x array([[ 0., 1., 2., 3., 4.], [ 5., 6., 7., 8., 9.]]) >>> np.ma.asanyarray(x) masked_array(data = [[ 0. 1. 2. 3. 4.] [ 5. 6. 7. 8. 9.]], mask = False, fill_value = 1e+20) >>> type(np.ma.asanyarray(x)) numpy.ma.fix_invalid(a, mask=False, copy=True, ﬁll_value=None) Return input with invalid data masked and replaced by a ﬁll value. Invalid data means values of nan, inf, etc. Parameters a : array_like Input array, a (subclass of) ndarray. copy : bool, optional Whether to use a copy of a (True) or to ﬁx a in place (False). Default is True. ﬁll_value : scalar, optional Value used for ﬁxing invalid data. Default is None, in which case the a.fill_value is used. Returns b : MaskedArray The input array with invalid entries ﬁxed. Notes A copy is performed by default. Examples >>> x= np.ma.array([1.,-1, np.nan, np.inf], mask=[1]+[0]*3) >>> x masked_array(data = [-- -1.0 nan inf], mask = [ True False False False], fill_value = 1e+20) >>> np.ma.fix_invalid(x) 1.7. Masked arrays 237 NumPy Reference, Release 1.8.1 masked_array(data = [-- -1.0 -- --], mask = [ True False True True], fill_value = 1e+20) >>> fixed= np.ma.fix_invalid(x) >>> fixed.data array([ 1.00000000e+00, -1.00000000e+00, 1.00000000e+20, 1.00000000e+20]) >>> x.data array([ 1., -1., NaN, Inf]) numpy.ma.masked_equal(x, value, copy=True) Mask an array where equal to a given value. This function is a shortcut to masked_where, with condition = (x == value). For ﬂoating point arrays, consider using masked_values(x, value). See Also: masked_where Mask where a condition is met. masked_values Mask using ﬂoating point equality. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_equal(a,2) masked_array(data = [0 1 -- 3], mask = [False False True False], fill_value=999999) numpy.ma.masked_greater(x, value, copy=True) Mask an array where greater than a given value. This function is a shortcut to masked_where, with condition = (x > value). See Also: masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_greater(a,2) masked_array(data = [0 1 2 --], mask = [False False False True], fill_value=999999) numpy.ma.masked_greater_equal(x, value, copy=True) Mask an array where greater than or equal to a given value. 238 Chapter 1. Array objects NumPy Reference, Release 1.8.1 This function is a shortcut to masked_where, with condition = (x >= value). See Also: masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_greater_equal(a,2) masked_array(data = [0 1 -- --], mask = [False False True True], fill_value=999999) numpy.ma.masked_inside(x, v1, v2, copy=True) Mask an array inside a given interval. Shortcut to masked_where, where condition is True for x inside the interval [v1,v2] (v1 <= x <= v2). The boundaries v1 and v2 can be given in either order. See Also: masked_where Mask where a condition is met. Notes The array x is preﬁlled with its ﬁlling value. Examples >>> import numpy.ma as ma >>> x=[0.31, 1.2, 0.01, 0.2,-0.4,-1.1] >>> ma.masked_inside(x,-0.3, 0.3) masked_array(data = [0.31 1.2 -- -- -0.4 -1.1], mask = [False False True True False False], fill_value=1e+20) The order of v1 and v2 doesn’t matter. >>> ma.masked_inside(x, 0.3,-0.3) masked_array(data = [0.31 1.2 -- -- -0.4 -1.1], mask = [False False True True False False], fill_value=1e+20) numpy.ma.masked_invalid(a, copy=True) Mask an array where invalid values occur (NaNs or infs). This function is a shortcut to masked_where, with condition = ~(np.isﬁnite(a)). Any pre-existing mask is conserved. Only applies to arrays with a dtype where NaNs or infs make sense (i.e. ﬂoating point types), but accepts any array_like object. See Also: masked_where Mask where a condition is met. 1.7. Masked arrays 239 NumPy Reference, Release 1.8.1 Examples >>> import numpy.ma as ma >>> a= np.arange(5, dtype=np.float) >>> a[2]= np.NaN >>> a[3]= np.PINF >>> a array([ 0., 1., NaN, Inf, 4.]) >>> ma.masked_invalid(a) masked_array(data = [0.0 1.0 -- -- 4.0], mask = [False False True True False], fill_value=1e+20) numpy.ma.masked_less(x, value, copy=True) Mask an array where less than a given value. This function is a shortcut to masked_where, with condition = (x < value). See Also: masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_less(a,2) masked_array(data = [-- -- 2 3], mask = [ True True False False], fill_value=999999) numpy.ma.masked_less_equal(x, value, copy=True) Mask an array where less than or equal to a given value. This function is a shortcut to masked_where, with condition = (x <= value). See Also: masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_less_equal(a,2) masked_array(data = [-- -- -- 3], mask = [ True True True False], fill_value=999999) numpy.ma.masked_not_equal(x, value, copy=True) Mask an array where not equal to a given value. This function is a shortcut to masked_where, with condition = (x != value). See Also: 240 Chapter 1. Array objects NumPy Reference, Release 1.8.1 masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_not_equal(a,2) masked_array(data = [-- -- 2 --], mask = [ True True False True], fill_value=999999) numpy.ma.masked_object(x, value, copy=True, shrink=True) Mask the array x where the data are exactly equal to value. This function is similar to masked_values, but only suitable for object arrays: for ﬂoating point, use masked_values instead. Parameters x : array_like Array to mask value : object Comparison value copy : {True, False}, optional Whether to return a copy of x. shrink : {True, False}, optional Whether to collapse a mask full of False to nomask Returns result : MaskedArray The result of masking x where equal to value. See Also: masked_where Mask where a condition is met. masked_equal Mask where equal to a given value (integers). masked_values Mask using ﬂoating point equality. Examples >>> import numpy.ma as ma >>> food= np.array([’green_eggs’,’ham’], dtype=object) >>> # don’t eat spoiled food >>> eat= ma.masked_object(food,’green_eggs’) >>> print eat [-- ham] >>> # plain ol‘ ham is boring >>> fresh_food= np.array([’cheese’,’ham’,’pineapple’], dtype=object) 1.7. Masked arrays 241 NumPy Reference, Release 1.8.1 >>> eat= ma.masked_object(fresh_food,’green_eggs’) >>> print eat [cheese ham pineapple] Note that mask is set to nomask if possible. >>> eat masked_array(data = [cheese ham pineapple], mask = False, fill_value=?) numpy.ma.masked_outside(x, v1, v2, copy=True) Mask an array outside a given interval. Shortcut to masked_where, where condition is True for x outside the interval [v1,v2] (x < v1)|(x > v2). The boundaries v1 and v2 can be given in either order. See Also: masked_where Mask where a condition is met. Notes The array x is preﬁlled with its ﬁlling value. Examples >>> import numpy.ma as ma >>> x=[0.31, 1.2, 0.01, 0.2,-0.4,-1.1] >>> ma.masked_outside(x,-0.3, 0.3) masked_array(data = [-- -- 0.01 0.2 -- --], mask = [ True True False False True True], fill_value=1e+20) The order of v1 and v2 doesn’t matter. >>> ma.masked_outside(x, 0.3,-0.3) masked_array(data = [-- -- 0.01 0.2 -- --], mask = [ True True False False True True], fill_value=1e+20) numpy.ma.masked_values(x, value, rtol=1e-05, atol=1e-08, copy=True, shrink=True) Mask using ﬂoating point equality. Return a MaskedArray, masked where the data in array x are approximately equal to value, i.e. where the following condition is True (abs(x - value) <= atol+rtol*abs(value)) The ﬁll_value is set to value and the mask is set to nomask if possible. For integers, consider using masked_equal. Parameters x : array_like Array to mask. value : ﬂoat Masking value. 242 Chapter 1. Array objects NumPy Reference, Release 1.8.1 rtol : ﬂoat, optional Tolerance parameter. atol : ﬂoat, optional Tolerance parameter (1e-8). copy : bool, optional Whether to return a copy of x. shrink : bool, optional Whether to collapse a mask full of False to nomask. Returns result : MaskedArray The result of masking x where approximately equal to value. See Also: masked_where Mask where a condition is met. masked_equal Mask where equal to a given value (integers). Examples >>> import numpy.ma as ma >>> x= np.array([1, 1.1,2, 1.1,3]) >>> ma.masked_values(x, 1.1) masked_array(data = [1.0 -- 2.0 -- 3.0], mask = [False True False True False], fill_value=1.1) Note that mask is set to nomask if possible. >>> ma.masked_values(x, 1.5) masked_array(data = [ 1. 1.1 2. 1.1 3. ], mask = False, fill_value=1.5) For integers, the ﬁll value will be different in general to the result of masked_equal. >>> x= np.arange(5) >>> x array([0, 1, 2, 3, 4]) >>> ma.masked_values(x,2) masked_array(data = [0 1 -- 3 4], mask = [False False True False False], fill_value=2) >>> ma.masked_equal(x,2) masked_array(data = [0 1 -- 3 4], mask = [False False True False False], fill_value=999999) numpy.ma.masked_where(condition, a, copy=True) Mask an array where a condition is met. 1.7. Masked arrays 243 NumPy Reference, Release 1.8.1 Return a as an array masked where condition is True. Any masked values of a or condition are also masked in the output. Parameters condition : array_like Masking condition. When condition tests ﬂoating point values for equality, consider using masked_values instead. a : array_like Array to mask. copy : bool If True (default) make a copy of a in the result. If False modify a in place and return a view. Returns result : MaskedArray The result of masking a where condition is True. See Also: masked_values Mask using ﬂoating point equality. masked_equal Mask where equal to a given value. masked_not_equal Mask where not equal to a given value. masked_less_equal Mask where less than or equal to a given value. masked_greater_equal Mask where greater than or equal to a given value. masked_less Mask where less than a given value. masked_greater Mask where greater than a given value. masked_inside Mask inside a given interval. masked_outside Mask outside a given interval. masked_invalid Mask invalid values (NaNs or infs). Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_where(a<=2, a) masked_array(data = [-- -- -- 3], 244 Chapter 1. Array objects NumPy Reference, Release 1.8.1 mask = [ True True True False], fill_value=999999) Mask array b conditional on a. >>> b=[’a’,’b’,’c’,’d’] >>> ma.masked_where(a ==2, b) masked_array(data = [a b -- d], mask = [False False True False], fill_value=N/A) Effect of the copy argument. >>> c= ma.masked_where(a<=2, a) >>> c masked_array(data = [-- -- -- 3], mask = [ True True True False], fill_value=999999) >>> c[0]= 99 >>> c masked_array(data = [99 -- -- 3], mask = [False True True False], fill_value=999999) >>> a array([0, 1, 2, 3]) >>> c= ma.masked_where(a<=2, a, copy=False) >>> c[0]= 99 >>> c masked_array(data = [99 -- -- 3], mask = [False True True False], fill_value=999999) >>> a array([99, 1, 2, 3]) When condition or a contain masked values. >>> a= np.arange(4) >>> a= ma.masked_where(a ==2, a) >>> a masked_array(data = [0 1 -- 3], mask = [False False True False], fill_value=999999) >>> b= np.arange(4) >>> b= ma.masked_where(b ==0, b) >>> b masked_array(data = [-- 1 2 3], mask = [ True False False False], fill_value=999999) >>> ma.masked_where(a ==3, b) masked_array(data = [-- 1 -- --], mask = [ True False True True], fill_value=999999) Accessing the data The underlying data of a masked array can be accessed in several ways: 1.7. Masked arrays 245 NumPy Reference, Release 1.8.1 • through the data attribute. The output is a view of the array as a numpy.ndarray or one of its subclasses, depending on the type of the underlying data at the masked array creation. • through the __array__ method. The output is then a numpy.ndarray. • by directly taking a view of the masked array as a numpy.ndarray or one of its subclass (which is actually what using the data attribute does). • by using the getdata function. None of these methods is completely satisfactory if some entries have been marked as invalid. As a general rule, where a representation of the array is required without any masked entries, it is recommended to ﬁll the array with the filled method. Accessing the mask The mask of a masked array is accessible through its mask attribute. We must keep in mind that a True entry in the mask indicates an invalid data. Another possibility is to use the getmask and getmaskarray functions. getmask(x) outputs the mask of x if x is a masked array, and the special value nomask otherwise. getmaskarray(x) outputs the mask of x if x is a masked array. If x has no invalid entry or is not a masked array, the function outputs a boolean array of False with as many elements as x. Accessing only the valid entries To retrieve only the valid entries, we can use the inverse of the mask as an index. The inverse of the mask can be calculated with the numpy.logical_not function or simply with the ~ operator: >>> x= ma.array([[1,2], [3,4]], mask=[[0,1], [1,0]]) >>> x[~x.mask] masked_array(data = [1 4], mask = [False False], fill_value = 999999) Another way to retrieve the valid data is to use the compressed method, which returns a one-dimensional ndarray (or one of its subclasses, depending on the value of the baseclass attribute): >>> x.compressed() array([1, 4]) Note that the output of compressed is always 1D. Modifying the mask Masking an entry The recommended way to mark one or several speciﬁc entries of a masked array as invalid is to assign the special value masked to them: >>> x= ma.array([1,2,3]) >>> x[0]= ma.masked >>> x masked_array(data = [-- 2 3], mask = [ True False False], fill_value = 999999) >>> y= ma.array([[1,2,3], [4,5,6], [7,8,9]]) 246 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> y[(0,1,2), (1,2,0)]= ma.masked >>> y masked_array(data = [[1 -- 3] [4 5 --] [-- 8 9]], mask = [[False True False] [False False True] [ True False False]], fill_value = 999999) >>> z= ma.array([1,2,3,4]) >>> z[:-2]= ma.masked >>> z masked_array(data = [-- -- 3 4], mask = [ True True False False], fill_value = 999999) A second possibility is to modify the mask directly, but this usage is discouraged. All the entries of an array can be masked at once by assigning True to the mask: >>> x= ma.array([1,2,3], mask=[0,0,1]) >>> x.mask= True >>> x masked_array(data = [-- -- --], mask = [ True True True], fill_value = 999999) Finally, speciﬁc entries can be masked and/or unmasked by assigning to the mask a sequence of booleans: >>> x= ma.array([1,2,3]) >>> x.mask=[0,1,0] >>> x masked_array(data = [1 -- 3], mask = [False True False], fill_value = 999999) Unmasking an entry To unmask one or several speciﬁc entries, we can just assign one or several new valid values to them: >>> x= ma.array([1,2,3], mask=[0,0,1]) >>> x masked_array(data = [1 2 --], mask = [False False True], fill_value = 999999) >>> x[-1]=5 >>> x masked_array(data = [1 2 5], mask = [False False False], fill_value = 999999) Note: Unmasking an entry by direct assignment will silently fail if the masked array has a hard mask, as shown by the hardmask attribute. This feature was introduced to prevent overwriting the mask. To force the unmasking of an entry where the array has a hard mask, the mask must ﬁrst to be softened using the soften_mask method before the allocation. It can be re-hardened with harden_mask: 1.7. Masked arrays 247 NumPy Reference, Release 1.8.1 >>> x= ma.array([1,2,3], mask=[0,0,1], hard_mask=True) >>> x masked_array(data = [1 2 --], mask = [False False True], fill_value = 999999) >>> x[-1]=5 >>> x masked_array(data = [1 2 --], mask = [False False True], fill_value = 999999) >>> x.soften_mask() >>> x[-1]=5 >>> x masked_array(data = [1 2 5], mask = [False False False], fill_value = 999999) >>> x.harden_mask() To unmask all masked entries of a masked array (provided the mask isn’t a hard mask), the simplest solution is to assign the constant nomask to the mask: >>> x= ma.array([1,2,3], mask=[0,0,1]) >>> x masked_array(data = [1 2 --], mask = [False False True], fill_value = 999999) >>> x.mask= ma.nomask >>> x masked_array(data = [1 2 3], mask = [False False False], fill_value = 999999) Indexing and slicing As a MaskedArray is a subclass of numpy.ndarray, it inherits its mechanisms for indexing and slicing. When accessing a single entry of a masked array with no named ﬁelds, the output is either a scalar (if the corresponding entry of the mask is False) or the special value masked (if the corresponding entry of the mask is True): >>> x= ma.array([1,2,3], mask=[0,0,1]) >>> x[0] 1 >>> x[-1] masked_array(data = --, mask = True, fill_value = 1e+20) >>> x[-1] is ma.masked True If the masked array has named ﬁelds, accessing a single entry returns a numpy.void object if none of the ﬁelds are masked, or a 0d masked array with the same dtype as the initial array if at least one of the ﬁelds is masked. >>> y= ma.masked_array([(1,2), (3,4)], ... mask=[(0,0), (0,1)], ... dtype=[(’a’, int), (’b’, int)]) >>> y[0] (1, 2) 248 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> y[-1] masked_array(data = (3, --), mask = (False, True), fill_value = (999999, 999999), dtype = [(’a’, ’>> x= ma.array([1,2,3,4,5], mask=[0,1,0,0,1]) >>> mx= x[:3] >>> mx masked_array(data = [1 -- 3], mask = [False True False], fill_value = 999999) >>> mx[1]=-1 >>> mx masked_array(data = [1 -1 3], mask = [False True False], fill_value = 999999) >>> x.mask array([False, True, False, False, True], dtype=bool) >>> x.data array([ 1, -1, 3, 4, 5]) Accessing a ﬁeld of a masked array with structured datatype returns a MaskedArray. Operations on masked arrays Arithmetic and comparison operations are supported by masked arrays. As much as possible, invalid entries of a masked array are not processed, meaning that the corresponding data entries should be the same before and after the operation. Warning: We need to stress that this behavior may not be systematic, that masked data may be affected by the operation in some cases and therefore users should not rely on this data remaining unchanged. The numpy.ma module comes with a speciﬁc implementation of most ufuncs. Unary and binary functions that have a validity domain (such as log or divide) return the masked constant whenever the input is masked or falls outside the validity domain: >>> ma.log([-1,0,1,2]) masked_array(data = [-- -- 0.0 0.69314718056], mask = [ True True False False], fill_value = 1e+20) Masked arrays also support standard numpy ufuncs. The output is then a masked array. The result of a unary ufunc is masked wherever the input is masked. The result of a binary ufunc is masked wherever any of the input is masked. If the ufunc also returns the optional context output (a 3-element tuple containing the name of the ufunc, its arguments and its domain), the context is processed and entries of the output masked array are masked wherever the corresponding input fall outside the validity domain: >>> x= ma.array([-1,1,0,2,3], mask=[0,0,0,0,1]) >>> np.log(x) masked_array(data = [-- -- 0.0 0.69314718056 --], 1.7. Masked arrays 249 NumPy Reference, Release 1.8.1 mask = [ True True False False True], fill_value = 1e+20) 1.7.3 Examples Data with a given value representing missing data Let’s consider a list of elements, x, where values of -9999. represent missing data. We wish to compute the average value of the data and the vector of anomalies (deviations from the average): >>> import numpy.ma as ma >>> x=[0.,1.,-9999.,3.,4.] >>> mx= ma.masked_values (x,-9999.) >>> print mx.mean() 2.0 >>> print mx- mx.mean() [-2.0 -1.0 -- 1.0 2.0] >>> print mx.anom() [-2.0 -1.0 -- 1.0 2.0] Filling in the missing data Suppose now that we wish to print that same data, but with the missing values replaced by the average value. >>> print mx.filled(mx.mean()) [ 0. 1. 2. 3. 4.] Numerical operations Numerical operations can be easily performed without worrying about missing values, dividing by zero, square roots of negative numbers, etc.: >>> import numpy as np, numpy.ma as ma >>> x= ma.array([1.,-1., 3., 4., 5., 6.], mask=[0,0,0,0,1,0]) >>> y= ma.array([1., 2., 0., 4., 5., 6.], mask=[0,0,0,0,0,1]) >>> print np.sqrt(x/y) [1.0 -- -- 1.0 -- --] Four values of the output are invalid: the ﬁrst one comes from taking the square root of a negative number, the second from the division by zero, and the last two where the inputs were masked. Ignoring extreme values Let’s consider an array d of random ﬂoats between 0 and 1. We wish to compute the average of the values of d while ignoring any data outside the range [0.1, 0.9]: >>> print ma.masked_outside(d, 0.1, 0.9).mean() 1.7.4 Constants of the numpy.ma module In addition to the MaskedArray class, the numpy.ma module deﬁnes several constants. 250 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.ma.masked The masked constant is a special case of MaskedArray, with a ﬂoat datatype and a null shape. It is used to test whether a speciﬁc entry of a masked array is masked, or to mask one or several entries of a masked array: >>> x= ma.array([1,2,3], mask=[0,1,0]) >>> x[1] is ma.masked True >>> x[-1]= ma.masked >>> x masked_array(data = [1 -- --], mask = [False True True], fill_value = 999999) numpy.ma.nomask Value indicating that a masked array has no invalid entry. nomask is used internally to speed up computations when the mask is not needed. numpy.ma.masked_print_options String used in lieu of missing data when a masked array is printed. By default, this string is ’--’. 1.7.5 The MaskedArray class class numpy.ma.MaskedArray A subclass of ndarray designed to manipulate numerical arrays with missing data. An instance of MaskedArray can be thought as the combination of several elements: • The data, as a regular numpy.ndarray of any shape or datatype (the data). • A boolean mask with the same shape as the data, where a True value indicates that the corresponding element of the data is invalid. The special value nomask is also acceptable for arrays without named ﬁelds, and indicates that no data is invalid. •A fill_value, a value that may be used to replace the invalid entries in order to return a standard numpy.ndarray. Attributes and properties of masked arrays See Also: Array Attributes MaskedArray.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= 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. MaskedArray.mask Returns the underlying mask, as an array with the same shape and structure as the data, but where all ﬁelds are atomically booleans. A value of True indicates an invalid entry. 1.7. Masked arrays 251 NumPy Reference, Release 1.8.1 MaskedArray.recordmask Returns the mask of the array if it has no named ﬁelds. For structured arrays, returns a ndarray of booleans where entries are True if all the ﬁelds are masked, False otherwise: >>> x= 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], dtype=bool) MaskedArray.fill_value Returns the value used to ﬁll the invalid entries of a masked array. The value is either a scalar (if the masked array has no named ﬁelds), or a 0-D ndarray with the same dtype as the masked array if it has named ﬁelds. The default ﬁlling value depends on the datatype of the array: datatype default bool True int 999999 ﬂoat 1.e20 complex 1.e20+0j object ‘?’ string ‘N/A’ MaskedArray.baseclass Returns the class of the underlying data. >>> x= ma.array(np.matrix([[1,2], [3,4]]), mask=[[0,0], [1,0]]) >>> x.baseclass MaskedArray.sharedmask Returns whether the mask of the array is shared between several masked arrays. If this is the case, any modiﬁ- cation to the mask of one array will be propagated to the others. MaskedArray.hardmask Returns whether the mask is hard (True) or soft (False). When the mask is hard, masked entries cannot be unmasked. As MaskedArray is a subclass of ndarray, a masked array also inherits all the attributes and properties of a ndarray instance. MaskedArray.base Base object if memory is from some other object. MaskedArray.ctypes An object to simplify the interaction of the array with the ctypes module. MaskedArray.dtype Data-type of the array’s elements. MaskedArray.flags Information about the memory layout of the array. MaskedArray.itemsize Length of one array element in bytes. MaskedArray.nbytes Total bytes consumed by the elements of the array. MaskedArray.ndim Number of array dimensions. MaskedArray.shape Tuple of array dimensions. MaskedArray.size Number of elements in the array. MaskedArray.strides Tuple of bytes to step in each dimension when traversing an array. MaskedArray.imag Imaginary part. MaskedArray.real Real part MaskedArray.flat Flat version of the array. MaskedArray.__array_priority__ int(x[, base]) -> integer 252 Chapter 1. Array objects NumPy Reference, Release 1.8.1 MaskedArray.base Base object if memory is from some other object. Examples The base of an array that owns its memory is None: >>> 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 MaskedArray.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 c : Python object Possessing attributes data, shape, strides, etc. See Also: numpy.ctypeslib 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): •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 ﬂags 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]. •shape (c_intp*self.ndim): A ctypes array of length self.ndim where the basetype is the C-integer corre- sponding to dtype(‘p’) on this platform. This base-type could be c_int, c_long, or c_longlong depending on the platform. The c_intp type is deﬁned accordingly in numpy.ctypeslib. The ctypes array contains the shape of the underlying array. •strides (c_intp*self.ndim): 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. •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 ﬂoating-point data: self.data_as(ctypes.POINTER(ctypes.c_double)). 1.7. Masked arrays 253 NumPy Reference, Release 1.8.1 •shape_as(obj): Return the shape tuple as an array of some other c-types type. For example: self.shape_as(ctypes.c_short). •strides_as(obj): Return the strides tuple as an array of some other c-types type. For example: self.strides_as(ctypes.c_longlong). Be careful using the ctypes attribute - especially on temporary arrays or arrays constructed on the ﬂy. For example, calling (a+b).ctypes.data_as(ctypes.c_void_p) returns a pointer to memory that is invalid because the array created as (a+b) is deallocated before the next Python statement. You can avoid this problem using either c=a+b or ct=(a+b).ctypes. In the latter case, ct will hold a reference to the array until ct is deleted or re-assigned. 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 ctypes >>> x array([[0, 1], [2, 3]]) >>> x.ctypes.data 30439712 >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents c_long(0) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents c_longlong(4294967296L) >>> x.ctypes.shape >>> x.ctypes.shape_as(ctypes.c_long) >>> x.ctypes.strides >>> x.ctypes.strides_as(ctypes.c_longlong) MaskedArray.dtype Data-type of the array’s elements. Parameters None Returns d : numpy dtype object See Also: numpy.dtype Examples >>> x array([[0, 1], [2, 3]]) >>> x.dtype dtype(’int32’) >>> type(x.dtype) 254 Chapter 1. Array objects NumPy Reference, Release 1.8.1 MaskedArray.flags Information about the memory layout of the array. 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 ﬂag names are only supported in dictionary access. Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED ﬂags can be changed by the user, via direct assign- ment to the attribute or dictionary entry, or by calling ndarray.setﬂags. The array ﬂags cannot be set arbitrarily: •UPDATEIFCOPY 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 arbi- trary 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. 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. WRITE- ABLE (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. UPDATEIF- COPY (U) This array is a copy of some other array. When this array is deallocated, 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. 1.7. Masked arrays 255 NumPy Reference, Release 1.8.1 MaskedArray.itemsize Length of one array element in bytes. Examples >>> x= np.array([1,2,3], dtype=np.float64) >>> x.itemsize 8 >>> x= np.array([1,2,3], dtype=np.complex128) >>> x.itemsize 16 MaskedArray.nbytes Total bytes consumed by the elements of the array. Notes Does not include memory consumed by non-element attributes of the array object. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.nbytes 480 >>> np.prod(x.shape) * x.itemsize 480 MaskedArray.ndim Number of array dimensions. Examples >>> x= np.array([1,2,3]) >>> x.ndim 1 >>> y= np.zeros((2,3,4)) >>> y.ndim 3 MaskedArray.shape Tuple of array dimensions. Notes May be used to “reshape” the array, as long as this would not require a change in the total number of elements Examples >>> x= np.array([1,2,3,4]) >>> x.shape (4,) >>> y= np.zeros((2,3,4)) >>> y.shape (2, 3, 4) >>> y.shape=(3,8) >>> y array([[ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0., 0., 0.]]) >>> y.shape=(3,6) 256 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Traceback (most recent call last): File "", line1, in ValueError: total size of new array must be unchanged MaskedArray.size Number of elements in the array. Equivalent to np.prod(a.shape), i.e., the product of the array’s dimensions. Examples >>> x= np.zeros((3,5,2), dtype=np.complex128) >>> x.size 30 >>> np.prod(x.shape) 30 MaskedArray.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 “ndarray.rst” ﬁle in the NumPy reference guide. See Also: numpy.lib.stride_tricks.as_strided 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 >>> y= np.reshape(np.arange(2 *3*4), (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]]]) >>> y.strides (48, 16, 4) >>> y[1,1,1] 17 >>> offset=sum(y.strides * np.array((1,1,1))) >>> offset/y.itemsize 17 1.7. Masked arrays 257 NumPy Reference, Release 1.8.1 >>> x= np.reshape(np.arange(5 *6*7*8), (5,6,7,8)).transpose(2,3,1,0) >>> x.strides (32, 4, 224, 1344) >>> i= np.array([3,5,2,2]) >>> offset= sum(i * x.strides) >>> x[3,5,2,2] 813 >>> offset/x.itemsize 813 MaskedArray.imag Imaginary part. MaskedArray.real Real part MaskedArray.flat Flat version of the array. MaskedArray.__array_priority__ = 15 1.7.6 MaskedArray methods See Also: Array methods Conversion MaskedArray.__float__() Convert to ﬂoat. MaskedArray.__hex__() <==> hex(x) MaskedArray.__int__() Convert to int. MaskedArray.__long__() <==> long(x) MaskedArray.__oct__() <==> oct(x) MaskedArray.view([dtype, type]) New view of array with the same data. MaskedArray.astype(newtype) Returns a copy of the MaskedArray cast to given newtype. MaskedArray.byteswap(inplace) Swap the bytes of the array elements MaskedArray.compressed() Return all the non-masked data as a 1-D array. MaskedArray.filled([ﬁll_value]) Return a copy of self, with masked values ﬁlled with a given value. MaskedArray.tofile(ﬁd[, sep, format]) Save a masked array to a ﬁle in binary format. MaskedArray.toflex() Transforms a masked array into a ﬂexible-type array. MaskedArray.tolist([ﬁll_value]) Return the data portion of the masked array as a hierarchical Python list. MaskedArray.torecords() Transforms a masked array into a ﬂexible-type array. MaskedArray.tostring([ﬁll_value, order]) Return the array data as a string containing the raw bytes in the array. MaskedArray.__float__() Convert to ﬂoat. MaskedArray.__hex__() <==> hex(x) MaskedArray.__int__() Convert to int. 258 Chapter 1. Array objects NumPy Reference, Release 1.8.1 MaskedArray.__long__() <==> long(x) MaskedArray.__oct__() <==> oct(x) MaskedArray.view(dtype=None, type=None) New view of array with the same data. Parameters dtype : data-type or ndarray sub-class, optional Data-type descriptor of the returned view, e.g., ﬂoat32 or int16. The default, None, results in the view having the same data-type as a. This argument can also be speciﬁed as an ndarray sub-class, which then speciﬁes the type of the returned object (this is equivalent to setting the type parameter). type : Python type, optional Type of the returned view, e.g., ndarray or matrix. Again, the default None results in type preservation. 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. 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 superﬁcial 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 deﬁned as a slice or transpose, etc., the view may give different results. Examples >>> x= np.array([(1,2)], dtype=[(’a’, np.int8), (’b’, np.int8)]) Viewing array data using a different type and dtype: >>> y=x.view(dtype=np.int16, type=np.matrix) >>> y matrix([[513]], dtype=int16) >>> print type(y) Creating a view on a structured array so it can be used in calculations >>> x= np.array([(1,2),(3,4)], dtype=[(’a’, np.int8), (’b’, np.int8)]) >>> xv=x.view(dtype=np.int8).reshape(-1,2) >>> xv array([[1, 2], [3, 4]], dtype=int8) >>> xv.mean(0) array([ 2., 3.]) Making changes to the view changes the underlying array 1.7. Masked arrays 259 NumPy Reference, Release 1.8.1 >>> xv[0,1]= 20 >>> print x [(1, 20) (3, 4)] Using a view to convert an array to a record array: >>> z=x.view(np.recarray) >>> z.a array([1], dtype=int8) Views share data: >>> x[0]=(9, 10) >>> z[0] (9, 10) Views that change the dtype size (bytes per entry) should normally be avoided on arrays deﬁned by slices, transposes, fortran-ordering, etc.: >>> x= np.array([[1,2,3],[4,5,6]], dtype=np.int16) >>> y= x[:,0:2] >>> y array([[1, 2], [4, 5]], dtype=int16) >>> y.view(dtype=[(’width’, np.int16), (’length’, np.int16)]) Traceback (most recent call last): File "", line1, in ValueError: new type not compatible with array. >>> z=y.copy() >>> z.view(dtype=[(’width’, np.int16), (’length’, np.int16)]) array([[(1, 2)], [(4, 5)]], dtype=[(’width’, ’>> x= np.ma.array([[1,2,3.1],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1.0 -- 3.1] [-- 5.0 --] [7.0 -- 9.0]] >>> print x.astype(int32) [[1 -- 3] [-- 5 --] [7 -- 9]] MaskedArray.byteswap(inplace) 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. Parameters inplace : bool, optional 260 Chapter 1. Array objects NumPy Reference, Release 1.8.1 If True, swap bytes in-place, default is False. Returns out : ndarray The byteswapped array. If inplace is True, this is a view to self. Examples >>> A= np.array([1, 256, 8755], dtype=np.int16) >>> map(hex, A) [’0x1’, ’0x100’, ’0x2233’] >>> A.byteswap(True) array([ 256, 1, 13090], dtype=int16) >>> map(hex, A) [’0x100’, ’0x1’, ’0x3322’] Arrays of strings are not swapped >>> A= np.array([’ceg’,’fac’]) >>> A.byteswap() array([’ceg’, ’fac’], dtype=’|S3’) MaskedArray.compressed() Return all the non-masked data as a 1-D array. Returns data : ndarray A new ndarray holding the non-masked data is returned. Notes The result is not a MaskedArray! Examples >>> x= np.ma.array(np.arange(5), mask=[0]*2+[1]*3) >>> x.compressed() array([0, 1]) >>> type(x.compressed()) MaskedArray.filled(ﬁll_value=None) Return a copy of self, with masked values ﬁlled with a given value. Parameters ﬁll_value : scalar, optional The value to use for invalid entries (None by default). If None, the fill_value attribute of the array is used instead. Returns ﬁlled_array : ndarray A copy of self with invalid entries replaced by ﬁll_value (be it the function argument or the attribute of self. Notes The result is not a MaskedArray! 1.7. Masked arrays 261 NumPy Reference, Release 1.8.1 Examples >>> 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]) >>> type(x.filled()) Subclassing is preserved. This means that if the data part of the masked array is a matrix, filled returns a matrix: >>> x= np.ma.array(np.matrix([[1,2], [3,4]]), mask=[[0,1], [1,0]]) >>> x.filled() matrix([[ 1, 999999], [999999, 4]]) MaskedArray.tofile(ﬁd, sep=’‘, format=’%s’) Save a masked array to a ﬁle in binary format. Warning: This function is not implemented yet. Raises NotImplementedError When tofile is called. MaskedArray.toflex() Transforms a masked array into a ﬂexible-type array. The ﬂexible type array that is returned will have two ﬁelds: •the _data ﬁeld stores the _data part of the array. •the _mask ﬁeld stores the _mask part of the array. Parameters None Returns record : ndarray A new ﬂexible-type ndarray with two ﬁelds: the ﬁrst 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 ﬂexible ndarray is that meta information (fill_value, ...) will be lost. Examples >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> print x.toflex() [[(1, False) (2, True) (3, False)] [(4, True) (5, False) (6, True)] [(7, False) (8, True) (9, False)]] 262 Chapter 1. Array objects NumPy Reference, Release 1.8.1 MaskedArray.tolist(ﬁll_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 ﬁll_value : scalar, optional The value to use for invalid entries. Default is None. Returns result : list The Python list representation of the masked array. Examples >>> 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]] MaskedArray.torecords() Transforms a masked array into a ﬂexible-type array. The ﬂexible type array that is returned will have two ﬁelds: •the _data ﬁeld stores the _data part of the array. •the _mask ﬁeld stores the _mask part of the array. Parameters None Returns record : ndarray A new ﬂexible-type ndarray with two ﬁelds: the ﬁrst 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 ﬂexible ndarray is that meta information (fill_value, ...) will be lost. Examples >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> print x.toflex() [[(1, False) (2, True) (3, False)] [(4, True) (5, False) (6, True)] [(7, False) (8, True) (9, False)]] MaskedArray.tostring(ﬁll_value=None, order=’C’) Return the array data as a string containing the raw bytes in the array. 1.7. Masked arrays 263 NumPy Reference, Release 1.8.1 The array is ﬁlled with a ﬁll value before the string conversion. Parameters ﬁll_value : scalar, optional Value used to ﬁll in the masked values. Deafult 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’. See Also: ndarray.tostring, tolist, tofile Notes As for ndarray.tostring, information about the shape, dtype, etc., but also about fill_value, will be lost. Examples >>> x= np.ma.array(np.array([[1,2], [3,4]]), mask=[[0,1], [1,0]]) >>> x.tostring() ’\x01\x00\x00\x00?B\x0f\x00?B\x0f\x00\x04\x00\x00\x00’ Shape manipulation For reshape, resize, and transpose, the single tuple argument may be replaced with n integers which will be interpreted as an n-tuple. MaskedArray.flatten([order]) Return a copy of the array collapsed into one dimension. MaskedArray.ravel() Returns a 1D version of self, as a view. MaskedArray.reshape(*s, **kwargs) Give a new shape to the array without changing its data. MaskedArray.resize(newshape[, refcheck, order]) MaskedArray.squeeze([axis]) Remove single-dimensional entries from the shape of a. MaskedArray.swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. MaskedArray.transpose(*axes) Returns a view of the array with axes transposed. MaskedArray.T MaskedArray.flatten(order=’C’) Return a copy of the array collapsed into one dimension. Parameters order : {‘C’, ‘F’, ‘A’}, optional Whether to ﬂatten in C (row-major), Fortran (column-major) order, or preserve the C/Fortran ordering from a. The default is ‘C’. Returns y : ndarray 264 Chapter 1. Array objects NumPy Reference, Release 1.8.1 A copy of the input array, ﬂattened to one dimension. See Also: ravel Return a ﬂattened array. flat A 1-D ﬂat iterator over the array. Examples >>> a= np.array([[1,2], [3,4]]) >>> a.flatten() array([1, 2, 3, 4]) >>> a.flatten(’F’) array([1, 3, 2, 4]) MaskedArray.ravel() Returns a 1D version of self, as a view. Returns MaskedArray Output view is of shape (self.size,) (or (np.ma.product(self.shape),)). Examples >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> print x.ravel() [1 -- 3 -- 5 -- 7 -- 9] MaskedArray.reshape(*s,**kwargs) Give a new shape to the array without changing its data. Returns a masked array containing the same data, but with a new shape. The result is a view on the original array; if this is not possible, a ValueError is raised. Parameters shape : int 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_array : array A new view on the array. See Also: 1.7. Masked arrays 265 NumPy Reference, Release 1.8.1 reshape Equivalent function in the masked array module. numpy.ndarray.reshape Equivalent method on ndarray object. numpy.reshape Equivalent function in the NumPy module. Notes The reshaping operation cannot guarantee that a copy will not be made, to modify the shape in place, use a.shape = s Examples >>> x= np.ma.array([[1,2],[3,4]], mask=[1,0,0,1]) >>> print x [[-- 2] [3 --]] >>> x=x.reshape((4,1)) >>> print x [[--] [2] [3] [--]] MaskedArray.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 difﬁcult to implement safely and may be deprecated in future releases of NumPy. MaskedArray.squeeze(axis=None) Remove single-dimensional entries from the shape of a. Refer to numpy.squeeze for full documentation. See Also: numpy.squeeze equivalent function MaskedArray.swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. Refer to numpy.swapaxes for full documentation. See Also: numpy.swapaxes equivalent function MaskedArray.transpose(*axes) Returns a view of the array with axes transposed. For a 1-D array, this has no effect. (To change between column and row vectors, ﬁrst cast the 1-D array into a ma- trix object.) For a 2-D array, this is the usual matrix transpose. For an n-D array, if axes are given, their order in- dicates how the axes are permuted (see Examples). If axes are not provided and a.shape = (i[0], i[1], 266 Chapter 1. Array objects NumPy Reference, Release 1.8.1 ... i[n-2], i[n-1]), then a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0]). 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 a‘s i-th axis becomes a.transpose()‘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 out : ndarray View of a, with axes suitably permuted. See Also: ndarray.T Array property returning the array transposed. Examples >>> 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]]) MaskedArray.T Item selection and manipulation For array methods that take an axis keyword, it defaults to None. If axis is None, then the array is treated as a 1-D array. Any other value for axis represents the dimension along which the operation should proceed. MaskedArray.argmax([axis, ﬁll_value, out]) Returns array of indices of the maximum values along the given axis. MaskedArray.argmin([axis, ﬁll_value, out]) Return array of indices to the minimum values along the given axis. MaskedArray.argsort([axis, kind, order, ...]) Return an ndarray of indices that sort the array along the speciﬁed axis. MaskedArray.choose(choices[, out, mode]) Use an index array to construct a new array from a set of choices. MaskedArray.compress(condition[, axis, out]) Return a where condition is True. MaskedArray.diagonal([offset, axis1, axis2]) Return speciﬁed diagonals. MaskedArray.fill(value) Fill the array with a scalar value. MaskedArray.item(*args) Copy an element of an array to a standard Python scalar and return it. MaskedArray.nonzero() Return the indices of unmasked elements that are not zero. Continued on next page 1.7. Masked arrays 267 NumPy Reference, Release 1.8.1 Table 1.64 – continued from previous page MaskedArray.put(indices, values[, mode]) Set storage-indexed locations to corresponding values. MaskedArray.repeat(repeats[, axis]) Repeat elements of an array. MaskedArray.searchsorted(v[, side, sorter]) Find indices where elements of v should be inserted in a to maintain order. MaskedArray.sort([axis, kind, order, ...]) Sort the array, in-place MaskedArray.take(indices[, axis, out, mode]) MaskedArray.argmax(axis=None, ﬁll_value=None, out=None) Returns array of indices of the maximum values along the given axis. Masked values are treated as if they had the value ﬁll_value. Parameters axis : {None, integer} If None, the index is into the ﬂattened array, otherwise along the speciﬁed axis ﬁll_value : {var}, optional Value used to ﬁll in the masked values. If None, the output of maxi- mum_ﬁll_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 >>> a= np.arange(6).reshape(2,3) >>> a.argmax() 5 >>> a.argmax(0) array([1, 1, 1]) >>> a.argmax(1) array([2, 2]) MaskedArray.argmin(axis=None, ﬁll_value=None, out=None) Return array of indices to the minimum values along the given axis. Parameters axis : {None, integer} If None, the index is into the ﬂattened array, otherwise along the speciﬁed axis ﬁll_value : {var}, optional Value used to ﬁll in the masked values. If None, the output of mini- mum_ﬁll_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, scalar} 268 Chapter 1. Array objects NumPy Reference, Release 1.8.1 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 >>> x= np.ma.array(arange(4), mask=[1,1,0,0]) >>> x.shape=(2,2) >>> print x [[-- --] [2 3]] >>> print x.argmin(axis=0, fill_value=-1) [0 0] >>> print x.argmin(axis=0, fill_value=9) [1 1] MaskedArray.argsort(axis=None, kind=’quicksort’, order=None, ﬁll_value=None) Return an ndarray of indices that sort the array along the speciﬁed axis. Masked values are ﬁlled beforehand to fill_value. Parameters axis : int, optional Axis along which to sort. The default is -1 (last axis). If None, the ﬂattened array is used. ﬁll_value : var, optional Value used to ﬁll the array before sorting. The default is the fill_value attribute of the input array. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional Sorting algorithm. order : list, optional When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. Returns index_array : ndarray, int Array of indices that sort a along the speciﬁed axis. In other words, a[index_array] yields a sorted a. See Also: sort Describes sorting algorithms used. lexsort Indirect stable sort with multiple keys. ndarray.sort Inplace sort. Notes See sort for notes on the different sorting algorithms. 1.7. Masked arrays 269 NumPy Reference, Release 1.8.1 Examples >>> 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]) MaskedArray.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. See Also: numpy.choose equivalent function MaskedArray.compress(condition, axis=None, out=None) Return a where condition is True. If condition is a MaskedArray, missing values are considered as False. Parameters condition : var 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 result : MaskedArray A MaskedArray object. Notes Please note the difference with compressed ! The output of compress has a mask, the output of compressed does not. Examples >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> x.compress([1,0,1]) masked_array(data = [1 3], mask = [False False], fill_value=999999) 270 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> x.compress([1,0,1], axis=1) masked_array(data = [[1 3] [-- --] [7 9]], mask = [[False False] [ True True] [False False]], fill_value=999999) MaskedArray.diagonal(offset=0, axis1=0, axis2=1) Return speciﬁed diagonals. Refer to numpy.diagonal for full documentation. See Also: numpy.diagonal equivalent function MaskedArray.fill(value) Fill the array with a scalar value. Parameters value : scalar All elements of a will be assigned this value. Examples >>> a= np.array([1,2]) >>> a.fill(0) >>> a array([0, 0]) >>> a= np.empty(2) >>> a.fill(1) >>> a array([ 1., 1.]) MaskedArray.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 ﬂat 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 z : Standard Python scalar object A copy of the speciﬁed element of the array as a suitable Python scalar 1.7. Masked arrays 271 NumPy Reference, Release 1.8.1 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 ﬁelds are deﬁned, 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 >>> x= np.random.randint(9, size=(3,3)) >>> x array([[3, 1, 7], [2, 8, 3], [8, 5, 3]]) >>> x.item(3) 2 >>> x.item(7) 5 >>> x.item((0,1)) 1 >>> x.item((2,2)) 3 MaskedArray.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_arrays : tuple Indices of elements that are non-zero. See Also: numpy.nonzero Function operating on ndarrays. flatnonzero Return indices that are non-zero in the ﬂattened version of the input array. ndarray.nonzero Equivalent ndarray method. count_nonzero Counts the number of non-zero elements in the input array. 272 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> 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 ﬁnd 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=999999) >>> 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])) MaskedArray.put(indices, values, mode=’raise’) Set storage-indexed locations to corresponding values. 1.7. Masked arrays 273 NumPy Reference, Release 1.8.1 Sets self._data.ﬂat[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 indices : 1-D array_like Target indices, interpreted as integers. values : array_like Values to place in self._data copy at target indices. mode : {‘raise’, ‘wrap’, ‘clip’}, optional Speciﬁes 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 >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> x.put([0,4,8],[10,20,30]) >>> print x [[10 -- 3] [-- 20 --] [7 -- 30]] >>> x.put(4,999) >>> print x [[10 -- 3] [-- 999 --] [7 -- 30]] MaskedArray.repeat(repeats, axis=None) Repeat elements of an array. Refer to numpy.repeat for full documentation. See Also: numpy.repeat equivalent function MaskedArray.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 See Also: numpy.searchsorted equivalent function 274 Chapter 1. Array objects NumPy Reference, Release 1.8.1 MaskedArray.sort(axis=-1, kind=’quicksort’, order=None, endwith=True, ﬁll_value=None) Sort the array, in-place Parameters a : array_like Array to be sorted. axis : int, optional Axis along which to sort. If None, the array is ﬂattened before sorting. The default is -1, which sorts along the last axis. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional Sorting algorithm. Default is ‘quicksort’. order : list, optional When a is a structured array, this argument speciﬁes which ﬁelds to compare ﬁrst, sec- ond, and so on. This list does not need to include all of the ﬁelds. endwith : {True, False}, optional Whether missing values (if any) should be forced in the upper indices (at the end of the array) (True) or lower indices (at the beginning). ﬁll_value : {var}, optional Value used internally for the masked values. If fill_value is not None, it supersedes endwith. Returns sorted_array : ndarray Array of the same type and shape as a. See Also: ndarray.sort Method to sort an array in-place. argsort Indirect sort. lexsort Indirect stable sort on multiple keys. searchsorted Find elements in a sorted array. Notes See sort for notes on the different sorting algorithms. Examples >>> a= ma.array([1,2,5,4,3],mask=[0,1,0,1,0]) >>> # Default >>> a.sort() >>> print a [1 3 5 -- --] 1.7. Masked arrays 275 NumPy Reference, Release 1.8.1 >>> a= ma.array([1,2,5,4,3],mask=[0,1,0,1,0]) >>> # Put missing values in the front >>> a.sort(endwith=False) >>> print a [-- -- 1 3 5] >>> a= 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) >>> print a [1 -- -- 3 5] MaskedArray.take(indices, axis=None, out=None, mode=’raise’) Pickling and copy MaskedArray.copy([order]) Return a copy of the array. MaskedArray.dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. MaskedArray.dumps() Returns the pickle of the array as a string. MaskedArray.copy(order=’C’) Return a copy of the array. 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 :func:numpy.copy are very similar, but have different default values for their order= arguments.) See Also: numpy.copy, numpy.copyto Examples >>> 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 MaskedArray.dump(ﬁle) Dump a pickle of the array to the speciﬁed ﬁle. The array can be read back with pickle.load or numpy.load. 276 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Parameters ﬁle : str A string naming the dump ﬁle. MaskedArray.dumps() Returns the pickle of the array as a string. pickle.loads or numpy.loads will convert the string back to an array. Parameters None Calculations MaskedArray.all([axis, out]) Check if all of the elements of a are true. MaskedArray.anom([axis, dtype]) Compute the anomalies (deviations from the arithmetic mean) along the given axis. MaskedArray.any([axis, out]) Check if any of the elements of a are true. MaskedArray.clip(a_min, a_max[, out]) Return an array whose values are limited to [a_min, a_max]. MaskedArray.conj() Complex-conjugate all elements. MaskedArray.conjugate() Return the complex conjugate, element-wise. MaskedArray.cumprod([axis, dtype, out]) Return the cumulative product of the elements along the given axis. MaskedArray.cumsum([axis, dtype, out]) Return the cumulative sum of the elements along the given axis. MaskedArray.max([axis, out, ﬁll_value]) Return the maximum along a given axis. MaskedArray.mean([axis, dtype, out]) Returns the average of the array elements. MaskedArray.min([axis, out, ﬁll_value]) Return the minimum along a given axis. MaskedArray.prod([axis, dtype, out]) Return the product of the array elements over the given axis. MaskedArray.product([axis, dtype, out]) Return the product of the array elements over the given axis. MaskedArray.ptp([axis, out, ﬁll_value]) Return (maximum - minimum) along the the given dimension (i.e. MaskedArray.round([decimals, out]) Return a with each element rounded to the given number of decimals. MaskedArray.std([axis, dtype, out, ddof]) Compute the standard deviation along the speciﬁed axis. MaskedArray.sum([axis, dtype, out]) Return the sum of the array elements over the given axis. MaskedArray.trace([offset, axis1, axis2, ...]) Return the sum along diagonals of the array. MaskedArray.var([axis, dtype, out, ddof]) Compute the variance along the speciﬁed axis. MaskedArray.all(axis=None, out=None) Check if all of the elements of a are true. Performs a logical_and over the given axis and returns the result. Masked values are considered as True during computation. For convenience, the output array is masked where ALL the values along the current axis are masked: if the output would have been a scalar and that all the values are masked, then the output is masked. Parameters axis : {None, integer} Axis to perform the operation over. If None, perform over ﬂattened array. 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. See Also: all equivalent function 1.7. Masked arrays 277 NumPy Reference, Release 1.8.1 Examples >>> np.ma.array([1,2,3]).all() True >>> a= np.ma.array([1,2,3], mask=True) >>> (a.all() is np.ma.masked) True MaskedArray.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 axis : int, optional Axis over which the anomalies are taken. The default is to use the mean of the ﬂattened array as reference. dtype : dtype, optional Type to use in computing the variance. For arrays of integer type the default is ﬂoat32; for arrays of ﬂoat types it is the same as the array type. See Also: mean Compute the mean of the array. Examples >>> a= np.ma.array([1,2,3]) >>> a.anom() masked_array(data = [-1. 0. 1.], mask = False, fill_value = 1e+20) MaskedArray.any(axis=None, out=None) Check if any of the elements of a are true. Performs a logical_or over the given axis and returns the result. Masked values are considered as False during computation. Parameters axis : {None, integer} Axis to perform the operation over. If None, perform over ﬂattened array and return a scalar. 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. See Also: any equivalent function 278 Chapter 1. Array objects NumPy Reference, Release 1.8.1 MaskedArray.clip(a_min, a_max, out=None) Return an array whose values are limited to [a_min, a_max]. Refer to numpy.clip for full documentation. See Also: numpy.clip equivalent function MaskedArray.conj() Complex-conjugate all elements. Refer to numpy.conjugate for full documentation. See Also: numpy.conjugate equivalent function MaskedArray.conjugate() Return the complex conjugate, element-wise. Refer to numpy.conjugate for full documentation. See Also: numpy.conjugate equivalent function MaskedArray.cumprod(axis=None, dtype=None, out=None) Return the cumulative product of the elements along the given axis. The cumulative product is taken over the ﬂattened array by default, otherwise over the speciﬁed 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. Parameters axis : {None, -1, int}, optional Axis along which the product is computed. The default (axis = None) is to compute over the ﬂattened array. dtype : {None, dtype}, optional Determines the type of the returned array and of the accumulator where the elements are multiplied. If dtype has the value None and the type of a is an integer type of precision less than the default platform integer, then the default platform integer precision is used. Otherwise, the dtype is the same as that of a. out : ndarray, 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. Returns cumprod : ndarray A new array holding the result is returned unless out is speciﬁed, in which case a refer- ence to out is returned. 1.7. Masked arrays 279 NumPy Reference, Release 1.8.1 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 overﬂow. MaskedArray.cumsum(axis=None, dtype=None, out=None) Return the cumulative sum of the elements along the given axis. The cumulative sum is calculated over the ﬂattened array by default, otherwise over the speciﬁed axis. Masked values are set to 0 internally during the computation. However, their position is saved, and the result will be masked at the same locations. Parameters axis : {None, -1, int}, optional Axis along which the sum is computed. The default (axis = None) is to compute over the ﬂattened array. axis may be negative, in which case it counts from the last to the ﬁrst axis. dtype : {None, dtype}, optional Type of the returned array and of the accumulator in which the elements are summed. If dtype is not speciﬁed, it defaults to the dtype of a, unless a has an integer dtype with a precision less than that of the default platform integer. In that case, the default platform integer is used. out : ndarray, 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. Returns cumsum : ndarray. A new array holding the result is returned unless out is speciﬁed, in which case a reference to out is returned. 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 overﬂow. Examples >>> marr= np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0]) >>> print marr.cumsum() [0 1 3 -- -- -- 9 16 24 33] MaskedArray.max(axis=None, out=None, ﬁll_value=None) Return the maximum along a given axis. Parameters axis : {None, int}, optional Axis along which to operate. By default, axis is None and the ﬂattened input is used. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. ﬁll_value : {var}, optional 280 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Value used to ﬁll in the masked values. If None, use the output of maxi- mum_ﬁll_value(). Returns amax : array_like New array holding the result. If out was speciﬁed, out is returned. See Also: maximum_fill_value Returns the maximum ﬁlling value for a given datatype. MaskedArray.mean(axis=None, dtype=None, out=None) Returns the average of the array elements. Masked entries are ignored. The average is taken over the ﬂattened array by default, otherwise over the speciﬁed axis. Refer to numpy.mean for the full documentation. Parameters a : array_like Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted. axis : int, optional Axis along which the means are computed. The default is to compute the mean of the ﬂattened array. dtype : dtype, optional Type to use in computing the mean. For integer inputs, the default is ﬂoat64; for ﬂoating point, inputs it is the same as the input dtype. out : 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 mean : ndarray, see dtype parameter above If out=None, returns a new array containing the mean values, otherwise a reference to the output array is returned. See Also: numpy.ma.mean Equivalent function. numpy.mean Equivalent function on non-masked arrays. numpy.ma.average Weighted average. Examples >>> a= np.ma.array([1,2,3], mask=[False, False, True]) >>> a masked_array(data = [1 2 --], mask = [False False True], 1.7. Masked arrays 281 NumPy Reference, Release 1.8.1 fill_value = 999999) >>> a.mean() 1.5 MaskedArray.min(axis=None, out=None, ﬁll_value=None) Return the minimum along a given axis. Parameters axis : {None, int}, optional Axis along which to operate. By default, axis is None and the ﬂattened input is used. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. ﬁll_value : {var}, optional Value used to ﬁll in the masked values. If None, use the output of minimum_fill_value. Returns amin : array_like New array holding the result. If out was speciﬁed, out is returned. See Also: minimum_fill_value Returns the minimum ﬁlling value for a given datatype. MaskedArray.prod(axis=None, dtype=None, out=None) Return the product of the array elements over the given axis. Masked elements are set to 1 internally for computation. Parameters axis : {None, int}, optional Axis over which the product is taken. If None is used, then the product is over all the array elements. dtype : {None, dtype}, optional Determines the type of the returned array and of the accumulator where the elements are multiplied. If dtype has the value None and the type of a is an integer type of precision less than the default platform integer, then the default platform integer precision is used. Otherwise, the dtype is the same as that of a. out : {None, array}, 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 product_along_axis : {array, scalar}, see dtype parameter above. Returns an array whose shape is the same as a with the speciﬁed axis removed. Returns a 0d array when a is 1d or axis=None. Returns a reference to the speciﬁed output array if speciﬁed. See Also: 282 Chapter 1. Array objects NumPy Reference, Release 1.8.1 prod equivalent function Notes Arithmetic is modular when using integer types, and no error is raised on overﬂow. Examples >>> np.prod([1.,2.]) 2.0 >>> np.prod([1.,2.], dtype=np.int32) 2 >>> np.prod([[1.,2.],[3.,4.]]) 24.0 >>> np.prod([[1.,2.],[3.,4.]], axis=1) array([ 2., 12.]) MaskedArray.product(axis=None, dtype=None, out=None) Return the product of the array elements over the given axis. Masked elements are set to 1 internally for computation. Parameters axis : {None, int}, optional Axis over which the product is taken. If None is used, then the product is over all the array elements. dtype : {None, dtype}, optional Determines the type of the returned array and of the accumulator where the elements are multiplied. If dtype has the value None and the type of a is an integer type of precision less than the default platform integer, then the default platform integer precision is used. Otherwise, the dtype is the same as that of a. out : {None, array}, 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 product_along_axis : {array, scalar}, see dtype parameter above. Returns an array whose shape is the same as a with the speciﬁed axis removed. Returns a 0d array when a is 1d or axis=None. Returns a reference to the speciﬁed output array if speciﬁed. See Also: prod equivalent function Notes Arithmetic is modular when using integer types, and no error is raised on overﬂow. Examples >>> np.prod([1.,2.]) 2.0 >>> np.prod([1.,2.], dtype=np.int32) 1.7. Masked arrays 283 NumPy Reference, Release 1.8.1 2 >>> np.prod([[1.,2.],[3.,4.]]) 24.0 >>> np.prod([[1.,2.],[3.,4.]], axis=1) array([ 2., 12.]) MaskedArray.ptp(axis=None, out=None, ﬁll_value=None) Return (maximum - minimum) along the the given dimension (i.e. peak-to-peak value). Parameters axis : {None, int}, optional Axis along which to ﬁnd the peaks. If None (default) the ﬂattened 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. ﬁll_value : {var}, optional Value used to ﬁll in the masked values. Returns ptp : ndarray. A new array holding the result, unless out was speciﬁed, in which case a reference to out is returned. MaskedArray.round(decimals=0, out=None) Return a with each element rounded to the given number of decimals. Refer to numpy.around for full documentation. See Also: numpy.around equivalent function MaskedArray.std(axis=None, dtype=None, out=None, ddof=0) Compute the standard deviation along the speciﬁed axis. Returns the standard deviation, a measure of the spread of a distribution, of the array elements. The standard deviation is computed for the ﬂattened array by default, otherwise over the speciﬁed axis. Parameters a : array_like Calculate the standard deviation of these values. axis : int, optional Axis along which the standard deviation is computed. The default is to compute the standard deviation of the ﬂattened array. dtype : dtype, optional Type to use in computing the standard deviation. For arrays of integer type the default is ﬂoat64, for arrays of ﬂoat types it is the same as the array type. out : ndarray, optional Alternative output array in which to place the result. It must have the same shape as the expected output but the type (of the calculated values) will be cast if necessary. 284 Chapter 1. Array objects NumPy Reference, Release 1.8.1 ddof : int, optional Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero. keepdims : bool, 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 original arr. Returns standard_deviation : ndarray, see dtype parameter above. If out is None, return a new array containing the standard deviation, otherwise return a reference to the output array. See Also: var, mean, nanmean, nanstd, nanvar numpy.doc.ufuncs Section “Output arguments” Notes The standard deviation is the square root of the average of the squared deviations from the mean, i.e., std = sqrt(mean(abs(x - x.mean())**2)). The average squared deviation is normally calculated as x.sum() / N, where N = len(x). If, however, ddof is speciﬁed, the divisor N - ddof is used instead. In standard statistical practice, ddof=1 provides an unbiased estimator of the variance of the inﬁnite population. ddof=0 provides a maximum likelihood estimate of the variance for normally distributed variables. The standard deviation computed in this function is the square root of the estimated variance, so even with ddof=1, it will not be an unbiased estimate of the standard deviation per se. Note that, for complex numbers, std takes the absolute value before squaring, so that the result is always real and nonnegative. For ﬂoating-point input, the std is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for ﬂoat32 (see example below). Specifying a higher- accuracy accumulator using the dtype keyword can alleviate this issue. Examples >>> a= np.array([[1,2], [3,4]]) >>> np.std(a) 1.1180339887498949 >>> np.std(a, axis=0) array([ 1., 1.]) >>> np.std(a, axis=1) array([ 0.5, 0.5]) In single precision, std() can be inaccurate: >>> a= np.zeros((2,512 *512), dtype=np.float32) >>> a[0,:]= 1.0 >>> a[1,:]= 0.1 >>> np.std(a) 0.45172946707416706 Computing the standard deviation in ﬂoat64 is more accurate: 1.7. Masked arrays 285 NumPy Reference, Release 1.8.1 >>> np.std(a, dtype=np.float64) 0.44999999925552653 MaskedArray.sum(axis=None, dtype=None, out=None) Return the sum of the array elements over the given axis. Masked elements are set to 0 internally. Parameters axis : {None, -1, int}, optional Axis along which the sum is computed. The default (axis = None) is to compute over the ﬂattened array. dtype : {None, dtype}, optional Determines the type of the returned array and of the accumulator where the elements are summed. If dtype has the value None and the type of a is an integer type of precision less than the default platform integer, then the default platform integer precision is used. Otherwise, the dtype is the same as that of a. out : {None, ndarray}, 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. Returns sum_along_axis : MaskedArray or scalar An array with the same shape as self, with the speciﬁed axis removed. If self is a 0-d array, or if axis is None, a scalar is returned. If an output array is speciﬁed, a reference to out is returned. Examples >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> print x.sum() 25 >>> print x.sum(axis=1) [4 5 16] >>> print x.sum(axis=0) [8 5 12] >>> print type(x.sum(axis=0, dtype=np.int64)[0]) MaskedArray.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. See Also: numpy.trace equivalent function MaskedArray.var(axis=None, dtype=None, out=None, ddof=0) Compute the variance along the speciﬁed axis. 286 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the ﬂattened array by default, otherwise over the speciﬁed axis. Parameters a : array_like Array containing numbers whose variance is desired. If a is not an array, a conversion is attempted. axis : int, optional Axis along which the variance is computed. The default is to compute the variance of the ﬂattened array. dtype : data-type, optional Type to use in computing the variance. For arrays of integer type the default is ﬂoat32; for arrays of ﬂoat types it is the same as the array type. out : ndarray, 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, 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. keepdims : bool, 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 original arr. Returns variance : ndarray, see dtype parameter above If out=None, returns a new array containing the variance; otherwise, a reference to the output array is returned. See Also: std, mean, nanmean, nanstd, nanvar numpy.doc.ufuncs Section “Output arguments” Notes The variance is the average of the squared deviations from the mean, i.e., var = mean(abs(x - x.mean())**2). The mean is normally calculated as x.sum() / N, where N = len(x). If, however, ddof is speciﬁed, the divisor N - ddof is used instead. In standard statistical practice, ddof=1 provides an unbiased estimator of the variance of a hypothetical inﬁnite population. ddof=0 provides a maximum likelihood estimate of the variance for normally distributed variables. Note that for complex numbers, the absolute value is taken before squaring, so that the result is always real and nonnegative. For ﬂoating-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 ﬂoat32 (see example below). Specifying a higher-accuracy accumulator using the dtype keyword can alleviate this issue. 1.7. Masked arrays 287 NumPy Reference, Release 1.8.1 Examples >>> 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) 0.20405951142311096 Computing the variance in ﬂoat64 is more accurate: >>> np.var(a, dtype=np.float64) 0.20249999932997387 >>> ((1-0.55)**2+(0.1-0.55)**2)/2 0.20250000000000001 Arithmetic and comparison operations Comparison operators: MaskedArray.__lt__ x.__lt__(y) <==> x x<=y MaskedArray.__gt__ x.__gt__(y) <==> x>y MaskedArray.__ge__ x.__ge__(y) <==> x>=y MaskedArray.__eq__(other) Check whether other equals self elementwise MaskedArray.__ne__(other) Check whether other doesn’t equal self elementwise MaskedArray.__lt__ x.__lt__(y) <==> x x<=y MaskedArray.__gt__ x.__gt__(y) <==> x>y MaskedArray.__ge__ x.__ge__(y) <==> x>=y MaskedArray.__eq__(other) Check whether other equals self elementwise MaskedArray.__ne__(other) Check whether other doesn’t equal self elementwise Truth value of an array (bool): MaskedArray.__nonzero__ x.__nonzero__() <==> x != 0 288 Chapter 1. Array objects NumPy Reference, Release 1.8.1 MaskedArray.__nonzero__ x.__nonzero__() <==> x != 0 Arithmetic: MaskedArray.__abs__() <==> abs(x) MaskedArray.__add__(other) Add other to self, and return a new masked array. MaskedArray.__radd__(other) Add other to self, and return a new masked array. MaskedArray.__sub__(other) Subtract other to self, and return a new masked array. MaskedArray.__rsub__(other) Subtract other to self, and return a new masked array. MaskedArray.__mul__(other) Multiply other by self, and return a new masked array. MaskedArray.__rmul__(other) Multiply other by self, and return a new masked array. MaskedArray.__div__(other) Divide other into self, and return a new masked array. MaskedArray.__rdiv__ x.__rdiv__(y) <==> y/x MaskedArray.__truediv__(other) Divide other into self, and return a new masked array. MaskedArray.__rtruediv__(other) Divide other into self, and return a new masked array. MaskedArray.__floordiv__(other) Divide other into self, and return a new masked array. MaskedArray.__rfloordiv__(other) Divide other into self, and return a new masked array. MaskedArray.__mod__ x.__mod__(y) <==> x%y MaskedArray.__rmod__ x.__rmod__(y) <==> y%x MaskedArray.__divmod__(y) <==> divmod(x, y) MaskedArray.__rdivmod__(y) <==> divmod(y, x) MaskedArray.__pow__(other) Raise self to the power other, masking the potential NaNs/Infs MaskedArray.__rpow__(other) Raise self to the power other, masking the potential NaNs/Infs MaskedArray.__lshift__ x.__lshift__(y) <==> x< y< x>>y MaskedArray.__rrshift__ x.__rrshift__(y) <==> y>>x MaskedArray.__and__ x.__and__(y) <==> x&y MaskedArray.__rand__ x.__rand__(y) <==> y&x MaskedArray.__or__ x.__or__(y) <==> x|y MaskedArray.__ror__ x.__ror__(y) <==> y|x MaskedArray.__xor__ x.__xor__(y) <==> x^y MaskedArray.__rxor__ x.__rxor__(y) <==> y^x MaskedArray.__abs__() <==> abs(x) MaskedArray.__add__(other) Add other to self, and return a new masked array. MaskedArray.__radd__(other) Add other to self, and return a new masked array. MaskedArray.__sub__(other) Subtract other to self, and return a new masked array. MaskedArray.__rsub__(other) Subtract other to self, and return a new masked array. MaskedArray.__mul__(other) Multiply other by self, and return a new masked array. MaskedArray.__rmul__(other) Multiply other by self, and return a new masked array. 1.7. Masked arrays 289 NumPy Reference, Release 1.8.1 MaskedArray.__div__(other) Divide other into self, and return a new masked array. MaskedArray.__rdiv__ x.__rdiv__(y) <==> y/x MaskedArray.__truediv__(other) Divide other into self, and return a new masked array. MaskedArray.__rtruediv__(other) Divide other into self, and return a new masked array. MaskedArray.__floordiv__(other) Divide other into self, and return a new masked array. MaskedArray.__rfloordiv__(other) Divide other into self, and return a new masked array. MaskedArray.__mod__ x.__mod__(y) <==> x%y MaskedArray.__rmod__ x.__rmod__(y) <==> y%x MaskedArray.__divmod__(y) <==> divmod(x, y) MaskedArray.__rdivmod__(y) <==> divmod(y, x) MaskedArray.__pow__(other) Raise self to the power other, masking the potential NaNs/Infs MaskedArray.__rpow__(other) Raise self to the power other, masking the potential NaNs/Infs MaskedArray.__lshift__ x.__lshift__(y) <==> x< y< x>>y MaskedArray.__rrshift__ x.__rrshift__(y) <==> y>>x MaskedArray.__and__ x.__and__(y) <==> x&y MaskedArray.__rand__ x.__rand__(y) <==> y&x MaskedArray.__or__ x.__or__(y) <==> x|y MaskedArray.__ror__ x.__ror__(y) <==> y|x MaskedArray.__xor__ x.__xor__(y) <==> x^y 290 Chapter 1. Array objects NumPy Reference, Release 1.8.1 MaskedArray.__rxor__ x.__rxor__(y) <==> y^x Arithmetic, in-place: MaskedArray.__iadd__(other) Add other to self in-place. MaskedArray.__isub__(other) Subtract other from self in-place. MaskedArray.__imul__(other) Multiply self by other in-place. MaskedArray.__idiv__(other) Divide self by other in-place. MaskedArray.__itruediv__(other) True divide self by other in-place. MaskedArray.__ifloordiv__(other) Floor divide self by other in-place. MaskedArray.__imod__ x.__imod__(y) <==> x%=y MaskedArray.__ipow__(other) Raise self to the power other, in place. MaskedArray.__ilshift__ x.__ilshift__(y) <==> x<<=y MaskedArray.__irshift__ x.__irshift__(y) <==> x>>=y MaskedArray.__iand__ x.__iand__(y) <==> x&=y MaskedArray.__ior__ x.__ior__(y) <==> x|=y MaskedArray.__ixor__ x.__ixor__(y) <==> x^=y MaskedArray.__iadd__(other) Add other to self in-place. MaskedArray.__isub__(other) Subtract other from self in-place. MaskedArray.__imul__(other) Multiply self by other in-place. MaskedArray.__idiv__(other) Divide self by other in-place. MaskedArray.__itruediv__(other) True divide self by other in-place. MaskedArray.__ifloordiv__(other) Floor divide self by other in-place. MaskedArray.__imod__ x.__imod__(y) <==> x%=y MaskedArray.__ipow__(other) Raise self to the power other, in place. MaskedArray.__ilshift__ x.__ilshift__(y) <==> x<<=y MaskedArray.__irshift__ x.__irshift__(y) <==> x>>=y MaskedArray.__iand__ x.__iand__(y) <==> x&=y MaskedArray.__ior__ x.__ior__(y) <==> x|=y MaskedArray.__ixor__ x.__ixor__(y) <==> x^=y 1.7. Masked arrays 291 NumPy Reference, Release 1.8.1 Representation MaskedArray.__repr__() Literal string representation. MaskedArray.__str__() String representation. MaskedArray.ids() Return the addresses of the data and mask areas. MaskedArray.iscontiguous() Return a boolean indicating whether the data is contiguous. MaskedArray.__repr__() Literal string representation. MaskedArray.__str__() String representation. MaskedArray.ids() Return the addresses of the data and mask areas. Parameters None Examples >>> x= np.ma.array([1,2,3], mask=[0,1,1]) >>> x.ids() (166670640, 166659832) 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, 3083169284L) MaskedArray.iscontiguous() Return a boolean indicating whether the data is contiguous. Parameters None Examples >>> x= np.ma.array([1,2,3]) >>> x.iscontiguous() True iscontiguous returns one of the ﬂags of the masked array: >>> x.flags C_CONTIGUOUS : True F_CONTIGUOUS : True OWNDATA : False WRITEABLE : True ALIGNED : True UPDATEIFCOPY : False Special methods For standard library functions: 292 Chapter 1. Array objects NumPy Reference, Release 1.8.1 MaskedArray.__copy__([order]) Return a copy of the array. MaskedArray.__deepcopy__([memo]) MaskedArray.__getstate__() Return the internal state of the masked array, for pickling MaskedArray.__reduce__() Return a 3-tuple for pickling a MaskedArray. MaskedArray.__setstate__(state) Restore the internal state of the masked array, for pickling purposes. MaskedArray.__copy__([order ]) Return a copy of the array. Parameters order : {‘C’, ‘F’, ‘A’}, optional If order is ‘C’ (False) then the result is contiguous (default). If order is ‘Fortran’ (True) then the result has fortran order. If order is ‘Any’ (None) then the result has fortran order only if the array already is in fortran order. MaskedArray.__deepcopy__(memo=None) MaskedArray.__getstate__() Return the internal state of the masked array, for pickling purposes. MaskedArray.__reduce__() Return a 3-tuple for pickling a MaskedArray. MaskedArray.__setstate__(state) Restore the internal state of the masked array, for pickling purposes. state is typically the output of the __getstate__ output, and is a 5-tuple: •class name •a tuple giving the shape of the data •a typecode for the data •a binary string for the data •a binary string for the mask. Basic customization: MaskedArray.__new__([data, mask, dtype, ...]) Create a new masked array from scratch. MaskedArray.__array__(...) Returns either a new reference to self if dtype is not given or a new array MaskedArray.__array_wrap__(obj[, context]) Special hook for ufuncs. static MaskedArray.__new__(data=None, mask=False, dtype=None, copy=False, subok=True, ndmin=0, ﬁll_value=None, keep_mask=True, hard_mask=None, shrink=True,**options) Create a new masked array from scratch. Notes A masked array can also be created by taking a .view(MaskedArray). MaskedArray.__array__(|dtype) → reference if type unchanged, copy otherwise. Returns either a new reference to self if dtype is not given or a new array of provided data type if dtype is different from the current dtype of the array. MaskedArray.__array_wrap__(obj, context=None) 1.7. Masked arrays 293 NumPy Reference, Release 1.8.1 Special hook for ufuncs. Wraps the numpy array and sets the mask according to context. Container customization: (see Indexing) MaskedArray.__len__() <==> len(x) MaskedArray.__getitem__(indx) x.__getitem__(y) <==> x[y] MaskedArray.__setitem__(indx, value) x.__setitem__(i, y) <==> x[i]=y MaskedArray.__delitem__ x.__delitem__(y) <==> del x[y] MaskedArray.__getslice__(i, j) x.__getslice__(i, j) <==> x[i:j] MaskedArray.__setslice__(i, j, value) x.__setslice__(i, j, value) <==> x[i:j]=value MaskedArray.__contains__ x.__contains__(y) <==> y in x MaskedArray.__len__() <==> len(x) MaskedArray.__getitem__(indx) x.__getitem__(y) <==> x[y] Return the item described by i, as a masked array. MaskedArray.__setitem__(indx, value) x.__setitem__(i, y) <==> x[i]=y Set item described by index. If value is masked, masks those locations. MaskedArray.__delitem__ x.__delitem__(y) <==> del x[y] MaskedArray.__getslice__(i, j) x.__getslice__(i, j) <==> x[i:j] Return the slice described by (i, j). The use of negative indices is not supported. MaskedArray.__setslice__(i, j, value) x.__setslice__(i, j, value) <==> x[i:j]=value Set the slice (i,j) of a to value. If value is masked, mask those locations. MaskedArray.__contains__ x.__contains__(y) <==> y in x Speciﬁc methods Handling the mask The following methods can be used to access information about the mask or to manipulate the mask. MaskedArray.__setmask__(mask[, copy]) Set the mask. MaskedArray.harden_mask() Force the mask to hard. MaskedArray.soften_mask() Force the mask to soft. MaskedArray.unshare_mask() Copy the mask and set the sharedmask ﬂag to False. MaskedArray.shrink_mask() Reduce a mask to nomask when possible. MaskedArray.__setmask__(mask, copy=False) Set the mask. MaskedArray.harden_mask() Force the mask to hard. 294 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Whether the mask of a masked array is hard or soft is determined by its hardmask property. harden_mask sets hardmask to True. See Also: hardmask MaskedArray.soften_mask() Force the mask to soft. Whether the mask of a masked array is hard or soft is determined by its hardmask property. soften_mask sets hardmask to False. See Also: hardmask MaskedArray.unshare_mask() Copy the mask and set the sharedmask ﬂag 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. See Also: sharedmask MaskedArray.shrink_mask() Reduce a mask to nomask when possible. Parameters None Returns None Examples >>> x= np.ma.array([[1,2],[3,4]], mask=[0]*4) >>> x.mask array([[False, False], [False, False]], dtype=bool) >>> x.shrink_mask() >>> x.mask False Handling the ﬁll_value MaskedArray.get_fill_value() Return the ﬁlling value of the masked array. MaskedArray.set_fill_value([value]) Set the ﬁlling value of the masked array. MaskedArray.get_fill_value() Return the ﬁlling value of the masked array. Returns ﬁll_value : scalar The ﬁlling value. 1.7. Masked arrays 295 NumPy Reference, Release 1.8.1 Examples >>> for dt in [np.int32, np.int64, np.float64, np.complex128]: ... np.ma.array([0,1], dtype=dt).get_fill_value() ... 999999 999999 1e+20 (1e+20+0j) >>> x= np.ma.array([0, 1.], fill_value=-np.inf) >>> x.get_fill_value() -inf MaskedArray.set_fill_value(value=None) Set the ﬁlling value of the masked array. Parameters value : scalar, optional The new ﬁlling value. Default is None, in which case a default based on the data type is used. See Also: ma.set_fill_value Equivalent function. Examples >>> x= np.ma.array([0, 1.], fill_value=-np.inf) >>> x.fill_value -inf >>> x.set_fill_value(np.pi) >>> x.fill_value 3.1415926535897931 Reset to default: >>> x.set_fill_value() >>> x.fill_value 1e+20 Counting the missing elements MaskedArray.count([axis]) Count the non-masked elements of the array along the given axis. MaskedArray.count(axis=None) Count the non-masked elements of the array along the given axis. Parameters axis : int, optional Axis along which to count the non-masked elements. If axis is None, all non-masked elements are counted. Returns result : int or ndarray 296 Chapter 1. Array objects NumPy Reference, Release 1.8.1 If axis is None, an integer count is returned. When axis is not None, an array with shape determined by the lengths of the remaining axes, is returned. See Also: count_masked Count masked elements in array or along a given axis. 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 speciﬁed an array of appropriate size is returned. >>> a.count(axis=0) array([1, 1, 1]) >>> a.count(axis=1) array([3, 0]) 1.7.7 Masked array operations Constants ma.MaskType Numpy’s Boolean type. Character code: ?. Alias: bool8 numpy.ma.MaskType alias of bool_ Creation From existing data ma.masked_array An array class with possibly masked values. ma.array(data[, dtype, copy, order, mask, ...]) An array class with possibly masked values. ma.copy copy ma.frombuffer(buffer[, dtype, count, offset]) Interpret a buffer as a 1-dimensional array. ma.fromfunction(function, shape, **kwargs) Construct an array by executing a function over each coordinate. ma.MaskedArray.copy([order]) Return a copy of the array. 1.7. Masked arrays 297 NumPy Reference, Release 1.8.1 numpy.ma.masked_array alias of MaskedArray numpy.ma.array(data, dtype=None, copy=False, order=False, mask=False, ﬁll_value=None, keep_mask=True, hard_mask=False, shrink=True, subok=True, ndmin=0) An array class with possibly masked values. Masked values of True exclude the corresponding element from any computation. Construction: x= MaskedArray(data, mask=nomask, dtype=None, copy=False, subok=True, ndmin=0, fill_value=None, keep_mask=True, hard_mask=None, shrink=True) Parameters data : array_like Input data. mask : sequence, optional Mask. Must be convertible to an array of booleans with the same shape as data. True indicates a masked (i.e. invalid) data. dtype : dtype, optional Data type of the output. If dtype is None, the type of the data argument (data.dtype) is used. If dtype is not None and different from data.dtype, a copy is performed. copy : bool, optional Whether to copy the input data (True), or to use a reference instead. Default is False. subok : bool, optional Whether to return a subclass of MaskedArray if possible (True) or a plain MaskedArray. Default is True. ndmin : int, optional Minimum number of dimensions. Default is 0. ﬁll_value : scalar, optional Value used to ﬁll in the masked values when necessary. If None, a default based on the data-type is used. keep_mask : bool, optional Whether to combine mask with the mask of the input data, if any (True), or to use only mask for the output (False). Default is True. hard_mask : bool, optional Whether to use a hard mask or not. With a hard mask, masked values cannot be un- masked. Default is False. shrink : bool, optional Whether to force compression of an empty mask. Default is True. numpy.ma.copy = copy a.copy(order=’C’) Return a copy of the array. 298 Chapter 1. Array objects NumPy Reference, Release 1.8.1 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 :func:numpy.copy are very similar, but have different default values for their order= arguments.) Examples >>> 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 numpy.ma.frombuffer(buffer, dtype=ﬂoat, count=-1, offset=0) = Interpret a buffer as a 1-dimensional array. Parameters buffer : buffer_like An object that exposes the buffer interface. dtype : data-type, optional Data-type of the returned array; default: ﬂoat. count : int, optional Number of items to read. -1 means all data in the buffer. offset : int, optional Start reading the buffer from this offset; default: 0. Notes If the buffer has data that is not in machine byte-order, this should be speciﬁed as part of the data-type, e.g.: >>> dt= np.dtype(int) >>> dt= dt.newbyteorder(’>’) >>> np.frombuffer(buf, dtype=dt) The data of the resulting array will not be byteswapped, but will be interpreted correctly. Examples 1.7. Masked arrays 299 NumPy Reference, Release 1.8.1 >>> s=’hello world’ >>> np.frombuffer(s, dtype=’S1’, count=5, offset=6) array([’w’, ’o’, ’r’, ’l’, ’d’], dtype=’|S1’) numpy.ma.fromfunction(function, shape,**kwargs) = Construct an array by executing a function over each coordinate. The resulting array therefore has a value fn(x, y, z) at coordinate (x, y, z). Parameters function : callable The function is called with N parameters, where N is the rank of shape. Each param- eter represents the coordinates of the array varying along a speciﬁc axis. For example, if shape were (2, 2), then the parameters in turn be (0, 0), (0, 1), (1, 0), (1, 1). shape : (N,) tuple of ints Shape of the output array, which also determines the shape of the coordinate arrays passed to function. dtype : data-type, optional Data-type of the coordinate arrays passed to function. By default, dtype is ﬂoat. Returns fromfunction : any The result of the call to function is passed back directly. Therefore the shape of fromfunction is completely determined by function. If function returns a scalar value, the shape of fromfunction would match the shape parameter. See Also: indices, meshgrid Notes Keywords other than dtype are passed to function. Examples >>> np.fromfunction(lambda i, j: i == j, (3,3), dtype=int) array([[ True, False, False], [False, True, False], [False, False, True]], dtype=bool) >>> np.fromfunction(lambda i, j: i+ j, (3,3), dtype=int) array([[0, 1, 2], [1, 2, 3], [2, 3, 4]]) MaskedArray.copy(order=’C’) Return a copy of the array. 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 300 Chapter 1. Array objects NumPy Reference, Release 1.8.1 closely as possible. (Note that this function and :func:numpy.copy are very similar, but have different default values for their order= arguments.) See Also: numpy.copy, numpy.copyto Examples >>> 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 Ones and zeros ma.empty(shape[, dtype, order]) Return a new array of given shape and type, without initializing entries. ma.empty_like(a[, dtype, order, subok]) Return a new array with the same shape and type as a given array. ma.masked_all(shape[, dtype]) Empty masked array with all elements masked. ma.masked_all_like(arr) Empty masked array with the properties of an existing array. ma.ones(shape[, dtype, order]) Return a new array of given shape and type, ﬁlled with ones. ma.zeros(shape[, dtype, order]) Return a new array of given shape and type, ﬁlled with zeros. numpy.ma.empty(shape, dtype=ﬂoat, order=’C’) = Return a new array of given shape and type, without initializing entries. Parameters shape : int or tuple of int Shape of the empty array dtype : data-type, optional Desired output data-type. order : {‘C’, ‘F’}, optional Whether to store multi-dimensional data in C (row-major) or Fortran (column-major) order in memory. See Also: empty_like, zeros, ones Notes empty, unlike zeros, does not set the array values to zero, and may therefore be marginally faster. On the other hand, it requires the user to manually set all the values in the array, and should be used with caution. 1.7. Masked arrays 301 NumPy Reference, Release 1.8.1 Examples >>> np.empty([2,2]) array([[ -9.74499359e+001, 6.69583040e-309], [ 2.13182611e-314, 3.06959433e-309]]) #random >>> np.empty([2,2], dtype=int) array([[-1073741821, -1067949133], [ 496041986, 19249760]]) #random numpy.ma.empty_like(a, dtype=None, order=’K’, subok=True) = Return a new array with the same shape and type as a given array. Parameters a : array_like The shape and data-type of a deﬁne these same attributes of the returned array. dtype : data-type, optional New in version 1.6.0. Overrides the data type of the result. order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional New in version 1.6.0. Overrides the memory layout of the result. ‘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. subok : bool, optional. If True, then the newly created array will use the sub-class type of ‘a’, otherwise it will be a base-class array. Defaults to True. Returns out : ndarray Array of uninitialized (arbitrary) data with the same shape and type as a. See Also: ones_like Return an array of ones with shape and type of input. zeros_like Return an array of zeros with shape and type of input. empty Return a new uninitialized array. ones Return a new array setting values to one. zeros Return a new array setting values to zero. Notes This function does not initialize the returned array; to do that use zeros_like or ones_like instead. It may be marginally faster than the functions that do set the array values. 302 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> a=([1,2,3], [4,5,6]) # a is array-like >>> np.empty_like(a) array([[-1073741821, -1073741821, 3], #random [ 0, 0, -1073741821]]) >>> a= np.array([[1., 2., 3.],[4.,5.,6.]]) >>> np.empty_like(a) array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000],#random [ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]]) numpy.ma.masked_all(shape, dtype=) Empty masked array with all elements masked. Return an empty masked array of the given shape and dtype, where all the data are masked. Parameters shape : tuple Shape of the required MaskedArray. dtype : dtype, optional Data type of the output. Returns a : MaskedArray A masked array with all data masked. See Also: masked_all_like Empty masked array modelled on an existing array. Examples >>> import numpy.ma as ma >>> ma.masked_all((3,3)) masked_array(data = [[-- -- --] [-- -- --] [-- -- --]], mask = [[ True True True] [ True True True] [ True True True]], fill_value=1e+20) The dtype parameter deﬁnes the underlying data type. >>> a= ma.masked_all((3,3)) >>> a.dtype dtype(’float64’) >>> a= ma.masked_all((3,3), dtype=np.int32) >>> a.dtype dtype(’int32’) numpy.ma.masked_all_like(arr) Empty masked array with the properties of an existing array. Return an empty masked array of the same shape and dtype as the array arr, where all the data are masked. 1.7. Masked arrays 303 NumPy Reference, Release 1.8.1 Parameters arr : ndarray An array describing the shape and dtype of the required MaskedArray. Returns a : MaskedArray A masked array with all data masked. Raises AttributeError If arr doesn’t have a shape attribute (i.e. not an ndarray) See Also: masked_all Empty masked array with all elements masked. Examples >>> import numpy.ma as ma >>> arr= np.zeros((2,3), dtype=np.float32) >>> arr array([[ 0., 0., 0.], [ 0., 0., 0.]], dtype=float32) >>> ma.masked_all_like(arr) masked_array(data = [[-- -- --] [-- -- --]], mask = [[ True True True] [ True True True]], fill_value=1e+20) The dtype of the masked array matches the dtype of arr. >>> arr.dtype dtype(’float32’) >>> ma.masked_all_like(arr).dtype dtype(’float32’) numpy.ma.ones(shape, dtype=None, order=’C’) = Return a new array of given shape and type, ﬁlled with ones. Parameters shape : int or sequence of ints Shape of the new array, e.g., (2, 3) or 2. dtype : data-type, optional The desired data-type for the array, e.g., numpy.int8. Default is numpy.float64. order : {‘C’, ‘F’}, optional Whether to store multidimensional data in C- or Fortran-contiguous (row- or column- wise) order in memory. Returns out : ndarray 304 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Array of ones with the given shape, dtype, and order. See Also: zeros, ones_like Examples >>> np.ones(5) array([ 1., 1., 1., 1., 1.]) >>> np.ones((5,), dtype=np.int) array([1, 1, 1, 1, 1]) >>> np.ones((2,1)) array([[ 1.], [ 1.]]) >>> s=(2,2) >>> np.ones(s) array([[ 1., 1.], [ 1., 1.]]) numpy.ma.zeros(shape, dtype=ﬂoat, order=’C’) = Return a new array of given shape and type, ﬁlled with zeros. Parameters shape : int or sequence of ints Shape of the new array, e.g., (2, 3) or 2. dtype : data-type, optional The desired data-type for the array, e.g., numpy.int8. Default is numpy.float64. order : {‘C’, ‘F’}, optional Whether to store multidimensional data in C- or Fortran-contiguous (row- or column- wise) order in memory. Returns out : ndarray Array of zeros with the given shape, dtype, and order. See Also: zeros_like Return an array of zeros with shape and type of input. ones_like Return an array of ones with shape and type of input. empty_like Return an empty array with shape and type of input. ones Return a new array setting values to one. empty Return a new uninitialized array. 1.7. Masked arrays 305 NumPy Reference, Release 1.8.1 Examples >>> np.zeros(5) array([ 0., 0., 0., 0., 0.]) >>> np.zeros((5,), dtype=numpy.int) array([0, 0, 0, 0, 0]) >>> np.zeros((2,1)) array([[ 0.], [ 0.]]) >>> s=(2,2) >>> np.zeros(s) array([[ 0., 0.], [ 0., 0.]]) >>> np.zeros((2,), dtype=[(’x’,’i4’), (’y’,’i4’)]) # custom dtype array([(0, 0), (0, 0)], dtype=[(’x’, ’ Check if all of the elements of a are true. Performs a logical_and over the given axis and returns the result. Masked values are considered as True during computation. For convenience, the output array is masked where ALL the values along the current axis are masked: if the output would have been a scalar and that all the values are masked, then the output is masked. Parameters axis : {None, integer} 306 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Axis to perform the operation over. If None, perform over ﬂattened array. 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. See Also: all equivalent function Examples >>> np.ma.array([1,2,3]).all() True >>> a= np.ma.array([1,2,3], mask=True) >>> (a.all() is np.ma.masked) True numpy.ma.any(self, axis=None, out=None) = Check if any of the elements of a are true. Performs a logical_or over the given axis and returns the result. Masked values are considered as False during computation. Parameters axis : {None, integer} Axis to perform the operation over. If None, perform over ﬂattened array and return a scalar. 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. See Also: any equivalent function numpy.ma.count(a, axis=None) Count the non-masked elements of the array along the given axis. Parameters axis : int, optional Axis along which to count the non-masked elements. If axis is None, all non-masked elements are counted. Returns result : int or ndarray If axis is None, an integer count is returned. When axis is not None, an array with shape determined by the lengths of the remaining axes, is returned. See Also: count_masked Count masked elements in array or along a given axis. 1.7. Masked arrays 307 NumPy Reference, Release 1.8.1 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 speciﬁed an array of appropriate size is returned. >>> a.count(axis=0) array([1, 1, 1]) >>> a.count(axis=1) array([3, 0]) numpy.ma.count_masked(arr, axis=None) Count the number of masked elements along the given axis. Parameters arr : array_like An array with (possibly) masked elements. axis : int, optional Axis along which to count. If None (default), a ﬂattened version of the array is used. Returns count : int, ndarray The total number of masked elements (axis=None) or the number of masked elements along each slice of the given axis. See Also: MaskedArray.count Count non-masked elements. Examples >>> import numpy.ma as ma >>> a= np.arange(9).reshape((3,3)) >>> a= ma.array(a) >>> a[1,0]= ma.masked >>> a[1,2]= ma.masked >>> a[2,1]= ma.masked >>> a masked_array(data = [[0 1 2] [-- 4 --] [6 -- 8]], mask = [[False False False] 308 Chapter 1. Array objects NumPy Reference, Release 1.8.1 [ True False True] [False True False]], fill_value=999999) >>> ma.count_masked(a) 3 When the axis keyword is used an array is returned. >>> ma.count_masked(a, axis=0) array([1, 1, 1]) >>> ma.count_masked(a, axis=1) array([0, 2, 1]) numpy.ma.getmask(a) Return the mask of a masked array, or nomask. Return the mask of a as an ndarray if a is a MaskedArray and the mask is not nomask, else return nomask. To guarantee a full array of booleans of the same shape as a, use getmaskarray. Parameters a : array_like Input MaskedArray for which the mask is required. See Also: getdata Return the data of a masked array as an ndarray. getmaskarray Return the mask of a masked array, or full array of False. Examples >>> import numpy.ma as ma >>> a= ma.masked_equal([[1,2],[3,4]],2) >>> a masked_array(data = [[1 --] [3 4]], mask = [[False True] [False False]], fill_value=999999) >>> ma.getmask(a) array([[False, True], [False, False]], dtype=bool) Equivalently use the MaskedArray mask attribute. >>> a.mask array([[False, True], [False, False]], dtype=bool) Result when mask == nomask >>> b= ma.masked_array([[1,2],[3,4]]) >>> b masked_array(data = [[1 2] 1.7. Masked arrays 309 NumPy Reference, Release 1.8.1 [3 4]], mask = False, fill_value=999999) >>> ma.nomask False >>> ma.getmask(b) == ma.nomask True >>> b.mask == ma.nomask True numpy.ma.getmaskarray(arr) Return the mask of a masked array, or full boolean array of False. Return the mask of arr as an ndarray if arr is a MaskedArray and the mask is not nomask, else return a full boolean array of False of the same shape as arr. Parameters arr : array_like Input MaskedArray for which the mask is required. See Also: getmask Return the mask of a masked array, or nomask. getdata Return the data of a masked array as an ndarray. Examples >>> import numpy.ma as ma >>> a= ma.masked_equal([[1,2],[3,4]],2) >>> a masked_array(data = [[1 --] [3 4]], mask = [[False True] [False False]], fill_value=999999) >>> ma.getmaskarray(a) array([[False, True], [False, False]], dtype=bool) Result when mask == nomask >>> b= ma.masked_array([[1,2],[3,4]]) >>> b masked_array(data = [[1 2] [3 4]], mask = False, fill_value=999999) >>> >ma.getmaskarray(b) array([[False, False], [False, False]], dtype=bool) 310 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.ma.getdata(a, subok=True) Return the data of a masked array as an ndarray. Return the data of a (if any) as an ndarray if a is a MaskedArray, else return a as a ndarray or subclass (depending on subok) if not. Parameters a : array_like Input MaskedArray, alternatively a ndarray or a subclass thereof. subok : bool Whether to force the output to be a pure ndarray (False) or to return a subclass of ndarray if appropriate (True, default). See Also: getmask Return the mask of a masked array, or nomask. getmaskarray Return the mask of a masked array, or full array of False. Examples >>> import numpy.ma as ma >>> a= ma.masked_equal([[1,2],[3,4]],2) >>> a masked_array(data = [[1 --] [3 4]], mask = [[False True] [False False]], fill_value=999999) >>> ma.getdata(a) array([[1, 2], [3, 4]]) Equivalently use the MaskedArray data attribute. >>> a.data array([[1, 2], [3, 4]]) numpy.ma.nonzero(self) = 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 1.7. Masked arrays 311 NumPy Reference, Release 1.8.1 Returns tuple_of_arrays : tuple Indices of elements that are non-zero. See Also: numpy.nonzero Function operating on ndarrays. flatnonzero Return indices that are non-zero in the ﬂattened version of the input array. ndarray.nonzero Equivalent ndarray method. count_nonzero Counts the number of non-zero elements in the input array. Examples >>> 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 ﬁnd 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. 312 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> 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=999999) >>> 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])) numpy.ma.shape(obj) Return the shape of an array. Parameters a : array_like Input array. Returns shape : tuple of ints The elements of the shape tuple give the lengths of the corresponding array dimensions. See Also: alen ndarray.shape Equivalent array method. Examples >>> np.shape(np.eye(3)) (3, 3) >>> np.shape([[1,2]]) (1, 2) >>> np.shape([0]) (1,) >>> np.shape(0) () >>> a= np.array([(1,2), (3,4)], dtype=[(’x’,’i4’), (’y’,’i4’)]) >>> np.shape(a) (2,) >>> a.shape (2,) numpy.ma.size(obj, axis=None) Return the number of elements along a given axis. Parameters a : array_like Input data. 1.7. Masked arrays 313 NumPy Reference, Release 1.8.1 axis : int, optional Axis along which the elements are counted. By default, give the total number of ele- ments. Returns element_count : int Number of elements along the speciﬁed axis. See Also: shape dimensions of array ndarray.shape dimensions of array ndarray.size number of elements in array Examples >>> a= np.array([[1,2,3],[4,5,6]]) >>> np.size(a) 6 >>> np.size(a,1) 3 >>> np.size(a,0) 2 MaskedArray.data Return the current data, as a view of the original underlying data. MaskedArray.mask Mask MaskedArray.recordmask Return the mask of the records. A record is masked when all the ﬁelds are masked. MaskedArray.all(axis=None, out=None) Check if all of the elements of a are true. Performs a logical_and over the given axis and returns the result. Masked values are considered as True during computation. For convenience, the output array is masked where ALL the values along the current axis are masked: if the output would have been a scalar and that all the values are masked, then the output is masked. Parameters axis : {None, integer} Axis to perform the operation over. If None, perform over ﬂattened array. 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. See Also: all equivalent function 314 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> np.ma.array([1,2,3]).all() True >>> a= np.ma.array([1,2,3], mask=True) >>> (a.all() is np.ma.masked) True MaskedArray.any(axis=None, out=None) Check if any of the elements of a are true. Performs a logical_or over the given axis and returns the result. Masked values are considered as False during computation. Parameters axis : {None, integer} Axis to perform the operation over. If None, perform over ﬂattened array and return a scalar. 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. See Also: any equivalent function MaskedArray.count(axis=None) Count the non-masked elements of the array along the given axis. Parameters axis : int, optional Axis along which to count the non-masked elements. If axis is None, all non-masked elements are counted. Returns result : int or ndarray If axis is None, an integer count is returned. When axis is not None, an array with shape determined by the lengths of the remaining axes, is returned. See Also: count_masked Count masked elements in array or along a given axis. 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] 1.7. Masked arrays 315 NumPy Reference, Release 1.8.1 [ True True True]], fill_value = 999999) >>> a.count() 3 When the axis keyword is speciﬁed an array of appropriate size is returned. >>> a.count(axis=0) array([1, 1, 1]) >>> a.count(axis=1) array([3, 0]) MaskedArray.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_arrays : tuple Indices of elements that are non-zero. See Also: numpy.nonzero Function operating on ndarrays. flatnonzero Return indices that are non-zero in the ﬂattened version of the input array. ndarray.nonzero Equivalent ndarray method. count_nonzero Counts the number of non-zero elements in the input array. Examples >>> 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) 316 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> 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 ﬁnd 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=999999) >>> 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])) numpy.ma.shape(obj) Return the shape of an array. Parameters a : array_like Input array. Returns shape : tuple of ints The elements of the shape tuple give the lengths of the corresponding array dimensions. See Also: alen 1.7. Masked arrays 317 NumPy Reference, Release 1.8.1 ndarray.shape Equivalent array method. Examples >>> np.shape(np.eye(3)) (3, 3) >>> np.shape([[1,2]]) (1, 2) >>> np.shape([0]) (1,) >>> np.shape(0) () >>> a= np.array([(1,2), (3,4)], dtype=[(’x’,’i4’), (’y’,’i4’)]) >>> np.shape(a) (2,) >>> a.shape (2,) numpy.ma.size(obj, axis=None) Return the number of elements along a given axis. Parameters a : array_like Input data. axis : int, optional Axis along which the elements are counted. By default, give the total number of ele- ments. Returns element_count : int Number of elements along the speciﬁed axis. See Also: shape dimensions of array ndarray.shape dimensions of array ndarray.size number of elements in array Examples >>> a= np.array([[1,2,3],[4,5,6]]) >>> np.size(a) 6 >>> np.size(a,1) 3 >>> np.size(a,0) 2 318 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Manipulating a MaskedArray Changing the shape ma.ravel(self) Returns a 1D version of self, as a view. ma.reshape(a, new_shape[, order]) Returns an array containing the same data with a new shape. ma.resize(x, new_shape) Return a new masked array with the speciﬁed size and shape. ma.MaskedArray.flatten([order]) Return a copy of the array collapsed into one dimension. ma.MaskedArray.ravel() Returns a 1D version of self, as a view. ma.MaskedArray.reshape(*s, **kwargs) Give a new shape to the array without changing its data. ma.MaskedArray.resize(newshape[, refcheck, ...]) numpy.ma.ravel(self) = Returns a 1D version of self, as a view. Returns MaskedArray Output view is of shape (self.size,) (or (np.ma.product(self.shape),)). Examples >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> print x.ravel() [1 -- 3 -- 5 -- 7 -- 9] numpy.ma.reshape(a, new_shape, order=’C’) Returns an array containing the same data with a new shape. Refer to MaskedArray.reshape for full documentation. See Also: MaskedArray.reshape equivalent function numpy.ma.resize(x, new_shape) Return a new masked array with the speciﬁed size and shape. This is the masked equivalent of the numpy.resize function. The new array is ﬁlled with repeated copies of x (in the order that the data are stored in memory). If x is masked, the new array will be masked, and the new mask will be a repetition of the old one. See Also: numpy.resize Equivalent function in the top level NumPy module. Examples 1.7. Masked arrays 319 NumPy Reference, Release 1.8.1 >>> import numpy.ma as ma >>> a= ma.array([[1,2] ,[3,4]]) >>> a[0,1]= ma.masked >>> a masked_array(data = [[1 --] [3 4]], mask = [[False True] [False False]], fill_value = 999999) >>> np.resize(a, (3,3)) array([[1, 2, 3], [4, 1, 2], [3, 4, 1]]) >>> ma.resize(a, (3,3)) masked_array(data = [[1 -- 3] [4 1 --] [3 4 1]], mask = [[False True False] [False False True] [False False False]], fill_value = 999999) A MaskedArray is always returned, regardless of the input type. >>> a= np.array([[1,2] ,[3,4]]) >>> ma.resize(a, (3,3)) masked_array(data = [[1 2 3] [4 1 2] [3 4 1]], mask = False, fill_value = 999999) MaskedArray.flatten(order=’C’) Return a copy of the array collapsed into one dimension. Parameters order : {‘C’, ‘F’, ‘A’}, optional Whether to ﬂatten in C (row-major), Fortran (column-major) order, or preserve the C/Fortran ordering from a. The default is ‘C’. Returns y : ndarray A copy of the input array, ﬂattened to one dimension. See Also: ravel Return a ﬂattened array. flat A 1-D ﬂat iterator over the array. 320 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> a= np.array([[1,2], [3,4]]) >>> a.flatten() array([1, 2, 3, 4]) >>> a.flatten(’F’) array([1, 3, 2, 4]) MaskedArray.ravel() Returns a 1D version of self, as a view. Returns MaskedArray Output view is of shape (self.size,) (or (np.ma.product(self.shape),)). Examples >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> print x.ravel() [1 -- 3 -- 5 -- 7 -- 9] MaskedArray.reshape(*s,**kwargs) Give a new shape to the array without changing its data. Returns a masked array containing the same data, but with a new shape. The result is a view on the original array; if this is not possible, a ValueError is raised. Parameters shape : int 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_array : array A new view on the array. See Also: reshape Equivalent function in the masked array module. numpy.ndarray.reshape Equivalent method on ndarray object. numpy.reshape Equivalent function in the NumPy module. 1.7. Masked arrays 321 NumPy Reference, Release 1.8.1 Notes The reshaping operation cannot guarantee that a copy will not be made, to modify the shape in place, use a.shape = s Examples >>> x= np.ma.array([[1,2],[3,4]], mask=[1,0,0,1]) >>> print x [[-- 2] [3 --]] >>> x=x.reshape((4,1)) >>> print x [[--] [2] [3] [--]] MaskedArray.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 difﬁcult to implement safely and may be deprecated in future releases of NumPy. Modifying axes ma.swapaxes swapaxes ma.transpose(a[, axes]) Permute the dimensions of an array. ma.MaskedArray.swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. ma.MaskedArray.transpose(*axes) Returns a view of the array with axes transposed. numpy.ma.swapaxes = swapaxes a.swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. Refer to numpy.swapaxes for full documentation. See Also: numpy.swapaxes equivalent function numpy.ma.transpose(a, axes=None) Permute the dimensions of an array. This function is exactly equivalent to numpy.transpose. See Also: numpy.transpose Equivalent function in top-level NumPy module. Examples >>> import numpy.ma as ma >>> x= ma.arange(4).reshape((2,2)) 322 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> x[1,1]= ma.masked >>>> x masked_array(data = [[0 1] [2 --]], mask = [[False False] [False True]], fill_value = 999999) >>> ma.transpose(x) masked_array(data = [[0 2] [1 --]], mask = [[False False] [False True]], fill_value = 999999) MaskedArray.swapaxes(axis1, axis2) Return a view of the array with axis1 and axis2 interchanged. Refer to numpy.swapaxes for full documentation. See Also: numpy.swapaxes equivalent function MaskedArray.transpose(*axes) Returns a view of the array with axes transposed. For a 1-D array, this has no effect. (To change between column and row vectors, ﬁrst cast the 1-D array into a ma- trix object.) For a 2-D array, this is the usual matrix transpose. For an n-D array, if axes are given, their order in- dicates how the axes are permuted (see Examples). If axes are not provided and a.shape = (i[0], i[1], ... i[n-2], i[n-1]), then a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0]). 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 a‘s i-th axis becomes a.transpose()‘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 out : ndarray View of a, with axes suitably permuted. See Also: ndarray.T Array property returning the array transposed. 1.7. Masked arrays 323 NumPy Reference, Release 1.8.1 Examples >>> 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]]) Changing the number of dimensions ma.atleast_1d(*arys) Convert inputs to arrays with at least one dimension. ma.atleast_2d(*arys) View inputs as arrays with at least two dimensions. ma.atleast_3d(*arys) View inputs as arrays with at least three dimensions. ma.expand_dims(x, axis) Expand the shape of an array. ma.squeeze(a[, axis]) Remove single-dimensional entries from the shape of an array. ma.MaskedArray.squeeze([axis]) Remove single-dimensional entries from the shape of a. ma.column_stack(tup) Stack 1-D arrays as columns into a 2-D array. ma.concatenate(arrays[, axis]) Concatenate a sequence of arrays along the given axis. ma.dstack(tup) Stack arrays in sequence depth wise (along third axis). ma.hstack(tup) Stack arrays in sequence horizontally (column wise). ma.hsplit(ary, indices_or_sections) Split an array into multiple sub-arrays horizontally (column-wise). ma.mr_ Translate slice objects to concatenation along the ﬁrst axis. ma.row_stack(tup) Stack arrays in sequence vertically (row wise). ma.vstack(tup) Stack arrays in sequence vertically (row wise). numpy.ma.atleast_1d(*arys) = Convert inputs to arrays with at least one dimension. Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved. Parameters arys1, arys2, ... : array_like One or more input arrays. Returns ret : ndarray An array, or sequence of arrays, each with a.ndim >= 1. Copies are made only if necessary. Notes The function is applied to both the _data and the _mask, if any. 324 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> np.atleast_1d(1.0) array([ 1.]) >>> x= np.arange(9.0).reshape(3,3) >>> np.atleast_1d(x) array([[ 0., 1., 2.], [ 3., 4., 5.], [ 6., 7., 8.]]) >>> np.atleast_1d(x) is x True >>> np.atleast_1d(1,[3,4]) [array([1]), array([3, 4])] numpy.ma.atleast_2d(*arys) = View inputs as arrays with at least two dimensions. Parameters arys1, arys2, ... : array_like One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have two or more dimensions are preserved. Returns res, res2, ... : ndarray An array, or tuple of arrays, each with a.ndim >= 2. Copies are avoided where possible, and views with two or more dimensions are returned. Notes The function is applied to both the _data and the _mask, if any. Examples >>> np.atleast_2d(3.0) array([[ 3.]]) >>> x= np.arange(3.0) >>> np.atleast_2d(x) array([[ 0., 1., 2.]]) >>> np.atleast_2d(x).base is x True >>> np.atleast_2d(1,[1,2], [[1,2]]) [array([[1]]), array([[1, 2]]), array([[1, 2]])] numpy.ma.atleast_3d(*arys) = View inputs as arrays with at least three dimensions. Parameters arys1, arys2, ... : array_like One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have three or more dimensions are preserved. 1.7. Masked arrays 325 NumPy Reference, Release 1.8.1 Returns res1, res2, ... : ndarray An array, or tuple of arrays, each with a.ndim >= 3. Copies are avoided where possible, and views with three or more dimensions are returned. For example, a 1-D array of shape (N,) becomes a view of shape (1, N, 1), and a 2-D array of shape (M, N) becomes a view of shape (M, N, 1). Notes The function is applied to both the _data and the _mask, if any. Examples >>> np.atleast_3d(3.0) array([[[ 3.]]]) >>> x= np.arange(3.0) >>> np.atleast_3d(x).shape (1, 3, 1) >>> x= np.arange(12.0).reshape(4,3) >>> np.atleast_3d(x).shape (4, 3, 1) >>> np.atleast_3d(x).base is x True >>> for arr in np.atleast_3d([1,2], [[1,2]], [[[1,2]]]): ... print arr, arr.shape ... [[[1] [2]]] (1, 2, 1) [[[1] [2]]] (1, 2, 1) [[[1 2]]] (1, 1, 2) numpy.ma.expand_dims(x, axis) Expand the shape of an array. Expands the shape of the array by including a new axis before the one speciﬁed by the axis parameter. This function behaves the same as numpy.expand_dims but preserves masked elements. See Also: numpy.expand_dims Equivalent function in top-level NumPy module. Examples >>> import numpy.ma as ma >>> x= ma.array([1,2,4]) >>> x[1]= ma.masked >>> x masked_array(data = [1 -- 4], mask = [False True False], fill_value = 999999) >>> np.expand_dims(x, axis=0) array([[1, 2, 4]]) >>> ma.expand_dims(x, axis=0) 326 Chapter 1. Array objects NumPy Reference, Release 1.8.1 masked_array(data = [[1 -- 4]], mask = [[False True False]], fill_value = 999999) The same result can be achieved using slicing syntax with np.newaxis. >>> x[np.newaxis, :] masked_array(data = [[1 -- 4]], mask = [[False True False]], fill_value = 999999) numpy.ma.squeeze(a, axis=None) Remove single-dimensional entries from the shape of an array. Parameters a : array_like Input data. axis : None or int or tuple of ints, optional New in version 1.7.0. Selects a subset of the single-dimensional entries in the shape. If an axis is selected with shape entry greater than one, an error is raised. Returns squeezed : ndarray The input array, but with with all or a subset of the dimensions of length 1 removed. This is always a itself or a view into a. Examples >>> x= np.array([[[0], [1], [2]]]) >>> x.shape (1, 3, 1) >>> np.squeeze(x).shape (3,) >>> np.squeeze(x, axis=(2,)).shape (1, 3) MaskedArray.squeeze(axis=None) Remove single-dimensional entries from the shape of a. Refer to numpy.squeeze for full documentation. See Also: numpy.squeeze equivalent function numpy.ma.column_stack(tup) = Stack 1-D arrays as columns into a 2-D array. Take a sequence of 1-D arrays and stack them as columns to make a single 2-D array. 2-D arrays are stacked as-is, just like with hstack. 1-D arrays are turned into 2-D columns ﬁrst. 1.7. Masked arrays 327 NumPy Reference, Release 1.8.1 Parameters tup : sequence of 1-D or 2-D arrays. Arrays to stack. All of them must have the same ﬁrst dimension. Returns stacked : 2-D array The array formed by stacking the given arrays. Notes The function is applied to both the _data and the _mask, if any. Examples >>> a= np.array((1,2,3)) >>> b= np.array((2,3,4)) >>> np.column_stack((a,b)) array([[1, 2], [2, 3], [3, 4]]) numpy.ma.concatenate(arrays, axis=0) Concatenate a sequence of arrays along the given axis. Parameters arrays : sequence of array_like The arrays must have the same shape, except in the dimension corresponding to axis (the ﬁrst, by default). axis : int, optional The axis along which the arrays will be joined. Default is 0. Returns result : MaskedArray The concatenated array with any masked entries preserved. See Also: numpy.concatenate Equivalent function in the top-level NumPy module. Examples >>> import numpy.ma as ma >>> a= ma.arange(3) >>> a[1]= ma.masked >>> b= ma.arange(2,5) >>> a masked_array(data = [0 -- 2], mask = [False True False], fill_value = 999999) >>> b masked_array(data = [2 3 4], mask = False, fill_value = 999999) >>> ma.concatenate([a, b]) masked_array(data = [0 -- 2 2 3 4], 328 Chapter 1. Array objects NumPy Reference, Release 1.8.1 mask = [False True False False False False], fill_value = 999999) numpy.ma.dstack(tup) = Stack arrays in sequence depth wise (along third axis). Takes a sequence of arrays and stack them along the third axis to make a single array. Rebuilds arrays divided by dsplit. This is a simple way to stack 2D arrays (images) into a single 3D array for processing. Parameters tup : sequence of arrays Arrays to stack. All of them must have the same shape along all but the third axis. Returns stacked : ndarray The array formed by stacking the given arrays. See Also: vstack Stack along ﬁrst axis. hstack Stack along second axis. concatenate Join arrays. dsplit Split array along third axis. Notes The function is applied to both the _data and the _mask, if any. Examples >>> a= np.array((1,2,3)) >>> b= np.array((2,3,4)) >>> np.dstack((a,b)) array([[[1, 2], [2, 3], [3, 4]]]) >>> a= np.array([[1],[2],[3]]) >>> b= np.array([[2],[3],[4]]) >>> np.dstack((a,b)) array([[[1, 2]], [[2, 3]], [[3, 4]]]) numpy.ma.hstack(tup) = 1.7. Masked arrays 329 NumPy Reference, Release 1.8.1 Stack arrays in sequence horizontally (column wise). Take a sequence of arrays and stack them horizontally to make a single array. Rebuild arrays divided by hsplit. Parameters tup : sequence of ndarrays All arrays must have the same shape along all but the second axis. Returns stacked : ndarray The array formed by stacking the given arrays. See Also: vstack Stack arrays in sequence vertically (row wise). dstack Stack arrays in sequence depth wise (along third axis). concatenate Join a sequence of arrays together. hsplit Split array along second axis. Notes The function is applied to both the _data and the _mask, if any. Examples >>> a= np.array((1,2,3)) >>> b= np.array((2,3,4)) >>> np.hstack((a,b)) array([1, 2, 3, 2, 3, 4]) >>> a= np.array([[1],[2],[3]]) >>> b= np.array([[2],[3],[4]]) >>> np.hstack((a,b)) array([[1, 2], [2, 3], [3, 4]]) numpy.ma.hsplit(ary, indices_or_sections) = Split an array into multiple sub-arrays horizontally (column-wise). Please refer to the split documentation. hsplit is equivalent to split with axis=1, the array is always split along the second axis regardless of the array dimension. See Also: split Split an array into multiple sub-arrays of equal size. 330 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Notes The function is applied to both the _data and the _mask, if any. Examples >>> x= np.arange(16.0).reshape(4,4) >>> x array([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.], [ 12., 13., 14., 15.]]) >>> np.hsplit(x,2) [array([[ 0., 1.], [ 4., 5.], [ 8., 9.], [ 12., 13.]]), array([[ 2., 3.], [ 6., 7.], [ 10., 11.], [ 14., 15.]])] >>> np.hsplit(x, np.array([3,6])) [array([[ 0., 1., 2.], [ 4., 5., 6.], [ 8., 9., 10.], [ 12., 13., 14.]]), array([[ 3.], [ 7.], [ 11.], [ 15.]]), array([], dtype=float64)] With a higher dimensional array the split is still along the second axis. >>> x= np.arange(8.0).reshape(2,2,2) >>> x array([[[ 0., 1.], [ 2., 3.]], [[ 4., 5.], [ 6., 7.]]]) >>> np.hsplit(x,2) [array([[[ 0., 1.]], [[ 4., 5.]]]), array([[[ 2., 3.]], [[ 6., 7.]]])] numpy.ma.mr_ = Translate slice objects to concatenation along the ﬁrst axis. This is the masked array version of lib.index_tricks.RClass. See Also: lib.index_tricks.RClass Examples >>> np.ma.mr_[np.ma.array([1,2,3]),0,0, np.ma.array([4,5,6])] array([1, 2, 3, 0, 0, 4, 5, 6]) 1.7. Masked arrays 331 NumPy Reference, Release 1.8.1 numpy.ma.row_stack(tup) = Stack arrays in sequence vertically (row wise). Take a sequence of arrays and stack them vertically to make a single array. Rebuild arrays divided by vsplit. Parameters tup : sequence of ndarrays Tuple containing arrays to be stacked. The arrays must have the same shape along all but the ﬁrst axis. Returns stacked : ndarray The array formed by stacking the given arrays. See Also: hstack Stack arrays in sequence horizontally (column wise). dstack Stack arrays in sequence depth wise (along third dimension). concatenate Join a sequence of arrays together. vsplit Split array into a list of multiple sub-arrays vertically. Notes The function is applied to both the _data and the _mask, if any. Examples >>> a= np.array([1,2,3]) >>> b= np.array([2,3,4]) >>> np.vstack((a,b)) array([[1, 2, 3], [2, 3, 4]]) >>> a= np.array([[1], [2], [3]]) >>> b= np.array([[2], [3], [4]]) >>> np.vstack((a,b)) array([[1], [2], [3], [2], [3], [4]]) numpy.ma.vstack(tup) = Stack arrays in sequence vertically (row wise). 332 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Take a sequence of arrays and stack them vertically to make a single array. Rebuild arrays divided by vsplit. Parameters tup : sequence of ndarrays Tuple containing arrays to be stacked. The arrays must have the same shape along all but the ﬁrst axis. Returns stacked : ndarray The array formed by stacking the given arrays. See Also: hstack Stack arrays in sequence horizontally (column wise). dstack Stack arrays in sequence depth wise (along third dimension). concatenate Join a sequence of arrays together. vsplit Split array into a list of multiple sub-arrays vertically. Notes The function is applied to both the _data and the _mask, if any. Examples >>> a= np.array([1,2,3]) >>> b= np.array([2,3,4]) >>> np.vstack((a,b)) array([[1, 2, 3], [2, 3, 4]]) >>> a= np.array([[1], [2], [3]]) >>> b= np.array([[2], [3], [4]]) >>> np.vstack((a,b)) array([[1], [2], [3], [2], [3], [4]]) Joining arrays ma.column_stack(tup) Stack 1-D arrays as columns into a 2-D array. ma.concatenate(arrays[, axis]) Concatenate a sequence of arrays along the given axis. ma.dstack(tup) Stack arrays in sequence depth wise (along third axis). ma.hstack(tup) Stack arrays in sequence horizontally (column wise). ma.vstack(tup) Stack arrays in sequence vertically (row wise). 1.7. Masked arrays 333 NumPy Reference, Release 1.8.1 numpy.ma.column_stack(tup) = Stack 1-D arrays as columns into a 2-D array. Take a sequence of 1-D arrays and stack them as columns to make a single 2-D array. 2-D arrays are stacked as-is, just like with hstack. 1-D arrays are turned into 2-D columns ﬁrst. Parameters tup : sequence of 1-D or 2-D arrays. Arrays to stack. All of them must have the same ﬁrst dimension. Returns stacked : 2-D array The array formed by stacking the given arrays. Notes The function is applied to both the _data and the _mask, if any. Examples >>> a= np.array((1,2,3)) >>> b= np.array((2,3,4)) >>> np.column_stack((a,b)) array([[1, 2], [2, 3], [3, 4]]) numpy.ma.concatenate(arrays, axis=0) Concatenate a sequence of arrays along the given axis. Parameters arrays : sequence of array_like The arrays must have the same shape, except in the dimension corresponding to axis (the ﬁrst, by default). axis : int, optional The axis along which the arrays will be joined. Default is 0. Returns result : MaskedArray The concatenated array with any masked entries preserved. See Also: numpy.concatenate Equivalent function in the top-level NumPy module. Examples >>> import numpy.ma as ma >>> a= ma.arange(3) >>> a[1]= ma.masked >>> b= ma.arange(2,5) >>> a masked_array(data = [0 -- 2], 334 Chapter 1. Array objects NumPy Reference, Release 1.8.1 mask = [False True False], fill_value = 999999) >>> b masked_array(data = [2 3 4], mask = False, fill_value = 999999) >>> ma.concatenate([a, b]) masked_array(data = [0 -- 2 2 3 4], mask = [False True False False False False], fill_value = 999999) numpy.ma.dstack(tup) = Stack arrays in sequence depth wise (along third axis). Takes a sequence of arrays and stack them along the third axis to make a single array. Rebuilds arrays divided by dsplit. This is a simple way to stack 2D arrays (images) into a single 3D array for processing. Parameters tup : sequence of arrays Arrays to stack. All of them must have the same shape along all but the third axis. Returns stacked : ndarray The array formed by stacking the given arrays. See Also: vstack Stack along ﬁrst axis. hstack Stack along second axis. concatenate Join arrays. dsplit Split array along third axis. Notes The function is applied to both the _data and the _mask, if any. Examples >>> a= np.array((1,2,3)) >>> b= np.array((2,3,4)) >>> np.dstack((a,b)) array([[[1, 2], [2, 3], [3, 4]]]) >>> a= np.array([[1],[2],[3]]) >>> b= np.array([[2],[3],[4]]) >>> np.dstack((a,b)) 1.7. Masked arrays 335 NumPy Reference, Release 1.8.1 array([[[1, 2]], [[2, 3]], [[3, 4]]]) numpy.ma.hstack(tup) = Stack arrays in sequence horizontally (column wise). Take a sequence of arrays and stack them horizontally to make a single array. Rebuild arrays divided by hsplit. Parameters tup : sequence of ndarrays All arrays must have the same shape along all but the second axis. Returns stacked : ndarray The array formed by stacking the given arrays. See Also: vstack Stack arrays in sequence vertically (row wise). dstack Stack arrays in sequence depth wise (along third axis). concatenate Join a sequence of arrays together. hsplit Split array along second axis. Notes The function is applied to both the _data and the _mask, if any. Examples >>> a= np.array((1,2,3)) >>> b= np.array((2,3,4)) >>> np.hstack((a,b)) array([1, 2, 3, 2, 3, 4]) >>> a= np.array([[1],[2],[3]]) >>> b= np.array([[2],[3],[4]]) >>> np.hstack((a,b)) array([[1, 2], [2, 3], [3, 4]]) numpy.ma.vstack(tup) = Stack arrays in sequence vertically (row wise). Take a sequence of arrays and stack them vertically to make a single array. Rebuild arrays divided by vsplit. 336 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Parameters tup : sequence of ndarrays Tuple containing arrays to be stacked. The arrays must have the same shape along all but the ﬁrst axis. Returns stacked : ndarray The array formed by stacking the given arrays. See Also: hstack Stack arrays in sequence horizontally (column wise). dstack Stack arrays in sequence depth wise (along third dimension). concatenate Join a sequence of arrays together. vsplit Split array into a list of multiple sub-arrays vertically. Notes The function is applied to both the _data and the _mask, if any. Examples >>> a= np.array([1,2,3]) >>> b= np.array([2,3,4]) >>> np.vstack((a,b)) array([[1, 2, 3], [2, 3, 4]]) >>> a= np.array([[1], [2], [3]]) >>> b= np.array([[2], [3], [4]]) >>> np.vstack((a,b)) array([[1], [2], [3], [2], [3], [4]]) Operations on masks Creating a mask ma.make_mask(m[, copy, shrink, dtype]) Create a boolean mask from an array. ma.make_mask_none(newshape[, dtype]) Return a boolean mask of the given shape, ﬁlled with False. ma.mask_or(m1, m2[, copy, shrink]) Combine two masks with the logical_or operator. ma.make_mask_descr(ndtype) Construct a dtype description list from a given dtype. 1.7. Masked arrays 337 NumPy Reference, Release 1.8.1 numpy.ma.make_mask(m, copy=False, shrink=True, dtype=) Create a boolean mask from an array. Return m as a boolean mask, creating a copy if necessary or requested. The function can accept any sequence that is convertible to integers, or nomask. Does not require that contents must be 0s and 1s, values of 0 are interepreted as False, everything else as True. Parameters m : array_like Potential mask. copy : bool, optional Whether to return a copy of m (True) or m itself (False). shrink : bool, optional Whether to shrink m to nomask if all its values are False. dtype : dtype, optional Data-type of the output mask. By default, the output mask has a dtype of MaskType (bool). If the dtype is ﬂexible, each ﬁeld has a boolean dtype. Returns result : ndarray A boolean mask derived from m. Examples >>> import numpy.ma as ma >>> m=[True, False, True, True] >>> ma.make_mask(m) array([ True, False, True, True], dtype=bool) >>> m=[1,0,1,1] >>> ma.make_mask(m) array([ True, False, True, True], dtype=bool) >>> m=[1,0,2,-3] >>> ma.make_mask(m) array([ True, False, True, True], dtype=bool) Effect of the shrink parameter. >>> m= np.zeros(4) >>> m array([ 0., 0., 0., 0.]) >>> ma.make_mask(m) False >>> ma.make_mask(m, shrink=False) array([False, False, False, False], dtype=bool) Using a ﬂexible dtype. >>> m=[1,0,1,1] >>> n=[0,1,0,0] >>> arr=[] >>> for man, mouse in zip(m, n): ... arr.append((man, mouse)) >>> arr [(1, 0), (0, 1), (1, 0), (1, 0)] >>> dtype= np.dtype({’names’:[’man’,’mouse’], 338 Chapter 1. Array objects NumPy Reference, Release 1.8.1 ’formats’:[np.int, np.int]}) >>> arr= np.array(arr, dtype=dtype) >>> arr array([(1, 0), (0, 1), (1, 0), (1, 0)], dtype=[(’man’, ’>> ma.make_mask(arr, dtype=dtype) array([(True, False), (False, True), (True, False), (True, False)], dtype=[(’man’, ’|b1’), (’mouse’, ’|b1’)]) numpy.ma.make_mask_none(newshape, dtype=None) Return a boolean mask of the given shape, ﬁlled with False. This function returns a boolean ndarray with all entries False, that can be used in common mask manipulations. If a complex dtype is speciﬁed, the type of each ﬁeld is converted to a boolean type. Parameters newshape : tuple A tuple indicating the shape of the mask. dtype : {None, dtype}, optional If None, use a MaskType instance. Otherwise, use a new datatype with the same ﬁelds as dtype, converted to boolean types. Returns result : ndarray An ndarray of appropriate shape and dtype, ﬁlled with False. See Also: make_mask Create a boolean mask from an array. make_mask_descr Construct a dtype description list from a given dtype. Examples >>> import numpy.ma as ma >>> ma.make_mask_none((3,)) array([False, False, False], dtype=bool) Deﬁning a more complex dtype. >>> dtype= np.dtype({’names’:[’foo’,’bar’], ’formats’:[np.float32, np.int]}) >>> dtype dtype([(’foo’, ’>> ma.make_mask_none((3,), dtype=dtype) array([(False, False), (False, False), (False, False)], dtype=[(’foo’, ’|b1’), (’bar’, ’|b1’)]) numpy.ma.mask_or(m1, m2, copy=False, shrink=True) Combine two masks with the logical_or operator. The result may be a view on m1 or m2 if the other is nomask (i.e. False). Parameters m1, m2 : array_like 1.7. Masked arrays 339 NumPy Reference, Release 1.8.1 Input masks. copy : bool, optional If copy is False and one of the inputs is nomask, return a view of the other input mask. Defaults to False. shrink : bool, optional Whether to shrink the output to nomask if all its values are False. Defaults to True. Returns mask : output mask The result masks values that are masked in either m1 or m2. Raises ValueError If m1 and m2 have different ﬂexible dtypes. Examples >>> m1= np.ma.make_mask([0,1,1,0]) >>> m2= np.ma.make_mask([1,0,0,0]) >>> np.ma.mask_or(m1, m2) array([ True, True, True, False], dtype=bool) numpy.ma.make_mask_descr(ndtype) Construct a dtype description list from a given dtype. Returns a new dtype object, with the type of all ﬁelds in ndtype to a boolean type. Field names are not altered. Parameters ndtype : dtype The dtype to convert. Returns result : dtype A dtype that looks like ndtype, the type of all ﬁelds is boolean. Examples >>> import numpy.ma as ma >>> dtype= np.dtype({’names’:[’foo’,’bar’], ’formats’:[np.float32, np.int]}) >>> dtype dtype([(’foo’, ’>> ma.make_mask_descr(dtype) dtype([(’foo’, ’|b1’), (’bar’, ’|b1’)]) >>> ma.make_mask_descr(np.float32) Accessing a mask ma.getmask(a) Return the mask of a masked array, or nomask. ma.getmaskarray(arr) Return the mask of a masked array, or full boolean array of False. ma.masked_array.mask Mask 340 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.ma.getmask(a) Return the mask of a masked array, or nomask. Return the mask of a as an ndarray if a is a MaskedArray and the mask is not nomask, else return nomask. To guarantee a full array of booleans of the same shape as a, use getmaskarray. Parameters a : array_like Input MaskedArray for which the mask is required. See Also: getdata Return the data of a masked array as an ndarray. getmaskarray Return the mask of a masked array, or full array of False. Examples >>> import numpy.ma as ma >>> a= ma.masked_equal([[1,2],[3,4]],2) >>> a masked_array(data = [[1 --] [3 4]], mask = [[False True] [False False]], fill_value=999999) >>> ma.getmask(a) array([[False, True], [False, False]], dtype=bool) Equivalently use the MaskedArray mask attribute. >>> a.mask array([[False, True], [False, False]], dtype=bool) Result when mask == nomask >>> b= ma.masked_array([[1,2],[3,4]]) >>> b masked_array(data = [[1 2] [3 4]], mask = False, fill_value=999999) >>> ma.nomask False >>> ma.getmask(b) == ma.nomask True >>> b.mask == ma.nomask True numpy.ma.getmaskarray(arr) Return the mask of a masked array, or full boolean array of False. 1.7. Masked arrays 341 NumPy Reference, Release 1.8.1 Return the mask of arr as an ndarray if arr is a MaskedArray and the mask is not nomask, else return a full boolean array of False of the same shape as arr. Parameters arr : array_like Input MaskedArray for which the mask is required. See Also: getmask Return the mask of a masked array, or nomask. getdata Return the data of a masked array as an ndarray. Examples >>> import numpy.ma as ma >>> a= ma.masked_equal([[1,2],[3,4]],2) >>> a masked_array(data = [[1 --] [3 4]], mask = [[False True] [False False]], fill_value=999999) >>> ma.getmaskarray(a) array([[False, True], [False, False]], dtype=bool) Result when mask == nomask >>> b= ma.masked_array([[1,2],[3,4]]) >>> b masked_array(data = [[1 2] [3 4]], mask = False, fill_value=999999) >>> >ma.getmaskarray(b) array([[False, False], [False, False]], dtype=bool) masked_array.mask Mask Finding masked data ma.flatnotmasked_contiguous(a) Find contiguous unmasked data in a masked array along the given axis. ma.flatnotmasked_edges(a) Find the indices of the ﬁrst and last unmasked values. ma.notmasked_contiguous(a[, axis]) Find contiguous unmasked data in a masked array along the given axis. ma.notmasked_edges(a[, axis]) Find the indices of the ﬁrst and last unmasked values along an axis. numpy.ma.flatnotmasked_contiguous(a) Find contiguous unmasked data in a masked array along the given axis. 342 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Parameters a : narray The input array. Returns slice_list : list A sorted sequence of slices (start index, end index). See Also: flatnotmasked_edges, notmasked_contiguous, notmasked_edges, clump_masked, clump_unmasked Notes Only accepts 2-D arrays at most. Examples >>> a= np.ma.arange(10) >>> np.ma.extras.flatnotmasked_contiguous(a) slice(0, 10, None) >>> mask= (a<3)| (a>8)| (a ==5) >>> a[mask]= np.ma.masked >>> np.array(a[~a.mask]) array([3, 4, 6, 7, 8]) >>> np.ma.extras.flatnotmasked_contiguous(a) [slice(3, 5, None), slice(6, 9, None)] >>> a[:]= np.ma.masked >>> print np.ma.extras.flatnotmasked_edges(a) None numpy.ma.flatnotmasked_edges(a) Find the indices of the ﬁrst and last unmasked values. Expects a 1-D MaskedArray, returns None if all values are masked. Parameters arr : array_like Input 1-D MaskedArray Returns edges : ndarray or None The indices of ﬁrst and last non-masked value in the array. Returns None if all values are masked. See Also: flatnotmasked_contiguous, notmasked_contiguous, notmasked_edges, clump_masked, clump_unmasked Notes Only accepts 1-D arrays. 1.7. Masked arrays 343 NumPy Reference, Release 1.8.1 Examples >>> a= np.ma.arange(10) >>> flatnotmasked_edges(a) [0,-1] >>> mask= (a<3)| (a>8)| (a ==5) >>> a[mask]= np.ma.masked >>> np.array(a[~a.mask]) array([3, 4, 6, 7, 8]) >>> flatnotmasked_edges(a) array([3, 8]) >>> a[:]= np.ma.masked >>> print flatnotmasked_edges(ma) None numpy.ma.notmasked_contiguous(a, axis=None) Find contiguous unmasked data in a masked array along the given axis. Parameters a : array_like The input array. axis : int, optional Axis along which to perform the operation. If None (default), applies to a ﬂattened version of the array. Returns endpoints : list A list of slices (start and end indexes) of unmasked indexes in the array. See Also: flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges, clump_masked, clump_unmasked Notes Only accepts 2-D arrays at most. Examples >>> a= np.arange(9).reshape((3,3)) >>> mask= np.zeros_like(a) >>> mask[1:,1:]=1 >>> ma= np.ma.array(a, mask=mask) >>> np.array(ma[~ma.mask]) array([0, 1, 2, 3, 6]) >>> np.ma.extras.notmasked_contiguous(ma) [slice(0, 4, None), slice(6, 7, None)] numpy.ma.notmasked_edges(a, axis=None) Find the indices of the ﬁrst and last unmasked values along an axis. If all values are masked, return None. Otherwise, return a list of two tuples, corresponding to the indices of the ﬁrst and last unmasked values respectively. 344 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Parameters a : array_like The input array. axis : int, optional Axis along which to perform the operation. If None (default), applies to a ﬂattened version of the array. Returns edges : ndarray or list An array of start and end indexes if there are any masked data in the array. If there are no masked data in the array, edges is a list of the ﬁrst and last index. See Also: flatnotmasked_contiguous, flatnotmasked_edges, notmasked_contiguous, clump_masked, clump_unmasked Examples >>> a= np.arange(9).reshape((3,3)) >>> m= np.zeros_like(a) >>> m[1:,1:]=1 >>> am= np.ma.array(a, mask=m) >>> np.array(am[~am.mask]) array([0, 1, 2, 3, 6]) >>> np.ma.extras.notmasked_edges(ma) array([0, 6]) Modifying a mask ma.mask_cols(a[, axis]) Mask columns of a 2D array that contain masked values. ma.mask_or(m1, m2[, copy, shrink]) Combine two masks with the logical_or operator. ma.mask_rowcols(a[, axis]) Mask rows and/or columns of a 2D array that contain masked values. ma.mask_rows(a[, axis]) Mask rows of a 2D array that contain masked values. ma.harden_mask(self) Force the mask to hard. ma.soften_mask(self) Force the mask to soft. ma.MaskedArray.harden_mask() Force the mask to hard. ma.MaskedArray.soften_mask() Force the mask to soft. ma.MaskedArray.shrink_mask() Reduce a mask to nomask when possible. ma.MaskedArray.unshare_mask() Copy the mask and set the sharedmask ﬂag to False. numpy.ma.mask_cols(a, axis=None) Mask columns of a 2D array that contain masked values. This function is a shortcut to mask_rowcols with axis equal to 1. See Also: mask_rowcols Mask rows and/or columns of a 2D array. masked_where Mask where a condition is met. 1.7. Masked arrays 345 NumPy Reference, Release 1.8.1 Examples >>> import numpy.ma as ma >>> a= np.zeros((3,3), dtype=np.int) >>> a[1,1]=1 >>> a array([[0, 0, 0], [0, 1, 0], [0, 0, 0]]) >>> a= ma.masked_equal(a,1) >>> a masked_array(data = [[0 0 0] [0 -- 0] [0 0 0]], mask = [[False False False] [False True False] [False False False]], fill_value=999999) >>> ma.mask_cols(a) masked_array(data = [[0 -- 0] [0 -- 0] [0 -- 0]], mask = [[False True False] [False True False] [False True False]], fill_value=999999) numpy.ma.mask_or(m1, m2, copy=False, shrink=True) Combine two masks with the logical_or operator. The result may be a view on m1 or m2 if the other is nomask (i.e. False). Parameters m1, m2 : array_like Input masks. copy : bool, optional If copy is False and one of the inputs is nomask, return a view of the other input mask. Defaults to False. shrink : bool, optional Whether to shrink the output to nomask if all its values are False. Defaults to True. Returns mask : output mask The result masks values that are masked in either m1 or m2. Raises ValueError If m1 and m2 have different ﬂexible dtypes. 346 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples >>> m1= np.ma.make_mask([0,1,1,0]) >>> m2= np.ma.make_mask([1,0,0,0]) >>> np.ma.mask_or(m1, m2) array([ True, True, True, False], dtype=bool) numpy.ma.mask_rowcols(a, axis=None) Mask rows and/or columns of a 2D array that contain masked values. Mask whole rows and/or columns of a 2D array that contain masked values. The masking behavior is selected using the axis parameter. •If axis is None, rows and columns are masked. •If axis is 0, only rows are masked. •If axis is 1 or -1, only columns are masked. Parameters a : array_like, MaskedArray The array to mask. If not a MaskedArray instance (or if no array elements are masked). The result is a MaskedArray with mask set to nomask (False). Must be a 2D array. axis : int, optional Axis along which to perform the operation. If None, applies to a ﬂattened version of the array. Returns a : MaskedArray A modiﬁed version of the input array, masked depending on the value of the axis pa- rameter. Raises NotImplementedError If input array a is not 2D. See Also: mask_rows Mask rows of a 2D array that contain masked values. mask_cols Mask cols of a 2D array that contain masked values. masked_where Mask where a condition is met. Notes The input array’s mask is modiﬁed by this function. Examples >>> import numpy.ma as ma >>> a= np.zeros((3,3), dtype=np.int) >>> a[1,1]=1 >>> a 1.7. Masked arrays 347 NumPy Reference, Release 1.8.1 array([[0, 0, 0], [0, 1, 0], [0, 0, 0]]) >>> a= ma.masked_equal(a,1) >>> a masked_array(data = [[0 0 0] [0 -- 0] [0 0 0]], mask = [[False False False] [False True False] [False False False]], fill_value=999999) >>> ma.mask_rowcols(a) masked_array(data = [[0 -- 0] [-- -- --] [0 -- 0]], mask = [[False True False] [ True True True] [False True False]], fill_value=999999) numpy.ma.mask_rows(a, axis=None) Mask rows of a 2D array that contain masked values. This function is a shortcut to mask_rowcols with axis equal to 0. See Also: mask_rowcols Mask rows and/or columns of a 2D array. masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.zeros((3,3), dtype=np.int) >>> a[1,1]=1 >>> a array([[0, 0, 0], [0, 1, 0], [0, 0, 0]]) >>> a= ma.masked_equal(a,1) >>> a masked_array(data = [[0 0 0] [0 -- 0] [0 0 0]], mask = [[False False False] [False True False] [False False False]], fill_value=999999) >>> ma.mask_rows(a) 348 Chapter 1. Array objects NumPy Reference, Release 1.8.1 masked_array(data = [[0 0 0] [-- -- --] [0 0 0]], mask = [[False False False] [ True True True] [False False False]], fill_value=999999) numpy.ma.harden_mask(self) = Force the mask to hard. Whether the mask of a masked array is hard or soft is determined by its hardmask property. harden_mask sets hardmask to True. See Also: hardmask numpy.ma.soften_mask(self) = Force the mask to soft. Whether the mask of a masked array is hard or soft is determined by its hardmask property. soften_mask sets hardmask to False. See Also: hardmask MaskedArray.harden_mask() Force the mask to hard. Whether the mask of a masked array is hard or soft is determined by its hardmask property. harden_mask sets hardmask to True. See Also: hardmask MaskedArray.soften_mask() Force the mask to soft. Whether the mask of a masked array is hard or soft is determined by its hardmask property. soften_mask sets hardmask to False. See Also: hardmask MaskedArray.shrink_mask() Reduce a mask to nomask when possible. Parameters None Returns None Examples >>> x= np.ma.array([[1,2],[3,4]], mask=[0]*4) >>> x.mask array([[False, False], 1.7. Masked arrays 349 NumPy Reference, Release 1.8.1 [False, False]], dtype=bool) >>> x.shrink_mask() >>> x.mask False MaskedArray.unshare_mask() Copy the mask and set the sharedmask ﬂag 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. See Also: sharedmask Conversion operations > to a masked array ma.asarray(a[, dtype, order]) Convert the input to a masked array of the given data-type. ma.asanyarray(a[, dtype]) Convert the input to a masked array, conserving subclasses. ma.fix_invalid(a[, mask, copy, ﬁll_value]) Return input with invalid data masked and replaced by a ﬁll value. ma.masked_equal(x, value[, copy]) Mask an array where equal to a given value. ma.masked_greater(x, value[, copy]) Mask an array where greater than a given value. ma.masked_greater_equal(x, value[, copy]) Mask an array where greater than or equal to a given value. ma.masked_inside(x, v1, v2[, copy]) Mask an array inside a given interval. ma.masked_invalid(a[, copy]) Mask an array where invalid values occur (NaNs or infs). ma.masked_less(x, value[, copy]) Mask an array where less than a given value. ma.masked_less_equal(x, value[, copy]) Mask an array where less than or equal to a given value. ma.masked_not_equal(x, value[, copy]) Mask an array where not equal to a given value. ma.masked_object(x, value[, copy, shrink]) Mask the array x where the data are exactly equal to value. ma.masked_outside(x, v1, v2[, copy]) Mask an array outside a given interval. ma.masked_values(x, value[, rtol, atol, ...]) Mask using ﬂoating point equality. ma.masked_where(condition, a[, copy]) Mask an array where a condition is met. numpy.ma.asarray(a, dtype=None, order=None) Convert the input to a masked array of the given data-type. No copy is performed if the input is already an ndarray. If a is a subclass of MaskedArray, a base class MaskedArray is returned. Parameters a : array_like Input data, in any form that can be converted to a masked array. This includes lists, lists of tuples, tuples, tuples of tuples, tuples of lists, ndarrays and masked arrays. dtype : dtype, optional By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional Whether to use row-major (‘C’) or column-major (‘FORTRAN’) memory representa- tion. Default is ‘C’. 350 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Returns out : MaskedArray Masked array interpretation of a. See Also: asanyarray Similar to asarray, but conserves subclasses. Examples >>> x= np.arange(10.).reshape(2,5) >>> x array([[ 0., 1., 2., 3., 4.], [ 5., 6., 7., 8., 9.]]) >>> np.ma.asarray(x) masked_array(data = [[ 0. 1. 2. 3. 4.] [ 5. 6. 7. 8. 9.]], mask = False, fill_value = 1e+20) >>> type(np.ma.asarray(x)) numpy.ma.asanyarray(a, dtype=None) Convert the input to a masked array, conserving subclasses. If a is a subclass of MaskedArray, its class is conserved. No copy is performed if the input is already an ndarray. Parameters a : array_like Input data, in any form that can be converted to an array. dtype : dtype, optional By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional Whether to use row-major (‘C’) or column-major (‘FORTRAN’) memory representa- tion. Default is ‘C’. Returns out : MaskedArray MaskedArray interpretation of a. See Also: asarray Similar to asanyarray, but does not conserve subclass. Examples >>> x= np.arange(10.).reshape(2,5) >>> x array([[ 0., 1., 2., 3., 4.], [ 5., 6., 7., 8., 9.]]) 1.7. Masked arrays 351 NumPy Reference, Release 1.8.1 >>> np.ma.asanyarray(x) masked_array(data = [[ 0. 1. 2. 3. 4.] [ 5. 6. 7. 8. 9.]], mask = False, fill_value = 1e+20) >>> type(np.ma.asanyarray(x)) numpy.ma.fix_invalid(a, mask=False, copy=True, ﬁll_value=None) Return input with invalid data masked and replaced by a ﬁll value. Invalid data means values of nan, inf, etc. Parameters a : array_like Input array, a (subclass of) ndarray. copy : bool, optional Whether to use a copy of a (True) or to ﬁx a in place (False). Default is True. ﬁll_value : scalar, optional Value used for ﬁxing invalid data. Default is None, in which case the a.fill_value is used. Returns b : MaskedArray The input array with invalid entries ﬁxed. Notes A copy is performed by default. Examples >>> x= np.ma.array([1.,-1, np.nan, np.inf], mask=[1]+[0]*3) >>> x masked_array(data = [-- -1.0 nan inf], mask = [ True False False False], fill_value = 1e+20) >>> np.ma.fix_invalid(x) masked_array(data = [-- -1.0 -- --], mask = [ True False True True], fill_value = 1e+20) >>> fixed= np.ma.fix_invalid(x) >>> fixed.data array([ 1.00000000e+00, -1.00000000e+00, 1.00000000e+20, 1.00000000e+20]) >>> x.data array([ 1., -1., NaN, Inf]) numpy.ma.masked_equal(x, value, copy=True) Mask an array where equal to a given value. This function is a shortcut to masked_where, with condition = (x == value). For ﬂoating point arrays, consider using masked_values(x, value). 352 Chapter 1. Array objects NumPy Reference, Release 1.8.1 See Also: masked_where Mask where a condition is met. masked_values Mask using ﬂoating point equality. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_equal(a,2) masked_array(data = [0 1 -- 3], mask = [False False True False], fill_value=999999) numpy.ma.masked_greater(x, value, copy=True) Mask an array where greater than a given value. This function is a shortcut to masked_where, with condition = (x > value). See Also: masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_greater(a,2) masked_array(data = [0 1 2 --], mask = [False False False True], fill_value=999999) numpy.ma.masked_greater_equal(x, value, copy=True) Mask an array where greater than or equal to a given value. This function is a shortcut to masked_where, with condition = (x >= value). See Also: masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_greater_equal(a,2) masked_array(data = [0 1 -- --], mask = [False False True True], fill_value=999999) 1.7. Masked arrays 353 NumPy Reference, Release 1.8.1 numpy.ma.masked_inside(x, v1, v2, copy=True) Mask an array inside a given interval. Shortcut to masked_where, where condition is True for x inside the interval [v1,v2] (v1 <= x <= v2). The boundaries v1 and v2 can be given in either order. See Also: masked_where Mask where a condition is met. Notes The array x is preﬁlled with its ﬁlling value. Examples >>> import numpy.ma as ma >>> x=[0.31, 1.2, 0.01, 0.2,-0.4,-1.1] >>> ma.masked_inside(x,-0.3, 0.3) masked_array(data = [0.31 1.2 -- -- -0.4 -1.1], mask = [False False True True False False], fill_value=1e+20) The order of v1 and v2 doesn’t matter. >>> ma.masked_inside(x, 0.3,-0.3) masked_array(data = [0.31 1.2 -- -- -0.4 -1.1], mask = [False False True True False False], fill_value=1e+20) numpy.ma.masked_invalid(a, copy=True) Mask an array where invalid values occur (NaNs or infs). This function is a shortcut to masked_where, with condition = ~(np.isﬁnite(a)). Any pre-existing mask is conserved. Only applies to arrays with a dtype where NaNs or infs make sense (i.e. ﬂoating point types), but accepts any array_like object. See Also: masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(5, dtype=np.float) >>> a[2]= np.NaN >>> a[3]= np.PINF >>> a array([ 0., 1., NaN, Inf, 4.]) >>> ma.masked_invalid(a) masked_array(data = [0.0 1.0 -- -- 4.0], mask = [False False True True False], fill_value=1e+20) numpy.ma.masked_less(x, value, copy=True) Mask an array where less than a given value. This function is a shortcut to masked_where, with condition = (x < value). 354 Chapter 1. Array objects NumPy Reference, Release 1.8.1 See Also: masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_less(a,2) masked_array(data = [-- -- 2 3], mask = [ True True False False], fill_value=999999) numpy.ma.masked_less_equal(x, value, copy=True) Mask an array where less than or equal to a given value. This function is a shortcut to masked_where, with condition = (x <= value). See Also: masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_less_equal(a,2) masked_array(data = [-- -- -- 3], mask = [ True True True False], fill_value=999999) numpy.ma.masked_not_equal(x, value, copy=True) Mask an array where not equal to a given value. This function is a shortcut to masked_where, with condition = (x != value). See Also: masked_where Mask where a condition is met. Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_not_equal(a,2) masked_array(data = [-- -- 2 --], mask = [ True True False True], fill_value=999999) 1.7. Masked arrays 355 NumPy Reference, Release 1.8.1 numpy.ma.masked_object(x, value, copy=True, shrink=True) Mask the array x where the data are exactly equal to value. This function is similar to masked_values, but only suitable for object arrays: for ﬂoating point, use masked_values instead. Parameters x : array_like Array to mask value : object Comparison value copy : {True, False}, optional Whether to return a copy of x. shrink : {True, False}, optional Whether to collapse a mask full of False to nomask Returns result : MaskedArray The result of masking x where equal to value. See Also: masked_where Mask where a condition is met. masked_equal Mask where equal to a given value (integers). masked_values Mask using ﬂoating point equality. Examples >>> import numpy.ma as ma >>> food= np.array([’green_eggs’,’ham’], dtype=object) >>> # don’t eat spoiled food >>> eat= ma.masked_object(food,’green_eggs’) >>> print eat [-- ham] >>> # plain ol‘ ham is boring >>> fresh_food= np.array([’cheese’,’ham’,’pineapple’], dtype=object) >>> eat= ma.masked_object(fresh_food,’green_eggs’) >>> print eat [cheese ham pineapple] Note that mask is set to nomask if possible. >>> eat masked_array(data = [cheese ham pineapple], mask = False, fill_value=?) numpy.ma.masked_outside(x, v1, v2, copy=True) Mask an array outside a given interval. 356 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Shortcut to masked_where, where condition is True for x outside the interval [v1,v2] (x < v1)|(x > v2). The boundaries v1 and v2 can be given in either order. See Also: masked_where Mask where a condition is met. Notes The array x is preﬁlled with its ﬁlling value. Examples >>> import numpy.ma as ma >>> x=[0.31, 1.2, 0.01, 0.2,-0.4,-1.1] >>> ma.masked_outside(x,-0.3, 0.3) masked_array(data = [-- -- 0.01 0.2 -- --], mask = [ True True False False True True], fill_value=1e+20) The order of v1 and v2 doesn’t matter. >>> ma.masked_outside(x, 0.3,-0.3) masked_array(data = [-- -- 0.01 0.2 -- --], mask = [ True True False False True True], fill_value=1e+20) numpy.ma.masked_values(x, value, rtol=1e-05, atol=1e-08, copy=True, shrink=True) Mask using ﬂoating point equality. Return a MaskedArray, masked where the data in array x are approximately equal to value, i.e. where the following condition is True (abs(x - value) <= atol+rtol*abs(value)) The ﬁll_value is set to value and the mask is set to nomask if possible. For integers, consider using masked_equal. Parameters x : array_like Array to mask. value : ﬂoat Masking value. rtol : ﬂoat, optional Tolerance parameter. atol : ﬂoat, optional Tolerance parameter (1e-8). copy : bool, optional Whether to return a copy of x. shrink : bool, optional Whether to collapse a mask full of False to nomask. 1.7. Masked arrays 357 NumPy Reference, Release 1.8.1 Returns result : MaskedArray The result of masking x where approximately equal to value. See Also: masked_where Mask where a condition is met. masked_equal Mask where equal to a given value (integers). Examples >>> import numpy.ma as ma >>> x= np.array([1, 1.1,2, 1.1,3]) >>> ma.masked_values(x, 1.1) masked_array(data = [1.0 -- 2.0 -- 3.0], mask = [False True False True False], fill_value=1.1) Note that mask is set to nomask if possible. >>> ma.masked_values(x, 1.5) masked_array(data = [ 1. 1.1 2. 1.1 3. ], mask = False, fill_value=1.5) For integers, the ﬁll value will be different in general to the result of masked_equal. >>> x= np.arange(5) >>> x array([0, 1, 2, 3, 4]) >>> ma.masked_values(x,2) masked_array(data = [0 1 -- 3 4], mask = [False False True False False], fill_value=2) >>> ma.masked_equal(x,2) masked_array(data = [0 1 -- 3 4], mask = [False False True False False], fill_value=999999) numpy.ma.masked_where(condition, a, copy=True) Mask an array where a condition is met. Return a as an array masked where condition is True. Any masked values of a or condition are also masked in the output. Parameters condition : array_like Masking condition. When condition tests ﬂoating point values for equality, consider using masked_values instead. a : array_like Array to mask. copy : bool 358 Chapter 1. Array objects NumPy Reference, Release 1.8.1 If True (default) make a copy of a in the result. If False modify a in place and return a view. Returns result : MaskedArray The result of masking a where condition is True. See Also: masked_values Mask using ﬂoating point equality. masked_equal Mask where equal to a given value. masked_not_equal Mask where not equal to a given value. masked_less_equal Mask where less than or equal to a given value. masked_greater_equal Mask where greater than or equal to a given value. masked_less Mask where less than a given value. masked_greater Mask where greater than a given value. masked_inside Mask inside a given interval. masked_outside Mask outside a given interval. masked_invalid Mask invalid values (NaNs or infs). Examples >>> import numpy.ma as ma >>> a= np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_where(a<=2, a) masked_array(data = [-- -- -- 3], mask = [ True True True False], fill_value=999999) Mask array b conditional on a. >>> b=[’a’,’b’,’c’,’d’] >>> ma.masked_where(a ==2, b) masked_array(data = [a b -- d], mask = [False False True False], fill_value=N/A) Effect of the copy argument. 1.7. Masked arrays 359 NumPy Reference, Release 1.8.1 >>> c= ma.masked_where(a<=2, a) >>> c masked_array(data = [-- -- -- 3], mask = [ True True True False], fill_value=999999) >>> c[0]= 99 >>> c masked_array(data = [99 -- -- 3], mask = [False True True False], fill_value=999999) >>> a array([0, 1, 2, 3]) >>> c= ma.masked_where(a<=2, a, copy=False) >>> c[0]= 99 >>> c masked_array(data = [99 -- -- 3], mask = [False True True False], fill_value=999999) >>> a array([99, 1, 2, 3]) When condition or a contain masked values. >>> a= np.arange(4) >>> a= ma.masked_where(a ==2, a) >>> a masked_array(data = [0 1 -- 3], mask = [False False True False], fill_value=999999) >>> b= np.arange(4) >>> b= ma.masked_where(b ==0, b) >>> b masked_array(data = [-- 1 2 3], mask = [ True False False False], fill_value=999999) >>> ma.masked_where(a ==3, b) masked_array(data = [-- 1 -- --], mask = [ True False True True], fill_value=999999) > to a ndarray ma.compress_cols(a) Suppress whole columns of a 2-D array that contain masked values. ma.compress_rowcols(x[, axis]) Suppress the rows and/or columns of a 2-D array that contain ma.compress_rows(a) Suppress whole rows of a 2-D array that contain masked values. ma.compressed(x) Return all the non-masked data as a 1-D array. ma.filled(a[, ﬁll_value]) Return input as an array with masked data replaced by a ﬁll value. ma.MaskedArray.compressed() Return all the non-masked data as a 1-D array. ma.MaskedArray.filled([ﬁll_value]) Return a copy of self, with masked values ﬁlled with a given value. numpy.ma.compress_cols(a) Suppress whole columns of a 2-D array that contain masked values. This is equivalent to np.ma.extras.compress_rowcols(a, 1), see extras.compress_rowcols for details. See Also: 360 Chapter 1. Array objects NumPy Reference, Release 1.8.1 extras.compress_rowcols numpy.ma.compress_rowcols(x, axis=None) Suppress the rows and/or columns of a 2-D array that contain masked values. The suppression behavior is selected with the axis parameter. •If axis is None, both rows and columns are suppressed. •If axis is 0, only rows are suppressed. •If axis is 1 or -1, only columns are suppressed. Parameters axis : int, optional Axis along which to perform the operation. Default is None. Returns compressed_array : ndarray The compressed array. Examples >>> x= np.ma.array(np.arange(9).reshape(3,3), mask=[[1,0,0], ... [1,0,0], ... [0,0,0]]) >>> x masked_array(data = [[-- 1 2] [-- 4 5] [6 7 8]], mask = [[ True False False] [ True False False] [False False False]], fill_value = 999999) >>> np.ma.extras.compress_rowcols(x) array([[7, 8]]) >>> np.ma.extras.compress_rowcols(x,0) array([[6, 7, 8]]) >>> np.ma.extras.compress_rowcols(x,1) array([[1, 2], [4, 5], [7, 8]]) numpy.ma.compress_rows(a) Suppress whole rows of a 2-D array that contain masked values. This is equivalent to np.ma.extras.compress_rowcols(a, 0), see extras.compress_rowcols for details. See Also: extras.compress_rowcols numpy.ma.compressed(x) Return all the non-masked data as a 1-D array. This function is equivalent to calling the “compressed” method of a MaskedArray, see MaskedArray.compressed for details. 1.7. Masked arrays 361 NumPy Reference, Release 1.8.1 See Also: MaskedArray.compressed Equivalent method. numpy.ma.filled(a, ﬁll_value=None) Return input as an array with masked data replaced by a ﬁll value. If a is not a MaskedArray, a itself is returned. If a is a MaskedArray and ﬁll_value is None, ﬁll_value is set to a.fill_value. Parameters a : MaskedArray or array_like An input object. ﬁll_value : scalar, optional Filling value. Default is None. Returns a : ndarray The ﬁlled array. See Also: compressed Examples >>> x= np.ma.array(np.arange(9).reshape(3,3), mask=[[1,0,0], ... [1,0,0], ... [0,0,0]]) >>> x.filled() array([[999999, 1, 2], [999999, 4, 5], [ 6, 7, 8]]) MaskedArray.compressed() Return all the non-masked data as a 1-D array. Returns data : ndarray A new ndarray holding the non-masked data is returned. Notes The result is not a MaskedArray! Examples >>> x= np.ma.array(np.arange(5), mask=[0]*2+[1]*3) >>> x.compressed() array([0, 1]) >>> type(x.compressed()) MaskedArray.filled(ﬁll_value=None) Return a copy of self, with masked values ﬁlled with a given value. 362 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Parameters ﬁll_value : scalar, optional The value to use for invalid entries (None by default). If None, the fill_value attribute of the array is used instead. Returns ﬁlled_array : ndarray A copy of self with invalid entries replaced by ﬁll_value (be it the function argument or the attribute of self. Notes The result is not a MaskedArray! Examples >>> 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]) >>> type(x.filled()) Subclassing is preserved. This means that if the data part of the masked array is a matrix, filled returns a matrix: >>> x= np.ma.array(np.matrix([[1,2], [3,4]]), mask=[[0,1], [1,0]]) >>> x.filled() matrix([[ 1, 999999], [999999, 4]]) > to another object ma.MaskedArray.tofile(ﬁd[, sep, format]) Save a masked array to a ﬁle in binary format. ma.MaskedArray.tolist([ﬁll_value]) Return the data portion of the masked array as a hierarchical Python list. ma.MaskedArray.torecords() Transforms a masked array into a ﬂexible-type array. ma.MaskedArray.tostring([ﬁll_value, order]) Return the array data as a string containing the raw bytes in the array. MaskedArray.tofile(ﬁd, sep=’‘, format=’%s’) Save a masked array to a ﬁle in binary format. Warning: This function is not implemented yet. Raises NotImplementedError When tofile is called. MaskedArray.tolist(ﬁll_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 ﬁll_value : scalar, optional The value to use for invalid entries. Default is None. 1.7. Masked arrays 363 NumPy Reference, Release 1.8.1 Returns result : list The Python list representation of the masked array. Examples >>> 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]] MaskedArray.torecords() Transforms a masked array into a ﬂexible-type array. The ﬂexible type array that is returned will have two ﬁelds: •the _data ﬁeld stores the _data part of the array. •the _mask ﬁeld stores the _mask part of the array. Parameters None Returns record : ndarray A new ﬂexible-type ndarray with two ﬁelds: the ﬁrst 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 ﬂexible ndarray is that meta information (fill_value, ...) will be lost. Examples >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> print x.toflex() [[(1, False) (2, True) (3, False)] [(4, True) (5, False) (6, True)] [(7, False) (8, True) (9, False)]] MaskedArray.tostring(ﬁll_value=None, order=’C’) Return the array data as a string containing the raw bytes in the array. The array is ﬁlled with a ﬁll value before the string conversion. Parameters ﬁll_value : scalar, optional Value used to ﬁll in the masked values. Deafult is None, in which case MaskedArray.fill_value is used. order : {‘C’,’F’,’A’}, optional 364 Chapter 1. Array objects NumPy Reference, Release 1.8.1 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’. See Also: ndarray.tostring, tolist, tofile Notes As for ndarray.tostring, information about the shape, dtype, etc., but also about fill_value, will be lost. Examples >>> x= np.ma.array(np.array([[1,2], [3,4]]), mask=[[0,1], [1,0]]) >>> x.tostring() ’\x01\x00\x00\x00?B\x0f\x00?B\x0f\x00\x04\x00\x00\x00’ Pickling and unpickling ma.dump(a, F) Pickle a masked array to a ﬁle. ma.dumps(a) Return a string corresponding to the pickling of a masked array. ma.load(F) Wrapper around cPickle.load which accepts either a ﬁle-like object ma.loads(strg) Load a pickle from the current string. numpy.ma.dump(a,F) Pickle a masked array to a ﬁle. This is a wrapper around cPickle.dump. Parameters a : MaskedArray The array to be pickled. F: str or ﬁle-like object The ﬁle to pickle a to. If a string, the full path to the ﬁle. numpy.ma.dumps(a) Return a string corresponding to the pickling of a masked array. This is a wrapper around cPickle.dumps. Parameters a : MaskedArray The array for which the string representation of the pickle is returned. numpy.ma.load(F) Wrapper around cPickle.load which accepts either a ﬁle-like object or a ﬁlename. Parameters F: str or ﬁle The ﬁle or ﬁle name to load. See Also: 1.7. Masked arrays 365 NumPy Reference, Release 1.8.1 dump Pickle an array Notes This is different from numpy.load, which does not use cPickle but loads the NumPy binary .npy format. numpy.ma.loads(strg) Load a pickle from the current string. The result of cPickle.loads(strg) is returned. Parameters strg : str The string to load. See Also: dumps Return a string corresponding to the pickling of a masked array. Filling a masked array ma.common_fill_value(a, b) Return the common ﬁlling value of two masked arrays, if any. ma.default_fill_value(obj) Return the default ﬁll value for the argument object. ma.maximum_fill_value(obj) Return the minimum value that can be represented by the dtype of an object. ma.maximum_fill_value(obj) Return the minimum value that can be represented by the dtype of an object. ma.set_fill_value(a, ﬁll_value) Set the ﬁlling value of a, if a is a masked array. ma.MaskedArray.get_fill_value() Return the ﬁlling value of the masked array. ma.MaskedArray.set_fill_value([value]) Set the ﬁlling value of the masked array. ma.MaskedArray.fill_value Filling value. numpy.ma.common_fill_value(a, b) Return the common ﬁlling value of two masked arrays, if any. If a.fill_value == b.fill_value, return the ﬁll value, otherwise return None. Parameters a, b : MaskedArray The masked arrays for which to compare ﬁll values. Returns ﬁll_value : scalar or None The common ﬁll value, or None. Examples >>> x= np.ma.array([0, 1.], fill_value=3) >>> y= np.ma.array([0, 1.], fill_value=3) >>> np.ma.common_fill_value(x, y) 3.0 numpy.ma.default_fill_value(obj) Return the default ﬁll value for the argument object. The default ﬁlling value depends on the datatype of the input array or the type of the input scalar: 366 Chapter 1. Array objects NumPy Reference, Release 1.8.1 datatype default bool True int 999999 ﬂoat 1.e20 complex 1.e20+0j object ‘?’ string ‘N/A’ Parameters obj : ndarray, dtype or scalar The array data-type or scalar for which the default ﬁll value is returned. Returns ﬁll_value : scalar The default ﬁll value. Examples >>> np.ma.default_fill_value(1) 999999 >>> np.ma.default_fill_value(np.array([1.1, 2., np.pi])) 1e+20 >>> np.ma.default_fill_value(np.dtype(complex)) (1e+20+0j) numpy.ma.maximum_fill_value(obj) Return the minimum value that can be represented by the dtype of an object. This function is useful for calculating a ﬁll value suitable for taking the maximum of an array with a given dtype. Parameters obj : {ndarray, dtype} An object that can be queried for it’s numeric type. Returns val : scalar The minimum representable value. Raises TypeError If obj isn’t a suitable numeric type. See Also: minimum_fill_value The inverse function. set_fill_value Set the ﬁlling value of a masked array. MaskedArray.fill_value Return current ﬁll value. 1.7. Masked arrays 367 NumPy Reference, Release 1.8.1 Examples >>> import numpy.ma as ma >>> a= np.int8() >>> ma.maximum_fill_value(a) -128 >>> a= np.int32() >>> ma.maximum_fill_value(a) -2147483648 An array of numeric data can also be passed. >>> a= np.array([1,2,3], dtype=np.int8) >>> ma.maximum_fill_value(a) -128 >>> a= np.array([1,2,3], dtype=np.float32) >>> ma.maximum_fill_value(a) -inf numpy.ma.maximum_fill_value(obj) Return the minimum value that can be represented by the dtype of an object. This function is useful for calculating a ﬁll value suitable for taking the maximum of an array with a given dtype. Parameters obj : {ndarray, dtype} An object that can be queried for it’s numeric type. Returns val : scalar The minimum representable value. Raises TypeError If obj isn’t a suitable numeric type. See Also: minimum_fill_value The inverse function. set_fill_value Set the ﬁlling value of a masked array. MaskedArray.fill_value Return current ﬁll value. Examples >>> import numpy.ma as ma >>> a= np.int8() >>> ma.maximum_fill_value(a) -128 >>> a= np.int32() >>> ma.maximum_fill_value(a) -2147483648 An array of numeric data can also be passed. 368 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> a= np.array([1,2,3], dtype=np.int8) >>> ma.maximum_fill_value(a) -128 >>> a= np.array([1,2,3], dtype=np.float32) >>> ma.maximum_fill_value(a) -inf numpy.ma.set_fill_value(a, ﬁll_value) Set the ﬁlling value of a, if a is a masked array. This function changes the ﬁll value of the masked array a in place. If a is not a masked array, the function returns silently, without doing anything. Parameters a : array_like Input array. ﬁll_value : dtype Filling value. A consistency test is performed to make sure the value is compatible with the dtype of a. Returns None Nothing returned by this function. See Also: maximum_fill_value Return the default ﬁll value for a dtype. MaskedArray.fill_value Return current ﬁll value. MaskedArray.set_fill_value Equivalent method. Examples >>> import numpy.ma as ma >>> a= np.arange(5) >>> a array([0, 1, 2, 3, 4]) >>> a= ma.masked_where(a<3, a) >>> a masked_array(data = [-- -- -- 3 4], mask = [ True True True False False], fill_value=999999) >>> ma.set_fill_value(a,-999) >>> a masked_array(data = [-- -- -- 3 4], mask = [ True True True False False], fill_value=-999) Nothing happens if a is not a masked array. >>> a= range(5) >>> a [0, 1, 2, 3, 4] 1.7. Masked arrays 369 NumPy Reference, Release 1.8.1 >>> ma.set_fill_value(a, 100) >>> a [0, 1, 2, 3, 4] >>> a= np.arange(5) >>> a array([0, 1, 2, 3, 4]) >>> ma.set_fill_value(a, 100) >>> a array([0, 1, 2, 3, 4]) MaskedArray.get_fill_value() Return the ﬁlling value of the masked array. Returns ﬁll_value : scalar The ﬁlling value. Examples >>> for dt in [np.int32, np.int64, np.float64, np.complex128]: ... np.ma.array([0,1], dtype=dt).get_fill_value() ... 999999 999999 1e+20 (1e+20+0j) >>> x= np.ma.array([0, 1.], fill_value=-np.inf) >>> x.get_fill_value() -inf MaskedArray.set_fill_value(value=None) Set the ﬁlling value of the masked array. Parameters value : scalar, optional The new ﬁlling value. Default is None, in which case a default based on the data type is used. See Also: ma.set_fill_value Equivalent function. Examples >>> x= np.ma.array([0, 1.], fill_value=-np.inf) >>> x.fill_value -inf >>> x.set_fill_value(np.pi) >>> x.fill_value 3.1415926535897931 Reset to default: >>> x.set_fill_value() >>> x.fill_value 1e+20 370 Chapter 1. Array objects NumPy Reference, Release 1.8.1 MaskedArray.fill_value Filling value. Masked arrays arithmetics Arithmetics ma.anom(self[, axis, dtype]) Compute the anomalies (deviations from the arithmetic mean) along the given axis. ma.anomalies(self[, axis, dtype]) Compute the anomalies (deviations from the arithmetic mean) along the given axis. ma.average(a[, axis, weights, returned]) Return the weighted average of array over the given axis. ma.conjugate(x[, out]) Return the complex conjugate, element-wise. ma.corrcoef(x[, y, rowvar, bias, ...]) Return correlation coefﬁcients of the input array. ma.cov(x[, y, rowvar, bias, allow_masked, ddof]) Estimate the covariance matrix. ma.cumsum(self[, axis, dtype, out]) Return the cumulative sum of the elements along the given axis. ma.cumprod(self[, axis, dtype, out]) Return the cumulative product of the elements along the given axis. ma.mean(self[, axis, dtype, out]) Returns the average of the array elements. ma.median(a[, axis, out, overwrite_input]) Compute the median along the speciﬁed axis. ma.power(a, b[, third]) Returns element-wise base array raised to power from second array. ma.prod(self[, axis, dtype, out]) Return the product of the array elements over the given axis. ma.std(self[, axis, dtype, out, ddof]) Compute the standard deviation along the speciﬁed axis. ma.sum(self[, axis, dtype, out]) Return the sum of the array elements over the given axis. ma.var(self[, axis, dtype, out, ddof]) Compute the variance along the speciﬁed axis. ma.MaskedArray.anom([axis, dtype]) Compute the anomalies (deviations from the arithmetic mean) along the given axis. ma.MaskedArray.cumprod([axis, dtype, out]) Return the cumulative product of the elements along the given axis. ma.MaskedArray.cumsum([axis, dtype, out]) Return the cumulative sum of the elements along the given axis. ma.MaskedArray.mean([axis, dtype, out]) Returns the average of the array elements. ma.MaskedArray.prod([axis, dtype, out]) Return the product of the array elements over the given axis. ma.MaskedArray.std([axis, dtype, out, ddof]) Compute the standard deviation along the speciﬁed axis. ma.MaskedArray.sum([axis, dtype, out]) Return the sum of the array elements over the given axis. ma.MaskedArray.var([axis, dtype, out, ddof]) Compute the variance along the speciﬁed axis. numpy.ma.anom(self, 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 axis : int, optional Axis over which the anomalies are taken. The default is to use the mean of the ﬂattened array as reference. dtype : dtype, optional Type to use in computing the variance. For arrays of integer type the default is ﬂoat32; for arrays of ﬂoat types it is the same as the array type. See Also: mean Compute the mean of the array. 1.7. Masked arrays 371 NumPy Reference, Release 1.8.1 Examples >>> a= np.ma.array([1,2,3]) >>> a.anom() masked_array(data = [-1. 0. 1.], mask = False, fill_value = 1e+20) numpy.ma.anomalies(self, 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 axis : int, optional Axis over which the anomalies are taken. The default is to use the mean of the ﬂattened array as reference. dtype : dtype, optional Type to use in computing the variance. For arrays of integer type the default is ﬂoat32; for arrays of ﬂoat types it is the same as the array type. See Also: mean Compute the mean of the array. Examples >>> a= np.ma.array([1,2,3]) >>> a.anom() masked_array(data = [-1. 0. 1.], mask = False, fill_value = 1e+20) numpy.ma.average(a, axis=None, weights=None, returned=False) Return the weighted average of array over the given axis. Parameters a : array_like Data to be averaged. Masked entries are not taken into account in the computation. axis : int, optional Axis along which the variance is computed. The default is to compute the variance of the ﬂattened array. weights : array_like, optional The importance that each element has in the computation of the average. The weights array can either be 1-D (in which case its length must be the size of a along the given axis) or of the same shape as a. If weights=None, then all data in a are assumed to have a weight equal to one. If weights is complex, the imaginary parts are ignored. returned : bool, optional Flag indicating whether a tuple (result, sum of weights) should be returned as output (True), or just the result (False). Default is False. 372 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Returns average, [sum_of_weights] : (tuple of) scalar or MaskedArray The average along the speciﬁed axis. When returned is True, return a tuple with the average as the ﬁrst element and the sum of the weights as the second element. The return type is np.ﬂoat64 if a is of integer type, otherwise it is of the same type as a. If returned, sum_of_weights is of the same type as average. Examples >>> a= np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True]) >>> np.ma.average(a, weights=[3,1,0,0]) 1.25 >>> x= np.ma.arange(6.).reshape(3,2) >>> print x [[ 0. 1.] [ 2. 3.] [ 4. 5.]] >>> avg, sumweights= np.ma.average(x, axis=0, weights=[1,2,3], ... returned=True) >>> print avg [2.66666666667 3.66666666667] numpy.ma.conjugate(x[, out ]) = Return the complex conjugate, element-wise. The complex conjugate of a complex number is obtained by changing the sign of its imaginary part. Parameters x : array_like Input value. Returns y : ndarray The complex conjugate of x, with same dtype as y. Examples >>> np.conjugate(1+2j) (1-2j) >>> x= np.eye(2)+1j * np.eye(2) >>> np.conjugate(x) array([[ 1.-1.j, 0.-0.j], [ 0.-0.j, 1.-1.j]]) numpy.ma.corrcoef(x, y=None, rowvar=True, bias=False, allow_masked=True, ddof=None) Return correlation coefﬁcients of the input array. Except for the handling of missing data this function does the same as numpy.corrcoef. For more details and examples, see numpy.corrcoef. Parameters x : array_like A 1-D or 2-D array containing multiple variables and observations. Each row of x represents a variable, and each column a single observation of all those variables. Also see rowvar below. 1.7. Masked arrays 373 NumPy Reference, Release 1.8.1 y : array_like, optional An additional set of variables and observations. y has the same shape as x. rowvar : bool, optional If rowvar is True (default), then each row represents a variable, with observations in the columns. Otherwise, the relationship is transposed: each column represents a variable, while the rows contain observations. bias : bool, optional Default normalization (False) is by (N-1), where N is the number of observations given (unbiased estimate). If bias is 1, then normalization is by N. This keyword can be overridden by the keyword ddof in numpy versions >= 1.5. allow_masked : bool, optional If True, masked values are propagated pair-wise: if a value is masked in x, the corre- sponding value is masked in y. If False, raises an exception. ddof : {None, int}, optional New in version 1.5. If not None normalization is by (N - ddof), where N is the number of observations; this overrides the value implied by bias. The default value is None. See Also: numpy.corrcoef Equivalent function in top-level NumPy module. cov Estimate the covariance matrix. numpy.ma.cov(x, y=None, rowvar=True, bias=False, allow_masked=True, ddof=None) Estimate the covariance matrix. Except for the handling of missing data this function does the same as numpy.cov. For more details and examples, see numpy.cov. By default, masked values are recognized as such. If x and y have the same shape, a common mask is allocated: if x[i,j] is masked, then y[i,j] will also be masked. Setting allow_masked to False will raise an exception if values are missing in either of the input arrays. Parameters x : array_like A 1-D or 2-D array containing multiple variables and observations. Each row of x represents a variable, and each column a single observation of all those variables. Also see rowvar below. y : array_like, optional An additional set of variables and observations. y has the same form as x. rowvar : bool, optional If rowvar is True (default), then each row represents a variable, with observations in the columns. Otherwise, the relationship is transposed: each column represents a variable, while the rows contain observations. bias : bool, optional 374 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Default normalization (False) is by (N-1), where N is the number of observations given (unbiased estimate). If bias is True, then normalization is by N. This keyword can be overridden by the keyword ddof in numpy versions >= 1.5. allow_masked : bool, optional If True, masked values are propagated pair-wise: if a value is masked in x, the cor- responding value is masked in y. If False, raises a ValueError exception when some values are missing. ddof : {None, int}, optional New in version 1.5. If not None normalization is by (N - ddof), where N is the number of observations; this overrides the value implied by bias. The default value is None. Raises ValueError Raised if some values are missing and allow_masked is False. See Also: numpy.cov numpy.ma.cumsum(self, axis=None, dtype=None, out=None) = Return the cumulative sum of the elements along the given axis. The cumulative sum is calculated over the ﬂattened array by default, otherwise over the speciﬁed axis. Masked values are set to 0 internally during the computation. However, their position is saved, and the result will be masked at the same locations. Parameters axis : {None, -1, int}, optional Axis along which the sum is computed. The default (axis = None) is to compute over the ﬂattened array. axis may be negative, in which case it counts from the last to the ﬁrst axis. dtype : {None, dtype}, optional Type of the returned array and of the accumulator in which the elements are summed. If dtype is not speciﬁed, it defaults to the dtype of a, unless a has an integer dtype with a precision less than that of the default platform integer. In that case, the default platform integer is used. out : ndarray, 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. Returns cumsum : ndarray. A new array holding the result is returned unless out is speciﬁed, in which case a reference to out is returned. 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 overﬂow. 1.7. Masked arrays 375 NumPy Reference, Release 1.8.1 Examples >>> marr= np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0]) >>> print marr.cumsum() [0 1 3 -- -- -- 9 16 24 33] numpy.ma.cumprod(self, axis=None, dtype=None, out=None) = Return the cumulative product of the elements along the given axis. The cumulative product is taken over the ﬂattened array by default, otherwise over the speciﬁed 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. Parameters axis : {None, -1, int}, optional Axis along which the product is computed. The default (axis = None) is to compute over the ﬂattened array. dtype : {None, dtype}, optional Determines the type of the returned array and of the accumulator where the elements are multiplied. If dtype has the value None and the type of a is an integer type of precision less than the default platform integer, then the default platform integer precision is used. Otherwise, the dtype is the same as that of a. out : ndarray, 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. Returns cumprod : ndarray A new array holding the result is returned unless out is speciﬁed, in which case a refer- ence to out is returned. 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 overﬂow. numpy.ma.mean(self, axis=None, dtype=None, out=None) = Returns the average of the array elements. Masked entries are ignored. The average is taken over the ﬂattened array by default, otherwise over the speciﬁed axis. Refer to numpy.mean for the full documentation. Parameters a : array_like Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted. axis : int, optional Axis along which the means are computed. The default is to compute the mean of the ﬂattened array. dtype : dtype, optional 376 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Type to use in computing the mean. For integer inputs, the default is ﬂoat64; for ﬂoating point, inputs it is the same as the input dtype. out : 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 mean : ndarray, see dtype parameter above If out=None, returns a new array containing the mean values, otherwise a reference to the output array is returned. See Also: numpy.ma.mean Equivalent function. numpy.mean Equivalent function on non-masked arrays. numpy.ma.average Weighted average. Examples >>> 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 numpy.ma.median(a, axis=None, out=None, overwrite_input=False) Compute the median along the speciﬁed axis. Returns the median of the array elements. Parameters a : array_like Input array or object that can be converted to an array. axis : int, optional Axis along which the medians are computed. The default (None) is to compute the median along a ﬂattened version of the array. out : ndarray, 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. overwrite_input : bool, optional If True, then allow use of memory of input array (a) for calculations. The input array will be modiﬁed by the call to median. This will save memory when you do not need to preserve the contents of the input array. Treat the input as undeﬁned, but it will probably be fully or partially sorted. Default is False. Note that, if overwrite_input is True, and the input is not already an ndarray, an error will be raised. 1.7. Masked arrays 377 NumPy Reference, Release 1.8.1 Returns median : ndarray A new array holding the result is returned unless out is speciﬁed, in which case a refer- ence to out is returned. Return data-type is ﬂoat64 for integers and ﬂoats smaller than ﬂoat64, or the input data-type, otherwise. See Also: mean Notes Given a vector V with N non masked values, the median of V is the middle value of a sorted copy of V(Vs) - i.e. Vs[(N-1)/2], when N is odd, or {Vs[N/2 - 1] + Vs[N/2]}/2 when N is even. Examples >>> x= np.ma.array(np.arange(8), mask=[0]*4+[1]*4) >>> np.ma.extras.median(x) 1.5 >>> x= np.ma.array(np.arange(10).reshape(2,5), mask=[0]*6+[1]*4) >>> np.ma.extras.median(x) 2.5 >>> np.ma.extras.median(x, axis=-1, overwrite_input=True) masked_array(data = [ 2. 5.], mask = False, fill_value = 1e+20) numpy.ma.power(a, b, third=None) Returns element-wise base array raised to power from second array. This is the masked array version of numpy.power. For details see numpy.power. See Also: numpy.power Notes The out argument to numpy.power is not supported, third has to be None. numpy.ma.prod(self, axis=None, dtype=None, out=None) = Return the product of the array elements over the given axis. Masked elements are set to 1 internally for computation. Parameters axis : {None, int}, optional Axis over which the product is taken. If None is used, then the product is over all the array elements. dtype : {None, dtype}, optional Determines the type of the returned array and of the accumulator where the elements are multiplied. If dtype has the value None and the type of a is an integer type of precision less than the default platform integer, then the default platform integer precision is used. Otherwise, the dtype is the same as that of a. out : {None, array}, optional 378 Chapter 1. Array objects NumPy Reference, Release 1.8.1 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 product_along_axis : {array, scalar}, see dtype parameter above. Returns an array whose shape is the same as a with the speciﬁed axis removed. Returns a 0d array when a is 1d or axis=None. Returns a reference to the speciﬁed output array if speciﬁed. See Also: prod equivalent function Notes Arithmetic is modular when using integer types, and no error is raised on overﬂow. Examples >>> np.prod([1.,2.]) 2.0 >>> np.prod([1.,2.], dtype=np.int32) 2 >>> np.prod([[1.,2.],[3.,4.]]) 24.0 >>> np.prod([[1.,2.],[3.,4.]], axis=1) array([ 2., 12.]) numpy.ma.std(self, axis=None, dtype=None, out=None, ddof=0) = Compute the standard deviation along the speciﬁed axis. Returns the standard deviation, a measure of the spread of a distribution, of the array elements. The standard deviation is computed for the ﬂattened array by default, otherwise over the speciﬁed axis. Parameters a : array_like Calculate the standard deviation of these values. axis : int, optional Axis along which the standard deviation is computed. The default is to compute the standard deviation of the ﬂattened array. dtype : dtype, optional Type to use in computing the standard deviation. For arrays of integer type the default is ﬂoat64, for arrays of ﬂoat types it is the same as the array type. out : ndarray, optional Alternative output array in which to place the result. It must have the same shape as the expected output but the type (of the calculated values) will be cast if necessary. ddof : int, optional Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero. keepdims : bool, optional 1.7. Masked arrays 379 NumPy Reference, Release 1.8.1 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 original arr. Returns standard_deviation : ndarray, see dtype parameter above. If out is None, return a new array containing the standard deviation, otherwise return a reference to the output array. See Also: var, mean, nanmean, nanstd, nanvar numpy.doc.ufuncs Section “Output arguments” Notes The standard deviation is the square root of the average of the squared deviations from the mean, i.e., std = sqrt(mean(abs(x - x.mean())**2)). The average squared deviation is normally calculated as x.sum() / N, where N = len(x). If, however, ddof is speciﬁed, the divisor N - ddof is used instead. In standard statistical practice, ddof=1 provides an unbiased estimator of the variance of the inﬁnite population. ddof=0 provides a maximum likelihood estimate of the variance for normally distributed variables. The standard deviation computed in this function is the square root of the estimated variance, so even with ddof=1, it will not be an unbiased estimate of the standard deviation per se. Note that, for complex numbers, std takes the absolute value before squaring, so that the result is always real and nonnegative. For ﬂoating-point input, the std is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for ﬂoat32 (see example below). Specifying a higher- accuracy accumulator using the dtype keyword can alleviate this issue. Examples >>> a= np.array([[1,2], [3,4]]) >>> np.std(a) 1.1180339887498949 >>> np.std(a, axis=0) array([ 1., 1.]) >>> np.std(a, axis=1) array([ 0.5, 0.5]) In single precision, std() can be inaccurate: >>> a= np.zeros((2,512 *512), dtype=np.float32) >>> a[0,:]= 1.0 >>> a[1,:]= 0.1 >>> np.std(a) 0.45172946707416706 Computing the standard deviation in ﬂoat64 is more accurate: >>> np.std(a, dtype=np.float64) 0.44999999925552653 numpy.ma.sum(self, axis=None, dtype=None, out=None) = Return the sum of the array elements over the given axis. Masked elements are set to 0 internally. 380 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Parameters axis : {None, -1, int}, optional Axis along which the sum is computed. The default (axis = None) is to compute over the ﬂattened array. dtype : {None, dtype}, optional Determines the type of the returned array and of the accumulator where the elements are summed. If dtype has the value None and the type of a is an integer type of precision less than the default platform integer, then the default platform integer precision is used. Otherwise, the dtype is the same as that of a. out : {None, ndarray}, 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. Returns sum_along_axis : MaskedArray or scalar An array with the same shape as self, with the speciﬁed axis removed. If self is a 0-d array, or if axis is None, a scalar is returned. If an output array is speciﬁed, a reference to out is returned. Examples >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> print x.sum() 25 >>> print x.sum(axis=1) [4 5 16] >>> print x.sum(axis=0) [8 5 12] >>> print type(x.sum(axis=0, dtype=np.int64)[0]) numpy.ma.var(self, axis=None, dtype=None, out=None, ddof=0) = Compute the variance along the speciﬁed axis. Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the ﬂattened array by default, otherwise over the speciﬁed axis. Parameters a : array_like Array containing numbers whose variance is desired. If a is not an array, a conversion is attempted. axis : int, optional Axis along which the variance is computed. The default is to compute the variance of the ﬂattened array. dtype : data-type, optional Type to use in computing the variance. For arrays of integer type the default is ﬂoat32; for arrays of ﬂoat types it is the same as the array type. 1.7. Masked arrays 381 NumPy Reference, Release 1.8.1 out : ndarray, 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, 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. keepdims : bool, 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 original arr. Returns variance : ndarray, see dtype parameter above If out=None, returns a new array containing the variance; otherwise, a reference to the output array is returned. See Also: std, mean, nanmean, nanstd, nanvar numpy.doc.ufuncs Section “Output arguments” Notes The variance is the average of the squared deviations from the mean, i.e., var = mean(abs(x - x.mean())**2). The mean is normally calculated as x.sum() / N, where N = len(x). If, however, ddof is speciﬁed, the divisor N - ddof is used instead. In standard statistical practice, ddof=1 provides an unbiased estimator of the variance of a hypothetical inﬁnite population. ddof=0 provides a maximum likelihood estimate of the variance for normally distributed variables. Note that for complex numbers, the absolute value is taken before squaring, so that the result is always real and nonnegative. For ﬂoating-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 ﬂoat32 (see example below). Specifying a higher-accuracy accumulator using the dtype keyword can alleviate this issue. Examples >>> 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) 0.20405951142311096 382 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Computing the variance in ﬂoat64 is more accurate: >>> np.var(a, dtype=np.float64) 0.20249999932997387 >>> ((1-0.55)**2+(0.1-0.55)**2)/2 0.20250000000000001 MaskedArray.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 axis : int, optional Axis over which the anomalies are taken. The default is to use the mean of the ﬂattened array as reference. dtype : dtype, optional Type to use in computing the variance. For arrays of integer type the default is ﬂoat32; for arrays of ﬂoat types it is the same as the array type. See Also: mean Compute the mean of the array. Examples >>> a= np.ma.array([1,2,3]) >>> a.anom() masked_array(data = [-1. 0. 1.], mask = False, fill_value = 1e+20) MaskedArray.cumprod(axis=None, dtype=None, out=None) Return the cumulative product of the elements along the given axis. The cumulative product is taken over the ﬂattened array by default, otherwise over the speciﬁed 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. Parameters axis : {None, -1, int}, optional Axis along which the product is computed. The default (axis = None) is to compute over the ﬂattened array. dtype : {None, dtype}, optional Determines the type of the returned array and of the accumulator where the elements are multiplied. If dtype has the value None and the type of a is an integer type of precision less than the default platform integer, then the default platform integer precision is used. Otherwise, the dtype is the same as that of a. out : ndarray, 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. 1.7. Masked arrays 383 NumPy Reference, Release 1.8.1 Returns cumprod : ndarray A new array holding the result is returned unless out is speciﬁed, in which case a refer- ence to out is returned. 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 overﬂow. MaskedArray.cumsum(axis=None, dtype=None, out=None) Return the cumulative sum of the elements along the given axis. The cumulative sum is calculated over the ﬂattened array by default, otherwise over the speciﬁed axis. Masked values are set to 0 internally during the computation. However, their position is saved, and the result will be masked at the same locations. Parameters axis : {None, -1, int}, optional Axis along which the sum is computed. The default (axis = None) is to compute over the ﬂattened array. axis may be negative, in which case it counts from the last to the ﬁrst axis. dtype : {None, dtype}, optional Type of the returned array and of the accumulator in which the elements are summed. If dtype is not speciﬁed, it defaults to the dtype of a, unless a has an integer dtype with a precision less than that of the default platform integer. In that case, the default platform integer is used. out : ndarray, 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. Returns cumsum : ndarray. A new array holding the result is returned unless out is speciﬁed, in which case a reference to out is returned. 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 overﬂow. Examples >>> marr= np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0]) >>> print marr.cumsum() [0 1 3 -- -- -- 9 16 24 33] MaskedArray.mean(axis=None, dtype=None, out=None) Returns the average of the array elements. Masked entries are ignored. The average is taken over the ﬂattened array by default, otherwise over the speciﬁed axis. Refer to numpy.mean for the full documentation. Parameters a : array_like 384 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted. axis : int, optional Axis along which the means are computed. The default is to compute the mean of the ﬂattened array. dtype : dtype, optional Type to use in computing the mean. For integer inputs, the default is ﬂoat64; for ﬂoating point, inputs it is the same as the input dtype. out : 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 mean : ndarray, see dtype parameter above If out=None, returns a new array containing the mean values, otherwise a reference to the output array is returned. See Also: numpy.ma.mean Equivalent function. numpy.mean Equivalent function on non-masked arrays. numpy.ma.average Weighted average. Examples >>> 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 MaskedArray.prod(axis=None, dtype=None, out=None) Return the product of the array elements over the given axis. Masked elements are set to 1 internally for computation. Parameters axis : {None, int}, optional Axis over which the product is taken. If None is used, then the product is over all the array elements. dtype : {None, dtype}, optional Determines the type of the returned array and of the accumulator where the elements are multiplied. If dtype has the value None and the type of a is an integer type of precision less than the default platform integer, then the default platform integer precision is used. Otherwise, the dtype is the same as that of a. out : {None, array}, optional 1.7. Masked arrays 385 NumPy Reference, Release 1.8.1 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 product_along_axis : {array, scalar}, see dtype parameter above. Returns an array whose shape is the same as a with the speciﬁed axis removed. Returns a 0d array when a is 1d or axis=None. Returns a reference to the speciﬁed output array if speciﬁed. See Also: prod equivalent function Notes Arithmetic is modular when using integer types, and no error is raised on overﬂow. Examples >>> np.prod([1.,2.]) 2.0 >>> np.prod([1.,2.], dtype=np.int32) 2 >>> np.prod([[1.,2.],[3.,4.]]) 24.0 >>> np.prod([[1.,2.],[3.,4.]], axis=1) array([ 2., 12.]) MaskedArray.std(axis=None, dtype=None, out=None, ddof=0) Compute the standard deviation along the speciﬁed axis. Returns the standard deviation, a measure of the spread of a distribution, of the array elements. The standard deviation is computed for the ﬂattened array by default, otherwise over the speciﬁed axis. Parameters a : array_like Calculate the standard deviation of these values. axis : int, optional Axis along which the standard deviation is computed. The default is to compute the standard deviation of the ﬂattened array. dtype : dtype, optional Type to use in computing the standard deviation. For arrays of integer type the default is ﬂoat64, for arrays of ﬂoat types it is the same as the array type. out : ndarray, optional Alternative output array in which to place the result. It must have the same shape as the expected output but the type (of the calculated values) will be cast if necessary. ddof : int, optional Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero. keepdims : bool, optional 386 Chapter 1. Array objects NumPy Reference, Release 1.8.1 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 original arr. Returns standard_deviation : ndarray, see dtype parameter above. If out is None, return a new array containing the standard deviation, otherwise return a reference to the output array. See Also: var, mean, nanmean, nanstd, nanvar numpy.doc.ufuncs Section “Output arguments” Notes The standard deviation is the square root of the average of the squared deviations from the mean, i.e., std = sqrt(mean(abs(x - x.mean())**2)). The average squared deviation is normally calculated as x.sum() / N, where N = len(x). If, however, ddof is speciﬁed, the divisor N - ddof is used instead. In standard statistical practice, ddof=1 provides an unbiased estimator of the variance of the inﬁnite population. ddof=0 provides a maximum likelihood estimate of the variance for normally distributed variables. The standard deviation computed in this function is the square root of the estimated variance, so even with ddof=1, it will not be an unbiased estimate of the standard deviation per se. Note that, for complex numbers, std takes the absolute value before squaring, so that the result is always real and nonnegative. For ﬂoating-point input, the std is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for ﬂoat32 (see example below). Specifying a higher- accuracy accumulator using the dtype keyword can alleviate this issue. Examples >>> a= np.array([[1,2], [3,4]]) >>> np.std(a) 1.1180339887498949 >>> np.std(a, axis=0) array([ 1., 1.]) >>> np.std(a, axis=1) array([ 0.5, 0.5]) In single precision, std() can be inaccurate: >>> a= np.zeros((2,512 *512), dtype=np.float32) >>> a[0,:]= 1.0 >>> a[1,:]= 0.1 >>> np.std(a) 0.45172946707416706 Computing the standard deviation in ﬂoat64 is more accurate: >>> np.std(a, dtype=np.float64) 0.44999999925552653 MaskedArray.sum(axis=None, dtype=None, out=None) Return the sum of the array elements over the given axis. Masked elements are set to 0 internally. 1.7. Masked arrays 387 NumPy Reference, Release 1.8.1 Parameters axis : {None, -1, int}, optional Axis along which the sum is computed. The default (axis = None) is to compute over the ﬂattened array. dtype : {None, dtype}, optional Determines the type of the returned array and of the accumulator where the elements are summed. If dtype has the value None and the type of a is an integer type of precision less than the default platform integer, then the default platform integer precision is used. Otherwise, the dtype is the same as that of a. out : {None, ndarray}, 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. Returns sum_along_axis : MaskedArray or scalar An array with the same shape as self, with the speciﬁed axis removed. If self is a 0-d array, or if axis is None, a scalar is returned. If an output array is speciﬁed, a reference to out is returned. Examples >>> x= np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0]+[1,0]*4) >>> print x [[1 -- 3] [-- 5 --] [7 -- 9]] >>> print x.sum() 25 >>> print x.sum(axis=1) [4 5 16] >>> print x.sum(axis=0) [8 5 12] >>> print type(x.sum(axis=0, dtype=np.int64)[0]) MaskedArray.var(axis=None, dtype=None, out=None, ddof=0) Compute the variance along the speciﬁed axis. Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the ﬂattened array by default, otherwise over the speciﬁed axis. Parameters a : array_like Array containing numbers whose variance is desired. If a is not an array, a conversion is attempted. axis : int, optional Axis along which the variance is computed. The default is to compute the variance of the ﬂattened array. dtype : data-type, optional Type to use in computing the variance. For arrays of integer type the default is ﬂoat32; for arrays of ﬂoat types it is the same as the array type. 388 Chapter 1. Array objects NumPy Reference, Release 1.8.1 out : ndarray, 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, 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. keepdims : bool, 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 original arr. Returns variance : ndarray, see dtype parameter above If out=None, returns a new array containing the variance; otherwise, a reference to the output array is returned. See Also: std, mean, nanmean, nanstd, nanvar numpy.doc.ufuncs Section “Output arguments” Notes The variance is the average of the squared deviations from the mean, i.e., var = mean(abs(x - x.mean())**2). The mean is normally calculated as x.sum() / N, where N = len(x). If, however, ddof is speciﬁed, the divisor N - ddof is used instead. In standard statistical practice, ddof=1 provides an unbiased estimator of the variance of a hypothetical inﬁnite population. ddof=0 provides a maximum likelihood estimate of the variance for normally distributed variables. Note that for complex numbers, the absolute value is taken before squaring, so that the result is always real and nonnegative. For ﬂoating-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 ﬂoat32 (see example below). Specifying a higher-accuracy accumulator using the dtype keyword can alleviate this issue. Examples >>> 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) 0.20405951142311096 1.7. Masked arrays 389 NumPy Reference, Release 1.8.1 Computing the variance in ﬂoat64 is more accurate: >>> np.var(a, dtype=np.float64) 0.20249999932997387 >>> ((1-0.55)**2+(0.1-0.55)**2)/2 0.20250000000000001 Minimum/maximum ma.argmax(a[, axis, ﬁll_value]) Function version of the eponymous method. ma.argmin(a[, axis, ﬁll_value]) Returns array of indices of the maximum values along the given axis. ma.max(obj[, axis, out, ﬁll_value]) Return the maximum along a given axis. ma.min(obj[, axis, out, ﬁll_value]) Return the minimum along a given axis. ma.ptp(obj[, axis, out, ﬁll_value]) Return (maximum - minimum) along the the given dimension (i.e. ma.MaskedArray.argmax([axis, ﬁll_value, out]) Returns array of indices of the maximum values along the given axis. ma.MaskedArray.argmin([axis, ﬁll_value, out]) Return array of indices to the minimum values along the given axis. ma.MaskedArray.max([axis, out, ﬁll_value]) Return the maximum along a given axis. ma.MaskedArray.min([axis, out, ﬁll_value]) Return the minimum along a given axis. ma.MaskedArray.ptp([axis, out, ﬁll_value]) Return (maximum - minimum) along the the given dimension (i.e. numpy.ma.argmax(a, axis=None, ﬁll_value=None) Function version of the eponymous method. numpy.ma.argmin(a, axis=None, ﬁll_value=None) Returns array of indices of the maximum values along the given axis. Masked values are treated as if they had the value ﬁll_value. Parameters axis : {None, integer} If None, the index is into the ﬂattened array, otherwise along the speciﬁed axis ﬁll_value : {var}, optional Value used to ﬁll in the masked values. If None, the output of maxi- mum_ﬁll_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 >>> a= np.arange(6).reshape(2,3) >>> a.argmax() 5 >>> a.argmax(0) array([1, 1, 1]) >>> a.argmax(1) array([2, 2]) numpy.ma.max(obj, axis=None, out=None, ﬁll_value=None) Return the maximum along a given axis. 390 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Parameters axis : {None, int}, optional Axis along which to operate. By default, axis is None and the ﬂattened input is used. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. ﬁll_value : {var}, optional Value used to ﬁll in the masked values. If None, use the output of maxi- mum_ﬁll_value(). Returns amax : array_like New array holding the result. If out was speciﬁed, out is returned. See Also: maximum_fill_value Returns the maximum ﬁlling value for a given datatype. numpy.ma.min(obj, axis=None, out=None, ﬁll_value=None) Return the minimum along a given axis. Parameters axis : {None, int}, optional Axis along which to operate. By default, axis is None and the ﬂattened input is used. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. ﬁll_value : {var}, optional Value used to ﬁll in the masked values. If None, use the output of minimum_fill_value. Returns amin : array_like New array holding the result. If out was speciﬁed, out is returned. See Also: minimum_fill_value Returns the minimum ﬁlling value for a given datatype. numpy.ma.ptp(obj, axis=None, out=None, ﬁll_value=None) Return (maximum - minimum) along the the given dimension (i.e. peak-to-peak value). Parameters axis : {None, int}, optional Axis along which to ﬁnd the peaks. If None (default) the ﬂattened array is used. out : {None, array_like}, optional 1.7. Masked arrays 391 NumPy Reference, Release 1.8.1 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. ﬁll_value : {var}, optional Value used to ﬁll in the masked values. Returns ptp : ndarray. A new array holding the result, unless out was speciﬁed, in which case a reference to out is returned. MaskedArray.argmax(axis=None, ﬁll_value=None, out=None) Returns array of indices of the maximum values along the given axis. Masked values are treated as if they had the value ﬁll_value. Parameters axis : {None, integer} If None, the index is into the ﬂattened array, otherwise along the speciﬁed axis ﬁll_value : {var}, optional Value used to ﬁll in the masked values. If None, the output of maxi- mum_ﬁll_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 >>> a= np.arange(6).reshape(2,3) >>> a.argmax() 5 >>> a.argmax(0) array([1, 1, 1]) >>> a.argmax(1) array([2, 2]) MaskedArray.argmin(axis=None, ﬁll_value=None, out=None) Return array of indices to the minimum values along the given axis. Parameters axis : {None, integer} If None, the index is into the ﬂattened array, otherwise along the speciﬁed axis ﬁll_value : {var}, optional Value used to ﬁll in the masked values. If None, the output of mini- mum_ﬁll_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, scalar} 392 Chapter 1. Array objects NumPy Reference, Release 1.8.1 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 >>> x= np.ma.array(arange(4), mask=[1,1,0,0]) >>> x.shape=(2,2) >>> print x [[-- --] [2 3]] >>> print x.argmin(axis=0, fill_value=-1) [0 0] >>> print x.argmin(axis=0, fill_value=9) [1 1] MaskedArray.max(axis=None, out=None, ﬁll_value=None) Return the maximum along a given axis. Parameters axis : {None, int}, optional Axis along which to operate. By default, axis is None and the ﬂattened input is used. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. ﬁll_value : {var}, optional Value used to ﬁll in the masked values. If None, use the output of maxi- mum_ﬁll_value(). Returns amax : array_like New array holding the result. If out was speciﬁed, out is returned. See Also: maximum_fill_value Returns the maximum ﬁlling value for a given datatype. MaskedArray.min(axis=None, out=None, ﬁll_value=None) Return the minimum along a given axis. Parameters axis : {None, int}, optional Axis along which to operate. By default, axis is None and the ﬂattened input is used. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. ﬁll_value : {var}, optional Value used to ﬁll in the masked values. If None, use the output of minimum_fill_value. 1.7. Masked arrays 393 NumPy Reference, Release 1.8.1 Returns amin : array_like New array holding the result. If out was speciﬁed, out is returned. See Also: minimum_fill_value Returns the minimum ﬁlling value for a given datatype. MaskedArray.ptp(axis=None, out=None, ﬁll_value=None) Return (maximum - minimum) along the the given dimension (i.e. peak-to-peak value). Parameters axis : {None, int}, optional Axis along which to ﬁnd the peaks. If None (default) the ﬂattened 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. ﬁll_value : {var}, optional Value used to ﬁll in the masked values. Returns ptp : ndarray. A new array holding the result, unless out was speciﬁed, in which case a reference to out is returned. Sorting ma.argsort(a[, axis, kind, order, ﬁll_value]) Return an ndarray of indices that sort the array along the speciﬁed axis. ma.sort(a[, axis, kind, order, endwith, ...]) Sort the array, in-place ma.MaskedArray.argsort([axis, kind, order, ...]) Return an ndarray of indices that sort the array along the speciﬁed axis. ma.MaskedArray.sort([axis, kind, order, ...]) Sort the array, in-place numpy.ma.argsort(a, axis=None, kind=’quicksort’, order=None, ﬁll_value=None) Return an ndarray of indices that sort the array along the speciﬁed axis. Masked values are ﬁlled beforehand to ﬁll_value. Parameters axis : int, optional Axis along which to sort. The default is -1 (last axis). If None, the ﬂattened array is used. ﬁll_value : var, optional Value used to ﬁll the array before sorting. The default is the ﬁll_value attribute of the input array. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional Sorting algorithm. order : list, optional 394 Chapter 1. Array objects NumPy Reference, Release 1.8.1 When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. Returns index_array : ndarray, int Array of indices that sort a along the speciﬁed axis. In other words, a[index_array] yields a sorted a. See Also: sort Describes sorting algorithms used. lexsort Indirect stable sort with multiple keys. ndarray.sort Inplace sort. Notes See sort for notes on the different sorting algorithms. Examples >>> 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]) numpy.ma.sort(a, axis=-1, kind=’quicksort’, order=None, endwith=True, ﬁll_value=None) Sort the array, in-place Parameters a : array_like Array to be sorted. axis : int, optional Axis along which to sort. If None, the array is ﬂattened before sorting. The default is -1, which sorts along the last axis. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional Sorting algorithm. Default is ‘quicksort’. order : list, optional When a is a structured array, this argument speciﬁes which ﬁelds to compare ﬁrst, sec- ond, and so on. This list does not need to include all of the ﬁelds. endwith : {True, False}, optional Whether missing values (if any) should be forced in the upper indices (at the end of the array) (True) or lower indices (at the beginning). ﬁll_value : {var}, optional 1.7. Masked arrays 395 NumPy Reference, Release 1.8.1 Value used internally for the masked values. If fill_value is not None, it supersedes endwith. Returns sorted_array : ndarray Array of the same type and shape as a. See Also: ndarray.sort Method to sort an array in-place. argsort Indirect sort. lexsort Indirect stable sort on multiple keys. searchsorted Find elements in a sorted array. Notes See sort for notes on the different sorting algorithms. Examples >>> a= ma.array([1,2,5,4,3],mask=[0,1,0,1,0]) >>> # Default >>> a.sort() >>> print a [1 3 5 -- --] >>> a= ma.array([1,2,5,4,3],mask=[0,1,0,1,0]) >>> # Put missing values in the front >>> a.sort(endwith=False) >>> print a [-- -- 1 3 5] >>> a= 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) >>> print a [1 -- -- 3 5] MaskedArray.argsort(axis=None, kind=’quicksort’, order=None, ﬁll_value=None) Return an ndarray of indices that sort the array along the speciﬁed axis. Masked values are ﬁlled beforehand to fill_value. Parameters axis : int, optional Axis along which to sort. The default is -1 (last axis). If None, the ﬂattened array is used. ﬁll_value : var, optional Value used to ﬁll the array before sorting. The default is the fill_value attribute of the input array. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional 396 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Sorting algorithm. order : list, optional When a is an array with ﬁelds deﬁned, this argument speciﬁes which ﬁelds to compare ﬁrst, second, etc. Not all ﬁelds need be speciﬁed. Returns index_array : ndarray, int Array of indices that sort a along the speciﬁed axis. In other words, a[index_array] yields a sorted a. See Also: sort Describes sorting algorithms used. lexsort Indirect stable sort with multiple keys. ndarray.sort Inplace sort. Notes See sort for notes on the different sorting algorithms. Examples >>> 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]) MaskedArray.sort(axis=-1, kind=’quicksort’, order=None, endwith=True, ﬁll_value=None) Sort the array, in-place Parameters a : array_like Array to be sorted. axis : int, optional Axis along which to sort. If None, the array is ﬂattened before sorting. The default is -1, which sorts along the last axis. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional Sorting algorithm. Default is ‘quicksort’. order : list, optional When a is a structured array, this argument speciﬁes which ﬁelds to compare ﬁrst, sec- ond, and so on. This list does not need to include all of the ﬁelds. endwith : {True, False}, optional Whether missing values (if any) should be forced in the upper indices (at the end of the array) (True) or lower indices (at the beginning). 1.7. Masked arrays 397 NumPy Reference, Release 1.8.1 ﬁll_value : {var}, optional Value used internally for the masked values. If fill_value is not None, it supersedes endwith. Returns sorted_array : ndarray Array of the same type and shape as a. See Also: ndarray.sort Method to sort an array in-place. argsort Indirect sort. lexsort Indirect stable sort on multiple keys. searchsorted Find elements in a sorted array. Notes See sort for notes on the different sorting algorithms. Examples >>> a= ma.array([1,2,5,4,3],mask=[0,1,0,1,0]) >>> # Default >>> a.sort() >>> print a [1 3 5 -- --] >>> a= ma.array([1,2,5,4,3],mask=[0,1,0,1,0]) >>> # Put missing values in the front >>> a.sort(endwith=False) >>> print a [-- -- 1 3 5] >>> a= 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) >>> print a [1 -- -- 3 5] Algebra ma.diag(v[, k]) Extract a diagonal or construct a diagonal array. ma.dot(a, b[, strict]) Return the dot product of two arrays. ma.identity(n[, dtype]) Return the identity array. ma.inner(a, b) Inner product of two arrays. ma.innerproduct(a, b) Inner product of two arrays. ma.outer(a, b) Compute the outer product of two vectors. ma.outerproduct(a, b) Compute the outer product of two vectors. ma.trace(self[, offset, axis1, axis2, ...]) Return the sum along diagonals of the array. Continued on next page 398 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Table 1.98 – continued from previous page ma.transpose(a[, axes]) Permute the dimensions of an array. ma.MaskedArray.trace([offset, axis1, axis2, ...]) Return the sum along diagonals of the array. ma.MaskedArray.transpose(*axes) Returns a view of the array with axes transposed. numpy.ma.diag(v, k=0) Extract a diagonal or construct a diagonal array. This function is the equivalent of numpy.diag that takes masked values into account, see numpy.diag for details. See Also: numpy.diag Equivalent function for ndarrays. numpy.ma.dot(a, b, strict=False) Return the dot product of two arrays. Note: Works only with 2-D arrays at the moment. This function is the equivalent of numpy.dot that takes masked values into account, see numpy.dot for details. Parameters a, b : ndarray Inputs arrays. strict : bool, 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. See Also: numpy.dot Equivalent function for ndarrays. Examples >>> a= ma.array([[1,2,3], [4,5,6]], mask=[[1,0,0], [0,0,0]]) >>> b= ma.array([[1,2], [3,4], [5,6]], mask=[[1,0], [0,0], [0,0]]) >>> np.ma.dot(a, b) masked_array(data = [[21 26] [45 64]], mask = [[False False] [False False]], fill_value = 999999) >>> np.ma.dot(a, b, strict=True) masked_array(data = [[-- --] [-- 64]], mask = 1.7. Masked arrays 399 NumPy Reference, Release 1.8.1 [[ True True] [ True False]], fill_value = 999999) numpy.ma.identity(n, dtype=None) = Return the identity array. The identity array is a square array with ones on the main diagonal. Parameters n : int Number of rows (and columns) in n x n output. dtype : data-type, optional Data-type of the output. Defaults to float. Returns out : ndarray n x n array with its main diagonal set to one, and all other elements 0. Examples >>> np.identity(3) array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]]) numpy.ma.inner(a, b) Inner product of two arrays. Ordinary inner product of vectors for 1-D arrays (without complex conjugation), in higher dimensions a sum product over the last axes. Parameters a, b : array_like If a and b are nonscalar, their last dimensions of must match. Returns out : ndarray out.shape = a.shape[:-1] + b.shape[:-1] Raises ValueError If the last dimension of a and b has different size. See Also: tensordot Sum products over arbitrary axes. dot Generalised matrix product, using second last dimension of b. einsum Einstein summation convention. 400 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Notes Masked values are replaced by 0. Examples Ordinary inner product for vectors: >>> a= np.array([1,2,3]) >>> b= np.array([0,1,0]) >>> np.inner(a, b) 2 A multidimensional example: >>> a= np.arange(24).reshape((2,3,4)) >>> b= np.arange(4) >>> np.inner(a, b) array([[ 14, 38, 62], [ 86, 110, 134]]) An example where b is a scalar: >>> np.inner(np.eye(2),7) array([[ 7., 0.], [ 0., 7.]]) numpy.ma.innerproduct(a, b) Inner product of two arrays. Ordinary inner product of vectors for 1-D arrays (without complex conjugation), in higher dimensions a sum product over the last axes. Parameters a, b : array_like If a and b are nonscalar, their last dimensions of must match. Returns out : ndarray out.shape = a.shape[:-1] + b.shape[:-1] Raises ValueError If the last dimension of a and b has different size. See Also: tensordot Sum products over arbitrary axes. dot Generalised matrix product, using second last dimension of b. einsum Einstein summation convention. Notes Masked values are replaced by 0. 1.7. Masked arrays 401 NumPy Reference, Release 1.8.1 Examples Ordinary inner product for vectors: >>> a= np.array([1,2,3]) >>> b= np.array([0,1,0]) >>> np.inner(a, b) 2 A multidimensional example: >>> a= np.arange(24).reshape((2,3,4)) >>> b= np.arange(4) >>> np.inner(a, b) array([[ 14, 38, 62], [ 86, 110, 134]]) An example where b is a scalar: >>> np.inner(np.eye(2),7) array([[ 7., 0.], [ 0., 7.]]) numpy.ma.outer(a, b) Compute the outer product of two vectors. Given two vectors, a = [a0, a1, ..., aM] and b = [b0, b1, ..., bN], the outer product [R48] is: [[a0*b0 a0*b1 ... a0*bN ] [a1*b0 . [ ... . [aM*b0 aM*bN ]] Parameters a : (M,) array_like First input vector. Input is ﬂattened if not already 1-dimensional. b : (N,) array_like Second input vector. Input is ﬂattened if not already 1-dimensional. Returns out : (M, N) ndarray out[i, j] = a[i] * b[j] See Also: inner, einsum Notes Masked values are replaced by 0. References [R48] 402 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Examples Make a (very coarse) grid for computing a Mandelbrot set: >>> rl= np.outer(np.ones((5,)), np.linspace(-2,2,5)) >>> rl array([[-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.]]) >>> im= np.outer(1j *np.linspace(2,-2,5), np.ones((5,))) >>> im array([[ 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j], [ 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j], [ 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], [ 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j], [ 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]]) >>> grid= rl+ im >>> grid array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j], [-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j], [-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j], [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j], [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]]) An example using a “vector” of letters: >>> x= np.array([’a’,’b’,’c’], dtype=object) >>> np.outer(x, [1,2,3]) array([[a, aa, aaa], [b, bb, bbb], [c, cc, ccc]], dtype=object) numpy.ma.outerproduct(a, b) Compute the outer product of two vectors. Given two vectors, a = [a0, a1, ..., aM] and b = [b0, b1, ..., bN], the outer product [R49] is: [[a0*b0 a0*b1 ... a0*bN ] [a1*b0 . [ ... . [aM*b0 aM*bN ]] Parameters a : (M,) array_like First input vector. Input is ﬂattened if not already 1-dimensional. b : (N,) array_like Second input vector. Input is ﬂattened if not already 1-dimensional. Returns out : (M, N) ndarray out[i, j] = a[i] * b[j] See Also: inner, einsum 1.7. Masked arrays 403 NumPy Reference, Release 1.8.1 Notes Masked values are replaced by 0. References [R49] Examples Make a (very coarse) grid for computing a Mandelbrot set: >>> rl= np.outer(np.ones((5,)), np.linspace(-2,2,5)) >>> rl array([[-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.], [-2., -1., 0., 1., 2.]]) >>> im= np.outer(1j *np.linspace(2,-2,5), np.ones((5,))) >>> im array([[ 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j], [ 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j], [ 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], [ 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j], [ 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]]) >>> grid= rl+ im >>> grid array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j], [-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j], [-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j], [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j], [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]]) An example using a “vector” of letters: >>> x= np.array([’a’,’b’,’c’], dtype=object) >>> np.outer(x, [1,2,3]) array([[a, aa, aaa], [b, bb, bbb], [c, cc, ccc]], dtype=object) numpy.ma.trace(self, offset=0, axis1=0, axis2=1, dtype=None, out=None) a.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. See Also: numpy.trace equivalent function numpy.ma.transpose(a, axes=None) Permute the dimensions of an array. This function is exactly equivalent to numpy.transpose. See Also: 404 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.transpose Equivalent function in top-level NumPy module. Examples >>> import numpy.ma as ma >>> x= ma.arange(4).reshape((2,2)) >>> x[1,1]= ma.masked >>>> x masked_array(data = [[0 1] [2 --]], mask = [[False False] [False True]], fill_value = 999999) >>> ma.transpose(x) masked_array(data = [[0 2] [1 --]], mask = [[False False] [False True]], fill_value = 999999) MaskedArray.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. See Also: numpy.trace equivalent function MaskedArray.transpose(*axes) Returns a view of the array with axes transposed. For a 1-D array, this has no effect. (To change between column and row vectors, ﬁrst cast the 1-D array into a ma- trix object.) For a 2-D array, this is the usual matrix transpose. For an n-D array, if axes are given, their order in- dicates how the axes are permuted (see Examples). If axes are not provided and a.shape = (i[0], i[1], ... i[n-2], i[n-1]), then a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0]). 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 a‘s i-th axis becomes a.transpose()‘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 out : ndarray View of a, with axes suitably permuted. See Also: 1.7. Masked arrays 405 NumPy Reference, Release 1.8.1 ndarray.T Array property returning the array transposed. Examples >>> 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]]) Polynomial ﬁt ma.vander(x[, n]) Generate a Van der Monde matrix. ma.polyfit(x, y, deg[, rcond, full, w, cov]) Least squares polynomial ﬁt. numpy.ma.vander(x, n=None) Generate a Van der Monde matrix. The columns of the output matrix are decreasing powers of the input vector. Speciﬁcally, the i-th output column is the input vector raised element-wise to the power of N - i - 1. Such a matrix with a geometric progression in each row is named for Alexandre-Theophile Vandermonde. Parameters x : array_like 1-D input array. N: int, optional Order of (number of columns in) the output. If N is not speciﬁed, a square array is returned (N = len(x)). Returns out : ndarray Van der Monde matrix of order N. The ﬁrst column is x^(N-1), the second x^(N-2) and so forth. Notes Masked values in the input array result in rows of zeros. Examples >>> x= np.array([1,2,3,5]) >>> N=3 >>> np.vander(x, N) array([[ 1, 1, 1], [ 4, 2, 1], 406 Chapter 1. Array objects NumPy Reference, Release 1.8.1 [ 9, 3, 1], [25, 5, 1]]) >>> np.column_stack([x**(N-1-i) for i in range(N)]) array([[ 1, 1, 1], [ 4, 2, 1], [ 9, 3, 1], [25, 5, 1]]) >>> x= np.array([1,2,3,5]) >>> np.vander(x) array([[ 1, 1, 1, 1], [ 8, 4, 2, 1], [ 27, 9, 3, 1], [125, 25, 5, 1]]) The determinant of a square Vandermonde matrix is the product of the differences between the values of the input vector: >>> np.linalg.det(np.vander(x)) 48.000000000000043 >>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1) 48 numpy.ma.polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False) Least squares polynomial ﬁt. Fit a polynomial p(x) = p[0] * x**deg + ... + p[deg] of degree deg to points (x, y). Returns a vector of coefﬁcients p that minimises the squared error. Parameters x : array_like, shape (M,) x-coordinates of the M sample points (x[i], y[i]). y : array_like, shape (M,) or (M, K) y-coordinates of the sample points. Several data sets of sample points sharing the same x-coordinates can be ﬁtted at once by passing in a 2D-array that contains one dataset per column. deg : int Degree of the ﬁtting polynomial rcond : ﬂoat, optional Relative condition number of the ﬁt. Singular values smaller than this relative to the largest singular value will be ignored. The default value is len(x)*eps, where eps is the relative precision of the ﬂoat type, about 2e-16 in most cases. full : bool, optional Switch determining nature of return value. When it is False (the default) just the coef- ﬁcients are returned, when True diagnostic information from the singular value decom- position is also returned. w : array_like, shape (M,), optional weights to apply to the y-coordinates of the sample points. cov : bool, optional 1.7. Masked arrays 407 NumPy Reference, Release 1.8.1 Return the estimate and the covariance matrix of the estimate If full is True, then cov is not returned. Returns p : ndarray, shape (M,) or (M, K) Polynomial coefﬁcients, highest power ﬁrst. If y was 2-D, the coefﬁcients for k-th data set are in p[:,k]. residuals, rank, singular_values, rcond : present only if full = True Residuals of the least-squares ﬁt, the effective rank of the scaled Vandermonde coefﬁ- cient matrix, its singular values, and the speciﬁed value of rcond. For more details, see linalg.lstsq. V: ndaray, shape (M,M) or (M,M,K) The covariance matrix of the polynomial coefﬁcient estimates. The diagonal of this ma- trix are the variance estimates for each coefﬁcient. If y is a 2-d array, then the covariance matrix for the k-th data set are in V[:,:,k] Warns RankWarning The rank of the coefﬁcient matrix in the least-squares ﬁt is deﬁcient. The warning is only raised if full = False. The warnings can be turned off by >>> import warnings >>> warnings.simplefilter(’ignore’, np.RankWarning) See Also: polyval Computes polynomial values. linalg.lstsq Computes a least-squares ﬁt. scipy.interpolate.UnivariateSpline Computes spline ﬁts. Notes Any masked values in x is propagated in y, and vice-versa. References [R50], [R51] Examples >>> x= np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0]) >>> y= np.array([0.0, 0.8, 0.9, 0.1,-0.8,-1.0]) >>> z= np.polyfit(x, y,3) >>> z array([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) It is convenient to use poly1d objects for dealing with polynomials: 408 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> p= np.poly1d(z) >>> p(0.5) 0.6143849206349179 >>> p(3.5) -0.34732142857143039 >>> p(10) 22.579365079365115 High-order polynomials may oscillate wildly: >>> p30= np.poly1d(np.polyfit(x, y, 30)) /... RankWarning: Polyfit may be poorly conditioned... >>> p30(4) -0.80000000000000204 >>> p30(5) -0.99999999999999445 >>> p30(4.5) -0.10547061179440398 Illustration: >>> import matplotlib.pyplot as plt >>> xp= np.linspace(-2,6, 100) >>> plt.plot(x, y,’.’, xp, p(xp),’-’, xp, p30(xp),’--’) [, , ] >>> plt.ylim(-2,2) (-2, 2) >>> plt.show() 2 1 0 1 2 3 4 5 6 2.0 1.5 1.0 0.5 0.0 0.5 1.0 1.5 2.0 Clipping and rounding ma.around Round an array to the given number of decimals. ma.clip(a, a_min, a_max[, out]) Clip (limit) the values in an array. ma.round(a[, decimals, out]) Return a copy of a, rounded to ‘decimals’ places. ma.MaskedArray.clip(a_min, a_max[, out]) Return an array whose values are limited to [a_min, a_max]. ma.MaskedArray.round([decimals, out]) Return a with each element rounded to the given number of decimals. 1.7. Masked arrays 409 NumPy Reference, Release 1.8.1 numpy.ma.around = Round an array to the given number of decimals. Refer to around for full documentation. See Also: around equivalent function numpy.ma.clip(a, a_min, a_max, out=None) Clip (limit) the values in an array. Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of [0, 1] is speciﬁed, values smaller than 0 become 0, and values larger than 1 become 1. Parameters a : array_like Array containing elements to clip. a_min : scalar or array_like Minimum value. a_max : scalar or array_like Maximum value. If a_min or a_max are array_like, then they will be broadcasted to the shape of a. out : ndarray, optional The results will be placed in this array. It may be the input array for in-place clipping. out must be of the right shape to hold the output. Its type is preserved. Returns clipped_array : ndarray An array with the elements of a, but where values < a_min are replaced with a_min, and those > a_max with a_max. See Also: numpy.doc.ufuncs Section “Output arguments” Examples >>> a= np.arange(10) >>> np.clip(a,1,8) array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8]) >>> a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> np.clip(a,3,6, out=a) array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) >>> a= np.arange(10) >>> a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> np.clip(a, [3,4,1,1,1,4,4,4,4,4],8) array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8]) 410 Chapter 1. Array objects NumPy Reference, Release 1.8.1 numpy.ma.round(a, decimals=0, out=None) Return a copy of a, rounded to ‘decimals’ places. When ‘decimals’ is negative, it speciﬁes the number of positions to the left of the decimal point. The real and imaginary parts of complex numbers are rounded separately. Nothing is done if the array is not of ﬂoat type and ‘decimals’ is greater than or equal to 0. Parameters decimals : int Number of decimals to round to. May be negative. out : array_like Existing array to use for output. If not given, returns a default copy of a. Notes If out is given and does not have a mask attribute, the mask of a is lost! MaskedArray.clip(a_min, a_max, out=None) Return an array whose values are limited to [a_min, a_max]. Refer to numpy.clip for full documentation. See Also: numpy.clip equivalent function MaskedArray.round(decimals=0, out=None) Return a with each element rounded to the given number of decimals. Refer to numpy.around for full documentation. See Also: numpy.around equivalent function Miscellanea ma.allequal(a, b[, ﬁll_value]) Return True if all entries of a and b are equal, using ma.allclose(a, b[, masked_equal, rtol, atol]) Returns True if two arrays are element-wise equal within a tolerance. ma.apply_along_axis(func1d, axis, arr, ...) Apply a function to 1-D slices along the given axis. ma.arange([start,] stop[, step,][, dtype]) Return evenly spaced values within a given interval. ma.choose(indices, choices[, out, mode]) Use an index array to construct a new array from a set of choices. ma.ediff1d(arr[, to_end, to_begin]) Compute the differences between consecutive elements of an array. ma.indices(dimensions[, dtype]) Return an array representing the indices of a grid. ma.where(condition[, x, y]) Return a masked array with elements from x or y, depending on condition. numpy.ma.allequal(a, b, ﬁll_value=True) Return True if all entries of a and b are equal, using ﬁll_value as a truth value where either or both are masked. Parameters a, b : array_like Input arrays to compare. ﬁll_value : bool, optional 1.7. Masked arrays 411 NumPy Reference, Release 1.8.1 Whether masked values in a or b are considered equal (True) or not (False). Returns y : bool Returns True if the two arrays are equal within the given tolerance, False otherwise. If either array contains NaN, then False is returned. See Also: all, any, numpy.ma.allclose Examples >>> a= ma.array([1e10, 1e-7, 42.0], mask=[0,0,1]) >>> a masked_array(data = [10000000000.0 1e-07 --], mask = [False False True], fill_value=1e+20) >>> b= array([1e10, 1e-7,-42.0]) >>> b array([ 1.00000000e+10, 1.00000000e-07, -4.20000000e+01]) >>> ma.allequal(a, b, fill_value=False) False >>> ma.allequal(a, b) True numpy.ma.allclose(a, b, masked_equal=True, rtol=1e-05, atol=1e-08) Returns True if two arrays are element-wise equal within a tolerance. This function is equivalent to allclose except that masked values are treated as equal (default) or unequal, depending on the masked_equal argument. Parameters a, b : array_like Input arrays to compare. masked_equal : bool, optional Whether masked values in a and b are considered equal (True) or not (False). They are considered equal by default. rtol : ﬂoat, optional Relative tolerance. The relative difference is equal to rtol * b. Default is 1e-5. atol : ﬂoat, optional Absolute tolerance. The absolute difference is equal to atol. Default is 1e-8. Returns y : bool Returns True if the two arrays are equal within the given tolerance, False otherwise. If either array contains NaN, then False is returned. See Also: all, any numpy.allclose the non-masked allclose. 412 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Notes If the following equation is element-wise True, then allclose returns True: absolute(‘a‘- ‘b‘)<=(‘atol‘+ ‘rtol‘ * absolute(‘b‘)) Return True if all elements of a and b are equal subject to given tolerances. Examples >>> a= ma.array([1e10, 1e-7, 42.0], mask=[0,0,1]) >>> a masked_array(data = [10000000000.0 1e-07 --], mask = [False False True], fill_value = 1e+20) >>> b= ma.array([1e10, 1e-8,-42.0], mask=[0,0,1]) >>> ma.allclose(a, b) False >>> a= ma.array([1e10, 1e-8, 42.0], mask=[0,0,1]) >>> b= ma.array([1.00001e10, 1e-9,-42.0], mask=[0,0,1]) >>> ma.allclose(a, b) True >>> ma.allclose(a, b, masked_equal=False) False Masked values are not compared directly. >>> a= ma.array([1e10, 1e-8, 42.0], mask=[0,0,1]) >>> b= ma.array([1.00001e10, 1e-9, 42.0], mask=[0,0,1]) >>> ma.allclose(a, b) True >>> ma.allclose(a, b, masked_equal=False) False numpy.ma.apply_along_axis(func1d, axis, arr,*args,**kwargs) Apply a function to 1-D slices along the given axis. Execute func1d(a, *args) where func1d operates on 1-D arrays and a is a 1-D slice of arr along axis. Parameters func1d : function This function should accept 1-D arrays. It is applied to 1-D slices of arr along the speciﬁed axis. axis : integer Axis along which arr is sliced. arr : ndarray Input array. args : any Additional arguments to func1d. Returns apply_along_axis : ndarray The output array. The shape of outarr is identical to the shape of arr, except along the axis dimension, where the length of outarr is equal to the size of the return value of func1d. If func1d returns a scalar outarr will have one fewer dimensions than arr. 1.7. Masked arrays 413 NumPy Reference, Release 1.8.1 See Also: apply_over_axes Apply a function repeatedly over multiple axes. Examples >>> def my_func(a): ... """Average first and last element of a 1-D array""" ... return (a[0]+ a[-1]) * 0.5 >>> b= np.array([[1,2,3], [4,5,6], [7,8,9]]) >>> np.apply_along_axis(my_func,0, b) array([ 4., 5., 6.]) >>> np.apply_along_axis(my_func,1, b) array([ 2., 5., 8.]) For a function that doesn’t return a scalar, the number of dimensions in outarr is the same as arr. >>> b= np.array([[8,1,7], [4,3,9], [5,2,6]]) >>> np.apply_along_axis(sorted,1, b) array([[1, 7, 8], [3, 4, 9], [2, 5, 6]]) numpy.ma.arange([start ], stop[, step], dtype=None) = Return evenly spaced values within a given interval. Values are generated within the half-open interval [start, stop) (in other words, the interval including start but excluding stop). For integer arguments the function is equivalent to the Python built-in range function, but returns an ndarray rather than a list. When using a non-integer step, such as 0.1, the results will often not be consistent. It is better to use linspace for these cases. Parameters start : number, optional Start of interval. The interval includes this value. The default start value is 0. stop : number End of interval. The interval does not include this value, except in some cases where step is not an integer and ﬂoating point round-off affects the length of out. step : number, optional Spacing between values. For any output out, this is the distance between two adjacent values, out[i+1] - out[i]. The default step size is 1. If step is speciﬁed, start must also be given. dtype : dtype The type of the output array. If dtype is not given, infer the data type from the other input arguments. Returns arange : ndarray Array of evenly spaced values. 414 Chapter 1. Array objects NumPy Reference, Release 1.8.1 For ﬂoating point arguments, the length of the result is ceil((stop - start)/step). Because of ﬂoating point overﬂow, this rule may result in the last element of out being greater than stop. See Also: linspace Evenly spaced numbers with careful handling of endpoints. ogrid Arrays of evenly spaced numbers in N-dimensions. mgrid Grid-shaped arrays of evenly spaced numbers in N-dimensions. Examples >>> np.arange(3) array([0, 1, 2]) >>> np.arange(3.0) array([ 0., 1., 2.]) >>> np.arange(3,7) array([3, 4, 5, 6]) >>> np.arange(3,7,2) array([3, 5]) numpy.ma.choose(indices, choices, out=None, mode=’raise’) Use an index array to construct a new array from a set of choices. Given an array of integers and a set of n choice arrays, this method will create a new array that merges each of the choice arrays. Where a value in a is i, the new array will have the value that choices[i] contains in the same place. Parameters a : ndarray of ints This array must contain integers in [0, n-1], where n is the number of choices. choices : sequence of arrays Choice arrays. The index array and all of the choices should be broadcastable to the same shape. out : array, optional If provided, the result will be inserted into this array. It should be of the appropriate shape and dtype. mode : {‘raise’, ‘wrap’, ‘clip’}, optional Speciﬁes how out-of-bounds indices will behave. • ‘raise’ : raise an error • ‘wrap’ : wrap around • ‘clip’ : clip to the range Returns merged_array : array See Also: 1.7. Masked arrays 415 NumPy Reference, Release 1.8.1 choose equivalent function Examples >>> choice= np.array([[1,1,1], [2,2,2], [3,3,3]]) >>> a= np.array([2,1,0]) >>> np.ma.choose(a, choice) masked_array(data = [3 2 1], mask = False, fill_value=999999) numpy.ma.ediff1d(arr, to_end=None, to_begin=None) Compute the differences between consecutive elements of an array. This function is the equivalent of numpy.ediff1d that takes masked values into account, see numpy.ediff1d for details. See Also: numpy.ediff1d Equivalent function for ndarrays. numpy.ma.indices(dimensions, dtype=) Return an array representing the indices of a grid. Compute an array where the subarrays contain index values 0,1,... varying only along the corresponding axis. Parameters dimensions : sequence of ints The shape of the grid. dtype : dtype, optional Data type of the result. Returns grid : ndarray The array of grid indices, grid.shape = (len(dimensions),) + tuple(dimensions). See Also: mgrid, meshgrid Notes The output shape is obtained by prepending the number of dimensions in front of the tuple of dimensions, i.e. if dimensions is a tuple (r0, ..., rN-1) of length N, the output shape is (N,r0,...,rN-1). The subarrays grid[k] contains the N-D array of indices along the k-th axis. Explicitly: grid[k,i0,i1,...,iN-1]= ik Examples >>> grid= np.indices((2,3)) >>> grid.shape (2, 2, 3) >>> grid[0]# row indices 416 Chapter 1. Array objects NumPy Reference, Release 1.8.1 array([[0, 0, 0], [1, 1, 1]]) >>> grid[1]# column indices array([[0, 1, 2], [0, 1, 2]]) The indices can be used as an index into an array. >>> x= np.arange(20).reshape(5,4) >>> row, col= np.indices((2,3)) >>> x[row, col] array([[0, 1, 2], [4, 5, 6]]) Note that it would be more straightforward in the above example to extract the required elements directly with x[:2, :3]. numpy.ma.where(condition, x=None, y=None) Return a masked array with elements from x or y, depending on condition. Returns a masked array, shaped like condition, where the elements are from x when condition is True, and from y otherwise. If neither x nor y are given, the function returns a tuple of indices where condition is True (the result of condition.nonzero()). Parameters condition : array_like, bool The condition to meet. For each True element, yield the corresponding element from x, otherwise from y. x, y : array_like, optional Values from which to choose. x and y need to have the same shape as condition, or be broadcast-able to that shape. Returns out : MaskedArray or tuple of ndarrays The resulting masked array if x and y were given, otherwise the result of condition.nonzero(). See Also: numpy.where Equivalent function in the top-level NumPy module. Examples >>> x= np.ma.array(np.arange(9.).reshape(3,3), mask=[[0,1,0], ... [1,0,1], ... [0,1,0]]) >>> print x [[0.0 -- 2.0] [-- 4.0 --] [6.0 -- 8.0]] >>> np.ma.where(x>5)# return the indices where x > 5 (array([2, 2]), array([0, 2])) >>> print np.ma.where(x>5, x,-3.1416) [[-3.1416 -- -3.1416] 1.7. Masked arrays 417 NumPy Reference, Release 1.8.1 [-- -3.1416 --] [6.0 -- 8.0]] 1.8 The Array Interface Note: This page describes the numpy-speciﬁc API for accessing the contents of a numpy array from other C exten- sions. PEP 3118 – The Revised Buffer Protocol introduces similar, standardized API to Python 2.6 and 3.0 for any extension module to use. Cython‘s buffer array support uses the PEP 3118 API; see the Cython numpy tutorial. Cython provides a way to write code that supports the buffer protocol with Python versions older than 2.6 because it has a backward-compatible implementation utilizing the array interface described here. version 3 The array interface (sometimes called array protocol) was created in 2005 as a means for array-like Python objects to re-use each other’s data buffers intelligently whenever possible. The homogeneous N-dimensional array interface is a default mechanism for objects to share N-dimensional array memory and information. The interface consists of a Python-side and a C-side using two attributes. Objects wishing to be considered an N-dimensional array in application code should support at least one of these attributes. Objects wishing to support an N-dimensional array in application code should look for at least one of these attributes and use the information provided appropriately. This interface describes homogeneous arrays in the sense that each item of the array has the same “type”. This type can be very simple or it can be a quite arbitrary and complicated C-like structure. There are two ways to use the interface: A Python side and a C-side. Both are separate attributes. 1.8.1 Python side This approach to the interface consists of the object having an __array_interface__ attribute. __array_interface__ A dictionary of items (3 required and 5 optional). The optional keys in the dictionary have implied defaults if they are not provided. The keys are: shape (required) Tuple whose elements are the array size in each dimension. Each entry is an integer (a Python int or long). Note that these integers could be larger than the platform “int” or “long” could hold (a Python int is a C long). It is up to the code using this attribute to handle this appropriately; either by raising an error when overﬂow is possible, or by using Py_LONG_LONG as the C type for the shapes. typestr (required) A string providing the basic type of the homogenous array The basic string format consists of 3 parts: a character describing the byteorder of the data (<: little-endian, >: big-endian, |: not-relevant), a character code giving the basic type of the array, and an integer providing the number of bytes the type uses. The basic type character codes are: 418 Chapter 1. Array objects NumPy Reference, Release 1.8.1 t Bit ﬁeld (following integer gives the number of bits in the bit ﬁeld). b Boolean (integer type where all values are only True or False) i Integer u Unsigned integer f Floating point c Complex ﬂoating point O Object (i.e. the memory contains a pointer to PyObject) S String (ﬁxed-length sequence of char) U Unicode (ﬁxed-length sequence of Py_UNICODE) V Other (void * – each item is a ﬁxed-size chunk of memory) descr (optional) A list of tuples providing a more detailed description of the memory layout for each item in the homogeneous array. Each tuple in the list has two or three elements. Normally, this attribute would be used when typestr is V[0-9]+, but this is not a requirement. The only requirement is that the number of bytes represented in the typestr key is the same as the total number of bytes represented here. The idea is to support descriptions of C-like structs (records) that make up array elements. The elements of each tuple in the list are 1.A string providing a name associated with this portion of the record. This could also be a tuple of (’full name’, ’basic_name’) where basic name would be a valid Python variable name representing the full name of the ﬁeld. 2.Either a basic-type description string as in typestr or another list (for nested records) 3.An optional shape tuple providing how many times this part of the record should be repeated. No repeats are assumed if this is not given. Very complicated structures can be described using this generic interface. Notice, however, that each element of the array is still of the same data-type. Some examples of using this interface are given below. Default:[(”, typestr)] data (optional) A 2-tuple whose ﬁrst argument is an integer (a long integer if necessary) that points to the data-area storing the array contents. This pointer must point to the ﬁrst element of data (in other words any offset is always ignored in this case). The second entry in the tuple is a read-only ﬂag (true means the data area is read-only). This attribute can also be an object exposing the buffer interface which will be used to share the data. If this key is not present (or returns None), then memory sharing will be done through the buffer interface of the object itself. In this case, the offset key can be used to indicate the start of the buffer. A reference to the object exposing the array interface must be stored by the new object if the memory area is to be secured. Default: None strides (optional) Either None to indicate a C-style contiguous array or a Tuple of strides which provides the number of bytes needed to jump to the next array element in the corresponding dimension. Each entry must be an integer (a Python int or long). As with shape, the values may be larger than can be represented by a C “int” or “long”; the calling code should handle this appropiately, either by raising an error, or by using Py_LONG_LONG in C. The default is None which implies a C-style contiguous memory buffer. In this model, the last dimension of the array varies the fastest. For example, the default strides tuple for an object whose array entries are 8 bytes long and whose shape is (10,20,30) would be (4800, 240, 8) Default: None (C-style contiguous) 1.8. The Array Interface 419 NumPy Reference, Release 1.8.1 mask (optional) None or an object exposing the array interface. All elements of the mask array should be interpreted only as true or not true indicating which elements of this array are valid. The shape of this object should be “broadcastable” to the shape of the original array. Default: None (All array values are valid) offset (optional) An integer offset into the array data region. This can only be used when data is None or returns a buffer object. Default: 0. version (required) An integer showing the version of the interface (i.e. 3 for this version). Be careful not to use this to invalidate objects exposing future versions of the interface. 1.8.2 C-struct access This approach to the array interface allows for faster access to an array using only one attribute lookup and a well- deﬁned C-structure. __array_struct__ A PyCObject whose voidptr member contains a pointer to a ﬁlled PyArrayInterface structure. Memory for the structure is dynamically created and the PyCObject is also created with an appropriate destructor so the retriever of this attribute simply has to apply Py_DECREF to the object returned by this attribute when it is ﬁnished. Also, either the data needs to be copied out, or a reference to the object exposing this attribute must be held to ensure the data is not freed. Objects exposing the __array_struct__ interface must also not reallocate their memory if other objects are referencing them. The PyArrayInterface structure is deﬁned in numpy/ndarrayobject.h as: typedef struct { int two; /* contains the integer 2 -- simple sanity check */ int nd; /* number of dimensions */ char typekind; /* kind in array --- character code of typestr */ int itemsize; /* size of each element */ int flags; /* flags indicating how the data should be interpreted */ /* must set ARR_HAS_DESCR bit to validate descr */ Py_intptr_t *shape; /* A length-nd array of shape information */ Py_intptr_t *strides; /* A length-nd array of stride information */ void *data; /* A pointer to the first element of the array */ PyObject *descr; /* NULL or data-description (same as descr key of __array_interface__) -- must set ARR_HAS_DESCR flag or this will be ignored. */ } PyArrayInterface; The ﬂags member may consist of 5 bits showing how the data should be interpreted and one bit showing how the Interface should be interpreted. The data-bits are CONTIGUOUS (0x1), FORTRAN (0x2), ALIGNED (0x100), NOTSWAPPED (0x200), and WRITEABLE (0x400). A ﬁnal ﬂag ARR_HAS_DESCR (0x800) indicates whether or not this structure has the arrdescr ﬁeld. The ﬁeld should not be accessed unless this ﬂag is present. New since June 16, 2006: In the past most implementations used the “desc” member of the PyCObject itself (do not confuse this with the “descr” member of the PyArrayInterface structure above — they are two separate things) to hold the pointer to 420 Chapter 1. Array objects NumPy Reference, Release 1.8.1 the object exposing the interface. This is now an explicit part of the interface. Be sure to own a reference to the object when the PyCObject is created using PyCObject_FromVoidPtrAndDesc. 1.8.3 Type description examples For clarity it is useful to provide some examples of the type description and corresponding __array_interface__ ‘descr’ entries. Thanks to Scott Gilbert for these examples: In every case, the ‘descr’ key is optional, but of course provides more information which may be important for various applications: * Float data typestr == ’>f4’ descr == [(’’,’>f4’)] * Complex double typestr == ’>c8’ descr == [(’real’,’>f4’), (’imag’,’>f4’)] * RGB Pixel data typestr == ’|V3’ descr == [(’r’,’|u1’), (’g’,’|u1’), (’b’,’|u1’)] * Mixed endian (weird but could happen). typestr == ’|V8’ (or ’>u8’) descr == [(’big’,’>i4’), (’little’,’i4’), (’data’,’>f8’,(16,4))] * Padded structure struct { int ival; double dval; } typestr == ’|V16’ descr == [(’ival’,’>i4’),(’’,’|V4’),(’dval’,’>f8’)] It should be clear that any record type could be described using this interface. 1.8. The Array Interface 421 NumPy Reference, Release 1.8.1 1.8.4 Differences with Array interface (Version 2) The version 2 interface was very similar. The differences were largely asthetic. In particular: 1. The PyArrayInterface structure had no descr member at the end (and therefore no ﬂag ARR_HAS_DESCR) 2. The desc member of the PyCObject returned from __array_struct__ was not speciﬁed. Usually, it was the object exposing the array (so that a reference to it could be kept and destroyed when the C-object was destroyed). Now it must be a tuple whose ﬁrst element is a string with “PyArrayInterface Version #” and whose second element is the object exposing the array. 3. The tuple returned from __array_interface__[’data’] used to be a hex-string (now it is an integer or a long integer). 4. There was no __array_interface__ attribute instead all of the keys (except for version) in the __array_interface__ dictionary were their own attribute: Thus to obtain the Python-side information you had to access separately the attributes: • __array_data__ • __array_shape__ • __array_strides__ • __array_typestr__ • __array_descr__ • __array_offset__ • __array_mask__ 1.9 Datetimes and Timedeltas New in version 1.7.0. Starting in NumPy 1.7, there are core array data types which natively support datetime func- tionality. The data type is called “datetime64”, so named because “datetime” is already taken by the datetime library included in Python. Note: The datetime API is experimental in 1.7.0, and may undergo changes in future versions of NumPy. 1.9.1 Basic Datetimes The most basic way to create datetimes is from strings in ISO 8601 date or datetime format. The unit for internal storage is automatically selected from the form of the string, and can be either a date unit or a time unit. The date units are years (‘Y’), months (‘M’), weeks (‘W’), and days (‘D’), while the time units are hours (‘h’), minutes (‘m’), seconds (‘s’), milliseconds (‘ms’), and some additional SI-preﬁx seconds-based units. Example A simple ISO date: >>> np.datetime64(’2005-02-25’) numpy.datetime64(’2005-02-25’) Using months for the unit: 422 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> np.datetime64(’2005-02’) numpy.datetime64(’2005-02’) Specifying just the month, but forcing a ‘days’ unit: >>> np.datetime64(’2005-02’,’D’) numpy.datetime64(’2005-02-01’) Using UTC “Zulu” time: >>> np.datetime64(’2005-02-25T03:30Z’) numpy.datetime64(’2005-02-24T21:30-0600’) ISO 8601 speciﬁes to use the local time zone if none is explicitly given: >>> np.datetime64(’2005-02-25T03:30’) numpy.datetime64(’2005-02-25T03:30-0600’) When creating an array of datetimes from a string, it is still possible to automatically select the unit from the inputs, by using the datetime type with generic units. Example >>> np.array([’2007-07-13’,’2006-01-13’,’2010-08-13’], dtype=’datetime64’) array([’2007-07-13’, ’2006-01-13’, ’2010-08-13’], dtype=’datetime64[D]’) >>> np.array([’2001-01-01T12:00’,’2002-02-03T13:56:03.172’], dtype=’datetime64’) array([’2001-01-01T12:00:00.000-0600’, ’2002-02-03T13:56:03.172-0600’], dtype=’datetime64[ms]’) The datetime type works with many common NumPy functions, for example arange can be used to generate ranges of dates. Example All the dates for one month: >>> np.arange(’2005-02’,’2005-03’, dtype=’datetime64[D]’) array([’2005-02-01’, ’2005-02-02’, ’2005-02-03’, ’2005-02-04’, ’2005-02-05’, ’2005-02-06’, ’2005-02-07’, ’2005-02-08’, ’2005-02-09’, ’2005-02-10’, ’2005-02-11’, ’2005-02-12’, ’2005-02-13’, ’2005-02-14’, ’2005-02-15’, ’2005-02-16’, ’2005-02-17’, ’2005-02-18’, ’2005-02-19’, ’2005-02-20’, ’2005-02-21’, ’2005-02-22’, ’2005-02-23’, ’2005-02-24’, ’2005-02-25’, ’2005-02-26’, ’2005-02-27’, ’2005-02-28’], dtype=’datetime64[D]’) The datetime object represents a single moment in time. If two datetimes have different units, they may still be representing the same moment of time, and converting from a bigger unit like months to a smaller unit like days is considered a ‘safe’ cast because the moment of time is still being represented exactly. Example >>> np.datetime64(’2005’) == np.datetime64(’2005-01-01’) True 1.9. Datetimes and Timedeltas 423 NumPy Reference, Release 1.8.1 >>> np.datetime64(’2010-03-14T15Z’) == np.datetime64(’2010-03-14T15:00:00.00Z’) True An important exception to this rule is between datetimes with date units and datetimes with time units. This is because this kind of conversion generally requires a choice of timezone and particular time of day on the given date. Example >>> np.datetime64(’2003-12-25’,’s’) Traceback (most recent call last): File "", line1, in TypeError: Cannot parse "2003-12-25" as unit ’s’ using casting rule ’same_kind’ >>> np.datetime64(’2003-12-25’) == np.datetime64(’2003-12-25T00Z’) False 1.9.2 Datetime and Timedelta Arithmetic NumPy allows the subtraction of two Datetime values, an operation which produces a number with a time unit. Because NumPy doesn’t have a physical quantities system in its core, the timedelta64 data type was created to com- plement datetime64. Datetimes and Timedeltas work together to provide ways for simple datetime calculations. Example >>> np.datetime64(’2009-01-01’)- np.datetime64(’2008-01-01’) numpy.timedelta64(366,’D’) >>> np.datetime64(’2009’)+ np.timedelta64(20,’D’) numpy.datetime64(’2009-01-21’) >>> np.datetime64(’2011-06-15T00:00’)+ np.timedelta64(12,’h’) numpy.datetime64(’2011-06-15T12:00-0500’) >>> np.timedelta64(1,’W’)/ np.timedelta64(1,’D’) 7.0 There are two Timedelta units (‘Y’, years and ‘M’, months) which are treated specially, because how much time they represent changes depending on when they are used. While a timedelta day unit is equivalent to 24 hours, there is no way to convert a month unit into days, because different months have different numbers of days. Example >>> a= np.timedelta64(1,’Y’) >>> np.timedelta64(a,’M’) numpy.timedelta64(12,’M’) >>> np.timedelta64(a,’D’) Traceback (most recent call last): File "", line1, in TypeError: Cannot cast NumPy timedelta64 scalar from metadata [Y] to [D] according to the rule ’same_kind’ 424 Chapter 1. Array objects NumPy Reference, Release 1.8.1 1.9.3 Datetime Units The Datetime and Timedelta data types support a large number of time units, as well as generic units which can be coerced into any of the other units based on input data. Datetimes are always stored based on POSIX time (though having a TAI mode which allows for accounting of leap- seconds is proposed), with a epoch of 1970-01-01T00:00Z. This means the supported dates are always a symmetric interval around the epoch, called “time span” in the table below. The length of the span is the range of a 64-bit integer times the length of the date or unit. For example, the time span for ‘W’ (week) is exactly 7 times longer than the time span for ‘D’ (day), and the time span for ‘D’ (day) is exactly 24 times longer than the time span for ‘h’ (hour). Here are the date units: Code Meaning Time span (relative) Time span (absolute) Y year +/- 9.2e18 years [9.2e18 BC, 9.2e18 AD] M month +/- 7.6e17 years [7.6e17 BC, 7.6e17 AD] W week +/- 1.7e17 years [1.7e17 BC, 1.7e17 AD] D day +/- 2.5e16 years [2.5e16 BC, 2.5e16 AD] And here are the time units: Code Meaning Time span (relative) Time span (absolute) h hour +/- 1.0e15 years [1.0e15 BC, 1.0e15 AD] m minute +/- 1.7e13 years [1.7e13 BC, 1.7e13 AD] s second +/- 2.9e12 years [ 2.9e9 BC, 2.9e9 AD] ms millisecond +/- 2.9e9 years [ 2.9e6 BC, 2.9e6 AD] us microsecond +/- 2.9e6 years [290301 BC, 294241 AD] ns nanosecond +/- 292 years [ 1678 AD, 2262 AD] ps picosecond +/- 106 days [ 1969 AD, 1970 AD] fs femtosecond +/- 2.6 hours [ 1969 AD, 1970 AD] as attosecond +/- 9.2 seconds [ 1969 AD, 1970 AD] 1.9.4 Business Day Functionality To allow the datetime to be used in contexts where only certain days of the week are valid, NumPy includes a set of “busday” (business day) functions. The default for busday functions is that the only valid days are Monday through Friday (the usual business days). The implementation is based on a “weekmask” containing 7 Boolean ﬂags to indicate valid days; custom weekmasks are possible that specify other sets of valid days. The “busday” functions can additionally check a list of “holiday” dates, speciﬁc dates that are not valid days. The function busday_offset allows you to apply offsets speciﬁed in business days to datetimes with a unit of ‘D’ (day). Example >>> np.busday_offset(’2011-06-23’,1) numpy.datetime64(’2011-06-24’) >>> np.busday_offset(’2011-06-23’,2) numpy.datetime64(’2011-06-27’) 1.9. Datetimes and Timedeltas 425 NumPy Reference, Release 1.8.1 When an input date falls on the weekend or a holiday, busday_offset ﬁrst applies a rule to roll the date to a valid business day, then applies the offset. The default rule is ‘raise’, which simply raises an exception. The rules most typically used are ‘forward’ and ‘backward’. Example >>> np.busday_offset(’2011-06-25’,2) Traceback (most recent call last): File "", line1, in ValueError: Non-business day date in busday_offset >>> np.busday_offset(’2011-06-25’,0, roll=’forward’) numpy.datetime64(’2011-06-27’) >>> np.busday_offset(’2011-06-25’,2, roll=’forward’) numpy.datetime64(’2011-06-29’) >>> np.busday_offset(’2011-06-25’,0, roll=’backward’) numpy.datetime64(’2011-06-24’) >>> np.busday_offset(’2011-06-25’,2, roll=’backward’) numpy.datetime64(’2011-06-28’) In some cases, an appropriate use of the roll and the offset is necessary to get a desired answer. Example The ﬁrst business day on or after a date: >>> np.busday_offset(’2011-03-20’,0, roll=’forward’) numpy.datetime64(’2011-03-21’,’D’) >>> np.busday_offset(’2011-03-22’,0, roll=’forward’) numpy.datetime64(’2011-03-22’,’D’) The ﬁrst business day strictly after a date: >>> np.busday_offset(’2011-03-20’,1, roll=’backward’) numpy.datetime64(’2011-03-21’,’D’) >>> np.busday_offset(’2011-03-22’,1, roll=’backward’) numpy.datetime64(’2011-03-23’,’D’) The function is also useful for computing some kinds of days like holidays. In Canada and the U.S., Mother’s day is on the second Sunday in May, which can be computed with a custom weekmask. Example >>> np.busday_offset(’2012-05’,1, roll=’forward’, weekmask=’Sun’) numpy.datetime64(’2012-05-13’,’D’) When performance is important for manipulating many business dates with one particular choice of weekmask and holidays, there is an object busdaycalendar which stores the data necessary in an optimized form. np.is_busday(): To test a datetime64 value to see if it is a valid day, use is_busday. 426 Chapter 1. Array objects NumPy Reference, Release 1.8.1 Example >>> np.is_busday(np.datetime64(’2011-07-15’)) # a Friday True >>> np.is_busday(np.datetime64(’2011-07-16’)) # a Saturday False >>> np.is_busday(np.datetime64(’2011-07-16’), weekmask="Sat Sun") True >>> a= np.arange(np.datetime64(’2011-07-11’), np.datetime64(’2011-07-18’)) >>> np.is_busday(a) array([ True, True, True, True, True, False, False], dtype=’bool’) np.busday_count(): To ﬁnd how many valid days there are in a speciﬁed range of datetime64 dates, use busday_count: Example >>> np.busday_count(np.datetime64(’2011-07-11’), np.datetime64(’2011-07-18’)) 5 >>> np.busday_count(np.datetime64(’2011-07-18’), np.datetime64(’2011-07-11’)) -5 If you have an array of datetime64 day values, and you want a count of how many of them are valid dates, you can do this: Example >>> a= np.arange(np.datetime64(’2011-07-11’), np.datetime64(’2011-07-18’)) >>> np.count_nonzero(np.is_busday(a)) 5 Custom Weekmasks Here are several examples of custom weekmask values. These examples specify the “busday” default of Monday through Friday being valid days. Some examples: # Positional sequences; positions are Monday through Sunday. # Length of the sequence must be exactly 7. weekmask=[1,1,1,1,1,0,0] # list or other sequence; 0 == invalid day, 1 == valid day weekmask="1111100" # string ’0’ == invalid day, ’1’ == valid day # string abbreviations from this list: Mon Tue Wed Thu Fri Sat Sun weekmask="Mon Tue Wed Thu Fri" # any amount of whitespace is allowed; abbreviations are case-sensitive. weekmask="MonTue Wed Thu \tFri" 1.9. Datetimes and Timedeltas 427 NumPy Reference, Release 1.8.1 1.9.5 Differences Between 1.6 and 1.7 Datetimes The NumPy 1.6 release includes a more primitive datetime data type than 1.7. This section documents many of the changes that have taken place. String Parsing The datetime string parser in NumPy 1.6 is very liberal in what it accepts, and silently allows invalid input without raising errors. The parser in NumPy 1.7 is quite strict about only accepting ISO 8601 dates, with a few convenience extensions. 1.6 always creates microsecond (us) units by default, whereas 1.7 detects a unit based on the format of the string. Here is a comparison.: # NumPy 1.6.1 >>> np.datetime64(’1979-03-22’) 1979-03-22 00:00:00 # NumPy 1.7.0 >>> np.datetime64(’1979-03-22’) numpy.datetime64(’1979-03-22’) # NumPy 1.6.1, unit default microseconds >>> np.datetime64(’1979-03-22’).dtype dtype(’datetime64[us]’) # NumPy 1.7.0, unit of days detected from string >>> np.datetime64(’1979-03-22’).dtype dtype(’>> np.datetime64(’1979-03-2corruptedstring’) 1979-03-02 00:00:00 # NumPy 1.7.0, raises error for invalid input >>> np.datetime64(’1979-03-2corruptedstring’) Traceback (most recent call last): File "", line 1, in ValueError: Error parsing datetime string "1979-03-2corruptedstring" at position 8 # NumPy 1.6.1, ’nat’ produces today’s date >>> np.datetime64(’nat’) 2012-04-30 00:00:00 # NumPy 1.7.0, ’nat’ produces not-a-time >>> np.datetime64(’nat’) numpy.datetime64(’NaT’) # NumPy 1.6.1, ’garbage’ produces today’s date >>> np.datetime64(’garbage’) 2012-04-30 00:00:00 # NumPy 1.7.0, ’garbage’ raises an exception >>> np.datetime64(’garbage’) Traceback (most recent call last): File "", line 1, in ValueError: Error parsing datetime string "garbage" at position 0 # NumPy 1.6.1, can’t specify unit in scalar constructor >>> np.datetime64(’1979-03-22T19:00’, ’h’) Traceback (most recent call last): File "", line 1, in TypeError: function takes at most 1 argument (2 given) # NumPy 1.7.0, unit in scalar constructor 428 Chapter 1. Array objects NumPy Reference, Release 1.8.1 >>> np.datetime64(’1979-03-22T19:00’, ’h’) numpy.datetime64(’1979-03-22T19:00-0500’,’h’) # NumPy 1.6.1, reads ISO 8601 strings w/o TZ as UTC >>> np.array([’1979-03-22T19:00’], dtype=’M8[h]’) array([1979-03-22 19:00:00], dtype=datetime64[h]) # NumPy 1.7.0, reads ISO 8601 strings w/o TZ as local (ISO specifies this) >>> np.array([’1979-03-22T19:00’], dtype=’M8[h]’) array([’1979-03-22T19-0500’], dtype=’datetime64[h]’) # NumPy 1.6.1, doesn’t parse all ISO 8601 strings correctly >>> np.array([’1979-03-22T12’], dtype=’M8[h]’) array([1979-03-22 00:00:00], dtype=datetime64[h]) >>> np.array([’1979-03-22T12:00’], dtype=’M8[h]’) array([1979-03-22 12:00:00], dtype=datetime64[h]) # NumPy 1.7.0, handles this case correctly >>> np.array([’1979-03-22T12’], dtype=’M8[h]’) array([’1979-03-22T12-0500’], dtype=’datetime64[h]’) >>> np.array([’1979-03-22T12:00’], dtype=’M8[h]’) array([’1979-03-22T12-0500’], dtype=’datetime64[h]’) Unit Conversion The 1.6 implementation of datetime does not convert between units correctly.: # NumPy 1.6.1, the representation value is untouched >>> np.array([’1979-03-22’], dtype=’M8[D]’) array([1979-03-22 00:00:00], dtype=datetime64[D]) >>> np.array([’1979-03-22’], dtype=’M8[D]’).astype(’M8[M]’) array([2250-08-01 00:00:00], dtype=datetime64[M]) # NumPy 1.7.0, the representation is scaled accordingly >>> np.array([’1979-03-22’], dtype=’M8[D]’) array([’1979-03-22’], dtype=’datetime64[D]’) >>> np.array([’1979-03-22’], dtype=’M8[D]’).astype(’M8[M]’) array([’1979-03’], dtype=’datetime64[M]’) Datetime Arithmetic The 1.6 implementation of datetime only works correctly for a small subset of arithmetic operations. Here we show some simple cases.: # NumPy 1.6.1, produces invalid results if units are incompatible >>> a = np.array([’1979-03-22T12’], dtype=’M8[h]’) >>> b = np.array([3*60], dtype=’m8[m]’) >>> a + b array([1970-01-01 00:00:00.080988], dtype=datetime64[us]) # NumPy 1.7.0, promotes to higher-resolution unit >>> a = np.array([’1979-03-22T12’], dtype=’M8[h]’) >>> b = np.array([3*60], dtype=’m8[m]’) >>> a + b array([’1979-03-22T15:00-0500’], dtype=’datetime64[m]’) # NumPy 1.6.1, arithmetic works if everything is microseconds >>> a = np.array([’1979-03-22T12:00’], dtype=’M8[us]’) >>> b = np.array([3*60*60*1000000], dtype=’m8[us]’) >>> a + b 1.9. Datetimes and Timedeltas 429 NumPy Reference, Release 1.8.1 array([1979-03-22 15:00:00], dtype=datetime64[us]) # NumPy 1.7.0 >>> a = np.array([’1979-03-22T12:00’], dtype=’M8[us]’) >>> b = np.array([3*60*60*1000000], dtype=’m8[us]’) >>> a + b array([’1979-03-22T15:00:00.000000-0500’], dtype=’datetime64[us]’) 430 Chapter 1. Array objects CHAPTER TWO UNIVERSAL FUNCTIONS (UFUNC) A universal function (or ufunc for short) is a function that operates on ndarrays in an element-by-element fashion, supporting array broadcasting, type casting, and several other standard features. That is, a ufunc is a “vectorized” wrapper for a function that takes a ﬁxed number of scalar inputs and produces a ﬁxed number of scalar outputs. In Numpy, universal functions are instances of the numpy.ufunc class. Many of the built-in functions are imple- mented in compiled C code, but ufunc instances can also be produced using the frompyfunc factory function. 2.1 Broadcasting Each universal function takes array inputs and produces array outputs by performing the core function element-wise on the inputs. Standard broadcasting rules are applied so that inputs not sharing exactly the same shapes can still be usefully operated on. Broadcasting can be understood by four rules: 1. All input arrays with ndim smaller than the input array of largest ndim, have 1’s prepended to their shapes. 2. The size in each dimension of the output shape is the maximum of all the input sizes in that dimension. 3. An input can be used in the calculation if its size in a particular dimension either matches the output size in that dimension, or has value exactly 1. 4. If an input has a dimension size of 1 in its shape, the ﬁrst data entry in that dimension will be used for all calculations along that dimension. In other words, the stepping machinery of the ufunc will simply not step along that dimension (the stride will be 0 for that dimension). Broadcasting is used throughout NumPy to decide how to handle disparately shaped arrays; for example, all arith- metic operations (+,-,*, ...) between ndarrays broadcast the arrays before operation. A set of arrays is called “broadcastable” to the same shape if the above rules produce a valid result, i.e., one of the following is true: 1. The arrays all have exactly the same shape. 2. The arrays all have the same number of dimensions and the length of each dimensions is either a common length or 1. 3. The arrays that have too few dimensions can have their shapes prepended with a dimension of length 1 to satisfy property 2. Example If a.shape is (5,1), b.shape is (1,6), c.shape is (6,) and d.shape is () so that d is a scalar, then a, b, c, and d are all broadcastable to dimension (5,6); and • a acts like a (5,6) array where a[:,0] is broadcast to the other columns, • b acts like a (5,6) array where b[0,:] is broadcast to the other rows, 431 NumPy Reference, Release 1.8.1 • c acts like a (1,6) array and therefore like a (5,6) array where c[:] is broadcast to every row, and ﬁnally, • d acts like a (5,6) array where the single value is repeated. 2.2 Output type determination The output of the ufunc (and its methods) is not necessarily an ndarray, if all input arguments are not ndarrays. All output arrays will be passed to the __array_prepare__ and __array_wrap__ methods of the in- put (besides ndarrays, and scalars) that deﬁnes it and has the highest __array_priority__ of any other input to the universal function. The default __array_priority__ of the ndarray is 0.0, and the default __array_priority__ of a subtype is 1.0. Matrices have __array_priority__ equal to 10.0. All ufuncs can also take output arguments. If necessary, output will be cast to the data-type(s) of the provided output array(s). If a class with an __array__ method is used for the output, results will be written to the object returned by __array__. Then, if the class also has an __array_prepare__ method, it is called so metadata may be determined based on the context of the ufunc (the context consisting of the ufunc itself, the arguments passed to the ufunc, and the ufunc domain.) The array object returned by __array_prepare__ is passed to the ufunc for computation. Finally, if the class also has an __array_wrap__ method, the returned ndarray result will be passed to that method just before passing control back to the caller. 2.3 Use of internal buffers Internally, buffers are used for misaligned data, swapped data, and data that has to be converted from one data type to another. The size of internal buffers is settable on a per-thread basis. There can be up to 2(ninputs + noutputs) buffers of the speciﬁed size created to handle the data from all the inputs and outputs of a ufunc. The default size of a buffer is 10,000 elements. Whenever buffer-based calculation would be needed, but all input arrays are smaller than the buffer size, those misbehaved or incorrectly-typed arrays will be copied before the calculation proceeds. Adjusting the size of the buffer may therefore alter the speed at which ufunc calculations of various sorts are completed. A simple interface for setting this variable is accessible using the function setbufsize(size) Set the size of the buffer used in ufuncs. numpy.setbufsize(size) Set the size of the buffer used in ufuncs. Parameters size : int Size of buffer. 2.4 Error handling Universal functions can trip special ﬂoating-point status registers in your hardware (such as divide-by-zero). If avail- able on your platform, these registers will be regularly checked during calculation. Error handling is controlled on a per-thread basis, and can be conﬁgured using the functions seterr([all, divide, over, under, invalid]) Set how ﬂoating-point errors are handled. seterrcall(func) Set the ﬂoating-point error callback function or log object. 432 Chapter 2. Universal functions (ufunc) NumPy Reference, Release 1.8.1 numpy.seterr(all=None, divide=None, over=None, under=None, invalid=None) Set how ﬂoating-point errors are handled. Note that operations on integer scalar types (such as int16) are handled like ﬂoating point, and are affected by these settings. Parameters all : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional Set treatment for all types of ﬂoating-point errors at once: • ignore: Take no action when the exception occurs. • warn: Print a RuntimeWarning (via the Python warnings module). • raise: Raise a FloatingPointError. • call: Call a function speciﬁed using the seterrcall function. • print: Print a warning directly to stdout. • log: Record error in a Log object speciﬁed by seterrcall. The default is not to change the current behavior. divide : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional Treatment for division by zero. over : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional Treatment for ﬂoating-point overﬂow. under : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional Treatment for ﬂoating-point underﬂow. invalid : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional Treatment for invalid ﬂoating-point operation. Returns old_settings : dict Dictionary containing the old settings. See Also: seterrcall Set a callback function for the ‘call’ mode. geterr, geterrcall, errstate Notes The ﬂoating-point exceptions are deﬁned in the IEEE 754 standard [1]: •Division by zero: inﬁnite result obtained from ﬁnite numbers. •Overﬂow: result too large to be expressed. •Underﬂow: result so close to zero that some precision was lost. •Invalid operation: result is not an expressible number, typically indicates that a NaN was produced. 2.4. Error handling 433 NumPy Reference, Release 1.8.1 Examples >>> old_settings= np.seterr(all=’ignore’)#seterr to known value >>> np.seterr(over=’raise’) {’over’: ’ignore’, ’divide’: ’ignore’, ’invalid’: ’ignore’, ’under’: ’ignore’} >>> np.seterr(**old_settings) # reset to default {’over’: ’raise’, ’divide’: ’ignore’, ’invalid’: ’ignore’, ’under’: ’ignore’} >>> np.int16(32000)* np.int16(3) 30464 >>> old_settings= np.seterr(all=’warn’, over=’raise’) >>> np.int16(32000)* np.int16(3) Traceback (most recent call last): File "", line1, in FloatingPointError: overflow encountered in short_scalars >>> old_settings= np.seterr(all=’print’) >>> np.geterr() {’over’: ’print’, ’divide’: ’print’, ’invalid’: ’print’, ’under’: ’print’} >>> np.int16(32000)* np.int16(3) Warning: overflow encountered in short_scalars 30464 numpy.seterrcall(func) Set the ﬂoating-point error callback function or log object. There are two ways to capture ﬂoating-point error messages. The ﬁrst is to set the error-handler to ‘call’, using seterr. Then, set the function to call using this function. The second is to set the error-handler to ‘log’, using seterr. Floating-point errors then trigger a call to the ‘write’ method of the provided object. Parameters func : callable f(err, ﬂag) or object with write method Function to call upon ﬂoating-point errors (‘call’-mode) or object whose ‘write’ method is used to log such message (‘log’-mode). The call function takes two arguments. The ﬁrst is the type of error (one of “divide”, “over”, “under”, or “invalid”), and the second is the status ﬂag. The ﬂag is a byte, whose least-signiﬁcant bits indicate the status: [0 0 0 0 invalid over under invalid] In other words, flags = divide + 2*over + 4*under + 8*invalid. If an object is provided, its write method should take one argument, a string. Returns h : callable, log instance or None The old error handler. See Also: seterr, geterr, geterrcall Examples Callback upon error: 434 Chapter 2. Universal functions (ufunc) NumPy Reference, Release 1.8.1 >>> def err_handler(type, flag): ... print "Floating point error (%s), with flag %s"%(type, flag) ... >>> saved_handler= np.seterrcall(err_handler) >>> save_err= np.seterr(all=’call’) >>> np.array([1,2,3])/ 0.0 Floating point error (divide by zero), with flag 1 array([ Inf, Inf, Inf]) >>> np.seterrcall(saved_handler) >>> np.seterr(**save_err) {’over’: ’call’, ’divide’: ’call’, ’invalid’: ’call’, ’under’: ’call’} Log error message: >>> class Log(object): ... def write(self, msg): ... print "LOG: %s"% msg ... >>> log= Log() >>> saved_handler= np.seterrcall(log) >>> save_err= np.seterr(all=’log’) >>> np.array([1,2,3])/ 0.0 LOG: Warning: divide by zero encountered in divide array([ Inf, Inf, Inf]) >>> np.seterrcall(saved_handler) <__main__.Log object at 0x...> >>> np.seterr(**save_err) {’over’: ’log’, ’divide’: ’log’, ’invalid’: ’log’, ’under’: ’log’} 2.5 Casting Rules Note: In NumPy 1.6.0, a type promotion API was created to encapsulate the mechansim for determining output types. See the functions result_type, promote_types, and min_scalar_type for more details. At the core of every ufunc is a one-dimensional strided loop that implements the actual function for a speciﬁc type combination. When a ufunc is created, it is given a static list of inner loops and a corresponding list of type signatures over which the ufunc operates. The ufunc machinery uses this list to determine which inner loop to use for a particular case. You can inspect the .types attribute for a particular ufunc to see which type combinations have a deﬁned inner loop and which output type they produce (character codes are used in said output for brevity). Casting must be done on one or more of the inputs whenever the ufunc does not have a core loop implementation for the input types provided. If an implementation for the input types cannot be found, then the algorithm searches for an implementation with a type signature to which all of the inputs can be cast “safely.” The ﬁrst one it ﬁnds in its internal list of loops is selected and performed, after all necessary type casting. Recall that internal copies during ufuncs (even for casting) are limited to the size of an internal buffer (which is user settable). 2.5. Casting Rules 435 NumPy Reference, Release 1.8.1 Note: Universal functions in NumPy are ﬂexible enough to have mixed type signatures. Thus, for example, a universal function could be deﬁned that works with ﬂoating-point and integer values. See ldexp for an example. By the above description, the casting rules are essentially implemented by the question of when a data type can be cast “safely” to another data type. The answer to this question can be determined in Python with a function call: can_cast(fromtype, totype). The Figure below shows the results of this call for the 24 internally supported types on the author’s 64-bit system. You can generate this table for your system with the code given in the Figure. Figure Code segment showing the “can cast safely” table for a 32-bit system. >>> def print_table(ntypes): ... print ’X’, ... for char in ntypes: print char, ... print ... for row in ntypes: ... print row, ... for col in ntypes: ... print int(np.can_cast(row, col)), ... print >>> print_table(np.typecodes[’All’]) X?bhilqpBHILQPefdgFDGSUVOMm ?11111111111111111111111111 b01111110000001111111111100 h00111110000000111111111100 i00011110000000011011111100 l00001110000000011011111100 q00001110000000011011111100 p00001110000000011011111100 B00111111111111111111111100 H00011110111110111111111100 I00001110011110011011111100 L00000000001110011011111100 Q00000000001110011011111100 P00000000001110011011111100 e00000000000001111111111100 f00000000000000111111111100 d00000000000000011011111100 g00000000000000001001111100 F00000000000000000111111100 D00000000000000000011111100 G00000000000000000001111100 S00000000000000000000111100 U00000000000000000000011100 V00000000000000000000001100 O00000000000000000000001100 M00000000000000000000000010 m00000000000000000000000001 You should note that, while included in the table for completeness, the ‘S’, ‘U’, and ‘V’ types cannot be operated on by ufuncs. Also, note that on a 32-bit system the integer types may have different sizes, resulting in a slightly altered table. Mixed scalar-array operations use a different set of casting rules that ensure that a scalar cannot “upcast” an array unless the scalar is of a fundamentally different kind of data (i.e., under a different hierarchy in the data-type hierarchy) than the array. This rule enables you to use scalar constants in your code (which, as Python types, are interpreted 436 Chapter 2. Universal functions (ufunc) NumPy Reference, Release 1.8.1 accordingly in ufuncs) without worrying about whether the precision of the scalar constant will cause upcasting on your large (small precision) array. 2.6 ufunc 2.6.1 Optional keyword arguments All ufuncs take optional keyword arguments. Most of these represent advanced usage and will not typically be used. out New in version 1.6. The ﬁrst output can provided as either a positional or a keyword parameter. where New in version 1.7. Accepts a boolean array which is broadcast together with the operands. Values of True indicate to calculate the ufunc at that position, values of False indicate to leave the value in the output alone. casting New in version 1.6. Provides a policy for what kind of casting is permitted. For compatibility with previous versions of NumPy, this defaults to ‘unsafe’. May be ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, or ‘unsafe’. See can_cast for explanations of the parameter values. In a future version of numpy, this argument will default to ‘same_kind’. As part of this transition, starting in version 1.7, ufuncs will produce a DeprecationWarning for calls which are allowed under the ‘unsafe’ rules, but not under the ‘same_kind’ rules. order New in version 1.6. Speciﬁes the calculation iteration order/memory layout of the output array. Defaults to ‘K’. ‘C’ means the output should be C-contiguous, ‘F’ means F-contiguous, ‘A’ means F-contiguous if the inputs are F-contiguous and not also not C-contiguous, C-contiguous otherwise, and ‘K’ means to match the element ordering of the inputs as closely as possible. dtype New in version 1.6. Overrides the dtype of the calculation and output arrays. Similar to sig. subok New in version 1.6. Defaults to true. If set to false, the output will always be a strict array, not a subtype. sig Either a data-type, a tuple of data-types, or a special signature string indicating the input and output types of a ufunc. This argument allows you to provide a speciﬁc signature for the 1-d loop to use in the underlying calculation. If the loop speciﬁed does not exist for the ufunc, then a TypeError is raised. Normally, a suitable loop is found automatically by comparing the input types with what is available and searching for a loop with data-types to which all inputs can be cast safely. This keyword argument lets you bypass that search and choose a particular loop. A list of available signatures is provided by the types attribute of the ufunc object. extobj a list of length 1, 2, or 3 specifying the ufunc buffer-size, the error mode integer, and the error call- back function. Normally, these values are looked up in a thread-speciﬁc dictionary. Passing them here circumvents that look up and uses the low-level speciﬁcation provided for the error mode. This may be 2.6. ufunc 437 NumPy Reference, Release 1.8.1 useful, for example, as an optimization for calculations requiring many ufunc calls on small arrays in a loop. 2.6.2 Attributes There are some informational attributes that universal functions possess. None of the attributes can be set. __doc__ A docstring for each ufunc. The ﬁrst part of the docstring is dynamically generated from the number of outputs, the name, and the number of inputs. The second part of the docstring is provided at creation time and stored with the ufunc. __name__The name of the ufunc. ufunc.nin The number of inputs. ufunc.nout The number of outputs. ufunc.nargs The number of arguments. ufunc.ntypes The number of types. ufunc.types Returns a list with types grouped input->output. ufunc.identity The identity value. ufunc.nin The number of inputs. Data attribute containing the number of arguments the ufunc treats as input. Examples >>> np.add.nin 2 >>> np.multiply.nin 2 >>> np.power.nin 2 >>> np.exp.nin 1 ufunc.nout The number of outputs. Data attribute containing the number of arguments the ufunc treats as output. Notes Since all ufuncs can take output arguments, this will always be (at least) 1. Examples >>> np.add.nout 1 >>> np.multiply.nout 1 >>> np.power.nout 1 >>> np.exp.nout 1 ufunc.nargs The number of arguments. 438 Chapter 2. Universal functions (ufunc) NumPy Reference, Release 1.8.1 Data attribute containing the number of arguments the ufunc takes, including optional ones. Notes Typically this value will be one more than what you might expect because all ufuncs take the optional “out” argument. Examples >>> np.add.nargs 3 >>> np.multiply.nargs 3 >>> np.power.nargs 3 >>> np.exp.nargs 2 ufunc.ntypes The number of types. The number of numerical NumPy types - of which there are 18 total - on which the ufunc can operate. See Also: numpy.ufunc.types Examples >>> np.add.ntypes 18 >>> np.multiply.ntypes 18 >>> np.power.ntypes 17 >>> np.exp.ntypes 7 >>> np.remainder.ntypes 14 ufunc.types Returns a list with types grouped input->output. Data attribute listing the data-type “Domain-Range” groupings the ufunc can deliver. The data-types are given using the character codes. See Also: numpy.ufunc.ntypes Examples >>> np.add.types [’??->?’, ’bb->b’, ’BB->B’, ’hh->h’, ’HH->H’, ’ii->i’, ’II->I’, ’ll->l’, ’LL->L’, ’qq->q’, ’QQ->Q’, ’ff->f’, ’dd->d’, ’gg->g’, ’FF->F’, ’DD->D’, ’GG->G’, ’OO->O’] >>> np.multiply.types [’??->?’, ’bb->b’, ’BB->B’, ’hh->h’, ’HH->H’, ’ii->i’, ’II->I’, ’ll->l’, ’LL->L’, ’qq->q’, ’QQ->Q’, ’ff->f’, ’dd->d’, ’gg->g’, ’FF->F’, ’DD->D’, ’GG->G’, ’OO->O’] 2.6. ufunc 439 NumPy Reference, Release 1.8.1 >>> np.power.types [’bb->b’, ’BB->B’, ’hh->h’, ’HH->H’, ’ii->i’, ’II->I’, ’ll->l’, ’LL->L’, ’qq->q’, ’QQ->Q’, ’ff->f’, ’dd->d’, ’gg->g’, ’FF->F’, ’DD->D’, ’GG->G’, ’OO->O’] >>> np.exp.types [’f->f’, ’d->d’, ’g->g’, ’F->F’, ’D->D’, ’G->G’, ’O->O’] >>> np.remainder.types [’bb->b’, ’BB->B’, ’hh->h’, ’HH->H’, ’ii->i’, ’II->I’, ’ll->l’, ’LL->L’, ’qq->q’, ’QQ->Q’, ’ff->f’, ’dd->d’, ’gg->g’, ’OO->O’] ufunc.identity The identity value. Data attribute containing the identity element for the ufunc, if it has one. If it does not, the attribute value is None. Examples >>> np.add.identity 0 >>> np.multiply.identity 1 >>> np.power.identity 1 >>> print np.exp.identity None 2.6.3 Methods All ufuncs have four methods. However, these methods only make sense on ufuncs that take two input arguments and return one output argument. Attempting to call these methods on other ufuncs will cause a ValueError. The reduce-like methods all take an axis keyword and a dtype keyword, and the arrays must all have dimension >= 1. The axis keyword speciﬁes the axis of the array over which the reduction will take place and may be negative, but must be an integer. The dtype keyword allows you to manage a very common problem that arises when naively using {op}.reduce. Sometimes you may have an array of a certain data type and wish to add up all of its elements, but the result does not ﬁt into the data type of the array. This commonly happens if you have an array of single-byte integers. The dtype keyword allows you to alter the data type over which the reduction takes place (and therefore the type of the output). Thus, you can ensure that the output is a data type with precision large enough to handle your output. The responsibility of altering the reduce type is mostly up to you. There is one exception: if no dtype is given for a reduction on the “add” or “multiply” operations, then if the input type is an integer (or Boolean) data-type and smaller than the size of the int_ data type, it will be internally upcast to the int_ (or uint) data-type. Ufuncs also have a ﬁfth method that allows in place operations to be performed using fancy indexing. No buffering is used on the dimensions where fancy indexing is used, so the fancy index can list an item more than once and the operation will be performed on the result of the previous operation for that item. ufunc.reduce(a[, axis, dtype, out, keepdims]) Reduces a‘s dimension by one, by applying ufunc along one axis. ufunc.accumulate(array[, axis, dtype, out]) Accumulate the result of applying the operator to all elements. ufunc.reduceat(a, indices[, axis, dtype, out]) Performs a (local) reduce with speciﬁed slices over a single axis. ufunc.outer(A, B) Apply the ufunc op to all pairs (a, b) with a in A and b in B. ufunc.at(a, indices[, b]) Performs unbuffered in place operation on operand ‘a’ for elements speciﬁed by ‘indices’. ufunc.reduce(a, axis=0, dtype=None, out=None, keepdims=False) 440 Chapter 2. Universal functions (ufunc) NumPy Reference, Release 1.8.1 Reduces a‘s dimension by one, by applying ufunc along one axis. Let a.shape = (N0, ..., Ni, ..., NM−1). Then ufunc.reduce(a, axis = i)[k0, .., ki−1, ki+1, .., kM−1] = the result of iterating j over range(Ni), cumulatively applying ufunc to each a[k0, .., ki−1, j, ki+1, .., kM−1]. For a one-dimensional array, reduce produces results equivalent to: r= op.identity # op = ufunc for i in range(len(A)): r= op(r, A[i]) return r For example, add.reduce() is equivalent to sum(). Parameters a : array_like The array to act on. axis : None or int or tuple of ints, optional Axis or axes along which a reduction is performed. The default (axis = 0) is perform a reduction over the ﬁrst dimension of the input array. axis may be negative, in which case it counts from the last to the ﬁrst axis. New in version 1.7.0. If this is None, a reduction is performed over all the axes. If this is a tuple of ints, a reduction is performed on multiple axes, instead of a single axis or all the axes as before. For operations which are either not commutative or not associative, doing a reduction over multiple axes is not well-deﬁned. The ufuncs do not currently raise an exception in this case, but will likely do so in the future. dtype : data-type code, optional The type used to represent the intermediate results. Defaults to the data-type of the output array if this is provided, or the data-type of the input array if no output array is provided. out : ndarray, optional A location into which the result is stored. If not provided, a freshly-allocated array is returned. keepdims : bool, 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 original arr. Returns r : ndarray The reduced array. If out was supplied, r is a reference to it. Examples >>> np.multiply.reduce([2,3,5]) 30 A multi-dimensional array example: >>> X= np.arange(8).reshape((2,2,2)) >>> X array([[[0, 1], [2, 3]], [[4, 5], 2.6. ufunc 441 NumPy Reference, Release 1.8.1 [6, 7]]]) >>> np.add.reduce(X,0) array([[ 4, 6], [ 8, 10]]) >>> np.add.reduce(X) # confirm: default axis value is 0 array([[ 4, 6], [ 8, 10]]) >>> np.add.reduce(X,1) array([[ 2, 4], [10, 12]]) >>> np.add.reduce(X,2) array([[ 1, 5], [ 9, 13]]) ufunc.accumulate(array, axis=0, dtype=None, out=None) Accumulate the result of applying the operator to all elements. For a one-dimensional array, accumulate produces results equivalent to: r= np.empty(len(A)) t= op.identity # op = the ufunc being applied to A’s elements for i in range(len(A)): t= op(t, A[i]) r[i]=t return r For example, add.accumulate() is equivalent to np.cumsum(). For a multi-dimensional array, accumulate is applied along only one axis (axis zero by default; see Examples below) so repeated use is necessary if one wants to accumulate over multiple axes. Parameters array : array_like The array to act on. axis : int, optional The axis along which to apply the accumulation; default is zero. dtype : data-type code, optional The data-type used to represent the intermediate results. Defaults to the data-type of the output array if such is provided, or the the data-type of the input array if no output array is provided. out : ndarray, optional A location into which the result is stored. If not provided a freshly-allocated array is returned. Returns r : ndarray The accumulated values. If out was supplied, r is a reference to out. Examples 1-D array examples: >>> np.add.accumulate([2,3,5]) array([ 2, 5, 10]) 442 Chapter 2. Universal functions (ufunc) NumPy Reference, Release 1.8.1 >>> np.multiply.accumulate([2,3,5]) array([ 2, 6, 30]) 2-D array examples: >>> I= np.eye(2) >>> I array([[ 1., 0.], [ 0., 1.]]) Accumulate along axis 0 (rows), down columns: >>> np.add.accumulate(I,0) array([[ 1., 0.], [ 1., 1.]]) >>> np.add.accumulate(I) # no axis specified = axis zero array([[ 1., 0.], [ 1., 1.]]) Accumulate along axis 1 (columns), through rows: >>> np.add.accumulate(I,1) array([[ 1., 1.], [ 0., 1.]]) ufunc.reduceat(a, indices, axis=0, dtype=None, out=None) Performs a (local) reduce with speciﬁed slices over a single axis. For i in range(len(indices)), reduceat computes ufunc.reduce(a[indices[i]:indices[i+1]]), which becomes the i-th generalized “row” parallel to axis in the ﬁnal result (i.e., in a 2-D array, for example, if axis = 0, it becomes the i-th row, but if axis = 1, it becomes the i-th column). There are two exceptions to this: •when i = len(indices) - 1 (so for the last index), indices[i+1] = a.shape[axis]. •if indices[i] >= indices[i + 1], the i-th generalized “row” is simply a[indices[i]]. The shape of the output depends on the size of indices, and may be larger than a (this happens if len(indices) > a.shape[axis]). Parameters a : array_like The array to act on. indices : array_like Paired indices, comma separated (not colon), specifying slices to reduce. axis : int, optional The axis along which to apply the reduceat. dtype : data-type code, optional The type used to represent the intermediate results. Defaults to the data type of the output array if this is provided, or the data type of the input array if no output array is provided. out : ndarray, optional A location into which the result is stored. If not provided a freshly-allocated array is returned. 2.6. ufunc 443 NumPy Reference, Release 1.8.1 Returns r : ndarray The reduced values. If out was supplied, r is a reference to out. Notes A descriptive example: If a is 1-D, the function ufunc.accumulate(a) is the same as ufunc.reduceat(a, indices)[::2] where indices is range(len(array) - 1) with a zero placed in every other element: indices = zeros(2 * len(a) - 1), indices[1::2] = range(1, len(a)). Don’t be fooled by this attribute’s name: reduceat(a) is not necessarily smaller than a. Examples To take the running sum of four successive values: >>> np.add.reduceat(np.arange(8),[0,4,1,5,2,6,3,7])[::2] array([ 6, 10, 14, 18]) A 2-D example: >>> x= np.linspace(0, 15, 16).reshape(4,4) >>> x array([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.], [ 12., 13., 14., 15.]]) # reduce such that the result has the following five rows: # [row1 + row2 + row3] # [row4] # [row2] # [row3] # [row1 + row2 + row3 + row4] >>> np.add.reduceat(x, [0,3,1,2,0]) array([[ 12., 15., 18., 21.], [ 12., 13., 14., 15.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.], [ 24., 28., 32., 36.]]) # reduce such that result has the following two columns: # [col1 * col2 * col3, col4] >>> np.multiply.reduceat(x, [0,3],1) array([[ 0., 3.], [ 120., 7.], [ 720., 11.], [ 2184., 15.]]) ufunc.outer(A,B) Apply the ufunc op to all pairs (a, b) with a in A and b in B. Let M = A.ndim, N = B.ndim. Then the result, C, of op.outer(A, B) is an array of dimension M + N 444 Chapter 2. Universal functions (ufunc) NumPy Reference, Release 1.8.1 such that: C[i0, ..., iM−1, j0, ..., jN−1] = op(A[i0, ..., iM−1],B[j0, ..., jN−1]) For A and B one-dimensional, this is equivalent to: r= empty(len(A),len(B)) for i in range(len(A)): for j in range(len(B)): r[i,j]= op(A[i], B[j]) # op = ufunc in question Parameters A: array_like First array B: array_like Second array Returns r : ndarray Output array See Also: numpy.outer Examples >>> np.multiply.outer([1,2,3], [4,5,6]) array([[ 4, 5, 6], [ 8, 10, 12], [12, 15, 18]]) A multi-dimensional example: >>> A= np.array([[1,2,3], [4,5,6]]) >>> A.shape (2, 3) >>> B= np.array([[1,2,3,4]]) >>> B.shape (1, 4) >>> C= np.multiply.outer(A, B) >>> C.shape; C (2, 3, 1, 4) array([[[[ 1, 2, 3, 4]], [[ 2, 4, 6, 8]], [[ 3, 6, 9, 12]]], [[[ 4, 8, 12, 16]], [[ 5, 10, 15, 20]], [[ 6, 12, 18, 24]]]]) ufunc.at(a, indices, b=None) Performs unbuffered in place operation on operand ‘a’ for elements speciﬁed by ‘indices’. For addition ufunc, this method is equivalent to a[indices] += b, except that results are accumulated for elements that are indexed more than once. For example, a[[0,0]] += 1 will only increment the ﬁrst element once because of buffering, whereas add.at(a, [0,0], 1) will increment the ﬁrst element twice. New in version 1.8.0. 2.6. ufunc 445 NumPy Reference, Release 1.8.1 Parameters a : array_like The array to perform in place operation on. indices : array_like or tuple Array like index object or slice object for indexing into ﬁrst operand. If ﬁrst operand has multiple dimensions, indices can be a tuple of array like index objects or slice objects. b : array_like Second operand for ufuncs requiring two operands. Operand must be broadcastable over ﬁrst operand after indexing or slicing. Examples Set items 0 and 1 to their negative values: >>> a= np.array([1,2,3,4]) >>> np.negative.at(a, [0,1]) >>> print(a) array([-1, -2, 3, 4]) Increment items 0 and 1, and increment item 2 twice: >>> a= np.array([1,2,3,4]) >>> np.add.at(a, [0,1,2,2],1) >>> print(a) array([2, 3, 5, 4]) Add items 0 and 1 in ﬁrst array to second array, and store results in ﬁrst array: >>> a= np.array([1,2,3,4]) >>> b= np.array([1,2]) >>> np.add.at(a, [0,1], b) >>> print(a) array([2, 4, 3, 4]) Warning: A reduce-like operation on an array with a data-type that has a range “too small” to handle the result will silently wrap. One should use dtype to increase the size of the data-type over which reduction takes place. 2.7 Available ufuncs There are currently more than 60 universal functions deﬁned in numpy on one or more types, covering a wide variety of operations. Some of these ufuncs are called automatically on arrays when the relevant inﬁx notation is used (e.g., add(a, b) is called internally when a + b is written and a or b is an ndarray). Nevertheless, you may still want to use the ufunc call in order to use the optional output argument(s) to place the output(s) in an object (or objects) of your choice. Recall that each ufunc operates element-by-element. Therefore, each ufunc will be described as if acting on a set of scalar inputs to return a set of scalar outputs. Note: The ufunc still returns its output(s) even if you use the optional output argument(s). 446 Chapter 2. Universal functions (ufunc) NumPy Reference, Release 1.8.1 2.7.1 Math operations add(x1, x2[, out]) Add arguments element-wise. subtract(x1, x2[, out]) Subtract arguments, element-wise. multiply(x1, x2[, out]) Multiply arguments element-wise. divide(x1, x2[, out]) Divide arguments element-wise. logaddexp(x1, x2[, out]) Logarithm of the sum of exponentiations of the inputs. logaddexp2(x1, x2[, out]) Logarithm of the sum of exponentiations of the inputs in base-2. true_divide(x1, x2[, out]) Returns a true division of the inputs, element-wise. floor_divide(x1, x2[, out]) Return the largest integer smaller or equal to the division of the inputs. negative(x[, out]) Numerical negative, element-wise. power(x1, x2[, out]) First array elements raised to powers from second array, element-wise. remainder(x1, x2[, out]) Return element-wise remainder of division. mod(x1, x2[, out]) Return element-wise remainder of division. fmod(x1, x2[, out]) Return the element-wise remainder of division. absolute(x[, out]) Calculate the absolute value element-wise. rint(x[, out]) Round elements of the array to the nearest integer. sign(x[, out]) Returns an element-wise indication of the sign of a number. conj(x[, out]) Return the complex conjugate, element-wise. exp(x[, out]) Calculate the exponential of all elements in the input array. exp2(x[, out]) Calculate 2**p for all p in the input array. log(x[, out]) Natural logarithm, element-wise. log2(x[, out]) Base-2 logarithm of x. log10(x[, out]) Return the base 10 logarithm of the input array, element-wise. expm1(x[, out]) Calculate exp(x) - 1 for all elements in the array. log1p(x[, out]) Return the natural logarithm of one plus the input array, element-wise. sqrt(x[, out]) Return the positive square-root of an array, element-wise. square(x[, out]) Return the element-wise square of the input. reciprocal(x[, out]) Return the reciprocal of the argument, element-wise. ones_like(a[, dtype, order, subok]) Return an array of ones with the same shape and type as a given array. Tip: The optional output arguments can be used to help you save memory for large calculations. If your arrays are large, complicated expressions can take longer than absolutely necessary due to the creation and (later) destruction of temporary calculation spaces. For example, the expression G = a * b + c is equivalent to t1 = A * B; G = T1 + C; del t1. It will be more quickly executed as G = A * B; add(G, C, G) which is the same as G = A * B; G += C. 2.7.2 Trigonometric functions All trigonometric functions use radians when an angle is called for. The ratio of degrees to radians is 180◦/π. sin(x[, out]) Trigonometric sine, element-wise. cos(x[, out]) Cosine element-wise. tan(x[, out]) Compute tangent element-wise. arcsin(x[, out]) Inverse sine, element-wise. arccos(x[, out]) Trigonometric inverse cosine, element-wise. arctan(x[, out]) Trigonometric inverse tangent, element-wise. arctan2(x1, x2[, out]) Element-wise arc tangent of x1/x2 choosing the quadrant correctly. Continued on next page 2.7. Available ufuncs 447 NumPy Reference, Release 1.8.1 Table 2.6 – continued from previous page hypot(x1, x2[, out]) Given the “legs” of a right triangle, return its hypotenuse. sinh(x[, out]) Hyperbolic sine, element-wise. cosh(x[, out]) Hyperbolic cosine, element-wise. tanh(x[, out]) Compute hyperbolic tangent element-wise. arcsinh(x[, out]) Inverse hyperbolic sine element-wise. arccosh(x[, out]) Inverse hyperbolic cosine, element-wise. arctanh(x[, out]) Inverse hyperbolic tangent element-wise. deg2rad(x[, out]) Convert angles from degrees to radians. rad2deg(x[, out]) Convert angles from radians to degrees. 2.7.3 Bit-twiddling functions These function all require integer arguments and they manipulate the bit-pattern of those arguments. bitwise_and(x1, x2[, out]) Compute the bit-wise AND of two arrays element-wise. bitwise_or(x1, x2[, out]) Compute the bit-wise OR of two arrays element-wise. bitwise_xor(x1, x2[, out]) Compute the bit-wise XOR of two arrays element-wise. invert(x[, out]) Compute bit-wise inversion, or bit-wise NOT, element-wise. left_shift(x1, x2[, out]) Shift the bits of an integer to the left. right_shift(x1, x2[, out]) Shift the bits of an integer to the right. 2.7.4 Comparison functions greater(x1, x2[, out]) Return the truth value of (x1 > x2) element-wise. greater_equal(x1, x2[, out]) Return the truth value of (x1 >= x2) element-wise. less(x1, x2[, out]) Return the truth value of (x1 < x2) element-wise. less_equal(x1, x2[, out]) Return the truth value of (x1 =< x2) element-wise. not_equal(x1, x2[, out]) Return (x1 != x2) element-wise. equal(x1, x2[, out]) Return (x1 == x2) element-wise. Warning: Do not use the Python keywords and and or to combine logical array expressions. These keywords will test the truth value of the entire array (not element-by-element as you might expect). Use the bitwise operators & and | instead. logical_and(x1, x2[, out]) Compute the truth value of x1 AND x2 element-wise. logical_or(x1, x2[, out]) Compute the truth value of x1 OR x2 element-wise. logical_xor(x1, x2[, out]) Compute the truth value of x1 XOR x2, element-wise. logical_not(x[, out]) Compute the truth value of NOT x element-wise. Warning: The bit-wise operators & and | are the proper way to perform element-by-element array comparisons. Be sure you understand the operator precedence: (a > 2) & (a < 5) is the proper syntax because a > 2 & a < 5 will result in an error due to the fact that 2 & a is evaluated ﬁrst. maximum(x1, x2[, out]) Element-wise maximum of array elements. 448 Chapter 2. Universal functions (ufunc) NumPy Reference, Release 1.8.1 Tip: The Python function max() will ﬁnd the maximum over a one-dimensional array, but it will do so using a slower sequence interface. The reduce method of the maximum ufunc is much faster. Also, the max() method will not give answers you might expect for arrays with greater than one dimension. The reduce method of minimum also allows you to compute a total minimum over an array. minimum(x1, x2[, out]) Element-wise minimum of array elements. Warning: the behavior of maximum(a, b) is different than that of max(a, b). As a ufunc, maximum(a, b) performs an element-by-element comparison of a and b and chooses each element of the result according to which element in the two arrays is larger. In contrast, max(a, b) treats the objects a and b as a whole, looks at the (total) truth value of a > b and uses it to return either a or b (as a whole). A similar difference exists between minimum(a, b) and min(a, b). fmax(x1, x2[, out]) Element-wise maximum of array elements. fmin(x1, x2[, out]) Element-wise minimum of array elements. 2.7.5 Floating functions Recall that all of these functions work element-by-element over an array, returning an array output. The description details only a single operation. isreal(x) Returns a bool array, where True if input element is real. iscomplex(x) Returns a bool array, where True if input element is complex. isfinite(x[, out]) Test element-wise for ﬁniteness (not inﬁnity or not Not a Number). isinf(x[, out]) Test element-wise for positive or negative inﬁnity. isnan(x[, out]) Test element-wise for NaN and return result as a boolean array. signbit(x[, out]) Returns element-wise True where signbit is set (less than zero). copysign(x1, x2[, out]) Change the sign of x1 to that of x2, element-wise. nextafter(x1, x2[, out]) Return the next ﬂoating-point value after x1 towards x2, element-wise. modf(x[, out1, out2]) Return the fractional and integral parts of an array, element-wise. ldexp(x1, x2[, out]) Returns x1 * 2**x2, element-wise. frexp(x[, out1, out2]) Decompose the elements of x into mantissa and twos exponent. fmod(x1, x2[, out]) Return the element-wise remainder of division. floor(x[, out]) Return the ﬂoor of the input, element-wise. ceil(x[, out]) Return the ceiling of the input, element-wise. trunc(x[, out]) Return the truncated value of the input, element-wise. 2.7. Available ufuncs 449 NumPy Reference, Release 1.8.1 450 Chapter 2. Universal functions (ufunc) CHAPTER THREE ROUTINES In this chapter routine docstrings are presented, grouped by functionality. Many docstrings contain example code, which demonstrates basic usage of the routine. The examples assume that NumPy is imported with: >>> import numpy as np A convenient way to execute examples is the %doctest_mode mode of IPython, which allows for pasting of multi- line examples and preserves indentation. 3.1 Array creation routines See Also: Array creation 3.1.1 Ones and zeros empty(shape[, dtype, order]) Return a new array of given shape and type, without initializing entries. empty_like(a[, dtype, order, subok]) Return a new array with the same shape and type as a given array. eye(N[, M, k, dtype]) Return a 2-D array with ones on the diagonal and zeros elsewhere. identity(n[, dtype]) Return the identity array. ones(shape[, dtype, order]) Return a new array of given shape and type, ﬁlled with ones. ones_like(a[, dtype, order, subok]) Return an array of ones with the same shape and type as a given array. zeros(shape[, dtype, order]) Return a new array of given shape and type, ﬁlled with zeros. zeros_like(a[, dtype, order, subok]) Return an array of zeros with the same shape and type as a given array. numpy.empty(shape, dtype=ﬂoat, order=’C’) Return a new array of given shape and type, without initializing entries. Parameters shape : int or tuple of int Shape of the empty array dtype : data-type, optional Desired output data-type. order : {‘C’, ‘F’}, optional 451 NumPy Reference, Release 1.8.1 Whether to store multi-dimensional data in C (row-major) or Fortran (column-major) order in memory. See Also: empty_like, zeros, ones Notes empty, unlike zeros, does not set the array values to zero, and may therefore be marginally faster. On the other hand, it requires the user to manually set all the values in the array, and should be used with caution. Examples >>> np.empty([2,2]) array([[ -9.74499359e+001, 6.69583040e-309], [ 2.13182611e-314, 3.06959433e-309]]) #random >>> np.empty([2,2], dtype=int) array([[-1073741821, -1067949133], [ 496041986, 19249760]]) #random numpy.empty_like(a, dtype=None, order=’K’, subok=True) Return a new array with the same shape and type as a given array. Parameters a : array_like The shape and data-type of a deﬁne these same attributes of the returned array. dtype : data-type, optional New in version 1.6.0. Overrides the data type of the result. order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional New in version 1.6.0. Overrides the memory layout of the result. ‘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. subok : bool, optional. If True, then the newly created array will use the sub-class type of ‘a’, otherwise it will be a base-class array. Defaults to True. Returns out : ndarray Array of uninitialized (arbitrary) data with the same shape and type as a. See Also: ones_like Return an array of ones with shape and type of input. zeros_like Return an array of zeros with shape and type of input. empty Return a new uninitialized array. ones Return a new array setting values to one. 452 Chapter 3. Routines NumPy Reference, Release 1.8.1 zeros Return a new array setting values to zero. Notes This function does not initialize the returned array; to do that use zeros_like or ones_like instead. It may be marginally faster than the functions that do set the array values. Examples >>> a=([1,2,3], [4,5,6]) # a is array-like >>> np.empty_like(a) array([[-1073741821, -1073741821, 3], #random [ 0, 0, -1073741821]]) >>> a= np.array([[1., 2., 3.],[4.,5.,6.]]) >>> np.empty_like(a) array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000],#random [ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]]) numpy.eye(N, M=None, k=0, dtype=) Return a 2-D array with ones on the diagonal and zeros elsewhere. Parameters N: int Number of rows in the output. M: int, optional Number of columns in the output. If None, defaults to N. k : int, optional Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal. dtype : data-type, optional Data-type of the returned array. Returns I: ndarray of shape (N,M) An array where all elements are equal to zero, except for the k-th diagonal, whose values are equal to one. See Also: identity (almost) equivalent function diag diagonal 2-D array from a 1-D array speciﬁed by the user. Examples >>> np.eye(2, dtype=int) array([[1, 0], [0, 1]]) >>> np.eye(3, k=1) array([[ 0., 1., 0.], [ 0., 0., 1.], [ 0., 0., 0.]]) 3.1. Array creation routines 453 NumPy Reference, Release 1.8.1 numpy.identity(n, dtype=None) Return the identity array. The identity array is a square array with ones on the main diagonal. Parameters n : int Number of rows (and columns) in n x n output. dtype : data-type, optional Data-type of the output. Defaults to float. Returns out : ndarray n x n array with its main diagonal set to one, and all other elements 0. Examples >>> np.identity(3) array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]]) numpy.ones(shape, dtype=None, order=’C’) Return a new array of given shape and type, ﬁlled with ones. Parameters shape : int or sequence of ints Shape of the new array, e.g., (2, 3) or 2. dtype : data-type, optional The desired data-type for the array, e.g., numpy.int8. Default is numpy.float64. order : {‘C’, ‘F’}, optional Whether to store multidimensional data in C- or Fortran-contiguous (row- or column- wise) order in memory. Returns out : ndarray Array of ones with the given shape, dtype, and order. See Also: zeros, ones_like Examples >>> np.ones(5) array([ 1., 1., 1., 1., 1.]) >>> np.ones((5,), dtype=np.int) array([1, 1, 1, 1, 1]) >>> np.ones((2,1)) array([[ 1.], [ 1.]]) 454 Chapter 3. Routines NumPy Reference, Release 1.8.1 >>> s=(2,2) >>> np.ones(s) array([[ 1., 1.], [ 1., 1.]]) numpy.ones_like(a, dtype=None, order=’K’, subok=True) Return an array of ones with the same shape and type as a given array. Parameters a : array_like The shape and data-type of a deﬁne these same attributes of the returned array. dtype : data-type, optional New in version 1.6.0. Overrides the data type of the result. order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional New in version 1.6.0. Overrides the memory layout of the result. ‘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. subok : bool, optional. If True, then the newly created array will use the sub-class type of ‘a’, otherwise it will be a base-class array. Defaults to True. Returns out : ndarray Array of ones with the same shape and type as a. See Also: zeros_like Return an array of zeros with shape and type of input. empty_like Return an empty array with shape and type of input. zeros Return a new array setting values to zero. ones Return a new array setting values to one. empty Return a new uninitialized array. Examples >>> x= np.arange(6) >>> x=x.reshape((2,3)) >>> x array([[0, 1, 2], [3, 4, 5]]) >>> np.ones_like(x) array([[1, 1, 1], [1, 1, 1]]) 3.1. Array creation routines 455 NumPy Reference, Release 1.8.1 >>> y= np.arange(3, dtype=np.float) >>> y array([ 0., 1., 2.]) >>> np.ones_like(y) array([ 1., 1., 1.]) numpy.zeros(shape, dtype=ﬂoat, order=’C’) Return a new array of given shape and type, ﬁlled with zeros. Parameters shape : int or sequence of ints Shape of the new array, e.g., (2, 3) or 2. dtype : data-type, optional The desired data-type for the array, e.g., numpy.int8. Default is numpy.float64. order : {‘C’, ‘F’}, optional Whether to store multidimensional data in C- or Fortran-contiguous (row- or column- wise) order in memory. Returns out : ndarray Array of zeros with the given shape, dtype, and order. See Also: zeros_like Return an array of zeros with shape and type of input. ones_like Return an array of ones with shape and type of input. empty_like Return an empty array with shape and type of input. ones Return a new array setting values to one. empty Return a new uninitialized array. Examples >>> np.zeros(5) array([ 0., 0., 0., 0., 0.]) >>> np.zeros((5,), dtype=numpy.int) array([0, 0, 0, 0, 0]) >>> np.zeros((2,1)) array([[ 0.], [ 0.]]) >>> s=(2,2) >>> np.zeros(s) array([[ 0., 0.], [ 0., 0.]]) 456 Chapter 3. Routines NumPy Reference, Release 1.8.1 >>> np.zeros((2,), dtype=[(’x’,’i4’), (’y’,’i4’)]) # custom dtype array([(0, 0), (0, 0)], dtype=[(’x’, ’>> x= np.arange(6) >>> x=x.reshape((2,3)) >>> x array([[0, 1, 2], [3, 4, 5]]) >>> np.zeros_like(x) array([[0, 0, 0], [0, 0, 0]]) 3.1. Array creation routines 457 NumPy Reference, Release 1.8.1 >>> y= np.arange(3, dtype=np.float) >>> y array([ 0., 1., 2.]) >>> np.zeros_like(y) array([ 0., 0., 0.]) 3.1.2 From existing data array(object[, dtype, copy, order, subok, ndmin]) Create an array. asarray(a[, dtype, order]) Convert the input to an array. asanyarray(a[, dtype, order]) Convert the input to an ndarray, but pass ndarray subclasses through. ascontiguousarray(a[, dtype]) Return a contiguous array in memory (C order). asmatrix(data[, dtype]) Interpret the input as a matrix. copy(a[, order]) Return an array copy of the given object. frombuffer(buffer[, dtype, count, offset]) Interpret a buffer as a 1-dimensional array. fromfile(ﬁle[, dtype, count, sep]) Construct an array from data in a text or binary ﬁle. fromfunction(function, shape, **kwargs) Construct an array by executing a function over each coordinate. fromiter(iterable, dtype[, count]) Create a new 1-dimensional array from an iterable object. fromstring(string[, dtype, count, sep]) A new 1-D array initialized from raw binary or text data in a string. loadtxt(fname[, dtype, comments, delimiter, ...]) Load data from a text ﬁle. numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0) Create an array. Parameters object : array_like An array, any object exposing the array interface, an object whose __array__ method returns an array, or any (nested) sequence. dtype : data-type, optional The desired data-type for the array. If not given, then the type will be determined as the minimum type required to hold the objects in the sequence. This argument can only be used to ‘upcast’ the array. For downcasting, use the .astype(t) method. 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.). order : {‘C’, ‘F’, ‘A’}, optional Specify the order of the array. If order is ‘C’ (default), then the array will be in C- contiguous order (last-index varies the fastest). If order is ‘F’, then the returned array will be in Fortran-contiguous order (ﬁrst-index varies the fastest). If order is ‘A’, then the returned array may be in any order (either C-, Fortran-contiguous, or even discon- tiguous). 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 458 Chapter 3. Routines NumPy Reference, Release 1.8.1 Speciﬁes the minimum number of dimensions that the resulting array should have. Ones will be pre-pended to the shape as needed to meet this requirement. Returns out : ndarray An array object satisfying the speciﬁed requirements. See Also: empty, empty_like, zeros, zeros_like, ones, ones_like, fill Examples >>> np.array([1,2,3]) array([1, 2, 3]) Upcasting: >>> np.array([1,2, 3.0]) array([ 1., 2., 3.]) More than one dimension: >>> np.array([[1,2], [3,4]]) array([[1, 2], [3, 4]]) Minimum dimensions 2: >>> np.array([1,2,3], ndmin=2) array([[1, 2, 3]]) Type provided: >>> np.array([1,2,3], dtype=complex) array([ 1.+0.j, 2.+0.j, 3.+0.j]) Data-type consisting of more than one element: >>> x= np.array([(1,2),(3,4)],dtype=[(’a’,’>> x[’a’] array([1, 3]) Creating an array from sub-classes: >>> np.array(np.mat(’1 2; 3 4’)) array([[1, 2], [3, 4]]) >>> np.array(np.mat(’1 2; 3 4’), subok=True) matrix([[1, 2], [3, 4]]) numpy.asarray(a, dtype=None, order=None) Convert the input to an array. Parameters a : array_like Input data, in any form that can be converted to an array. This includes lists, lists of tuples, tuples, tuples of tuples, tuples of lists and ndarrays. 3.1. Array creation routines 459 NumPy Reference, Release 1.8.1 dtype : data-type, optional By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional Whether to use row-major (‘C’) or column-major (‘F’ for FORTRAN) memory repre- sentation. Defaults to ‘C’. Returns out : ndarray Array interpretation of a. No copy is performed if the input is already an ndarray. If a is a subclass of ndarray, a base class ndarray is returned. See Also: asanyarray Similar function which passes through subclasses. ascontiguousarray Convert input to a contiguous array. asfarray Convert input to a ﬂoating point ndarray. asfortranarray Convert input to an ndarray with column-major memory order. asarray_chkfinite Similar function which checks input for NaNs and Infs. fromiter Create an array from an iterator. fromfunction Construct an array by executing a function on grid positions. Examples Convert a list into an array: >>> a=[1,2] >>> np.asarray(a) array([1, 2]) Existing arrays are not copied: >>> a= np.array([1,2]) >>> np.asarray(a) is a True If dtype is set, array is copied only if dtype does not match: >>> a= np.array([1,2], dtype=np.float32) >>> np.asarray(a, dtype=np.float32) is a True >>> np.asarray(a, dtype=np.float64) is a False Contrary to asanyarray, ndarray subclasses are not passed through: 460 Chapter 3. Routines NumPy Reference, Release 1.8.1 >>> issubclass(np.matrix, np.ndarray) True >>> a= np.matrix([[1,2]]) >>> np.asarray(a) is a False >>> np.asanyarray(a) is a True numpy.asanyarray(a, dtype=None, order=None) Convert the input to an ndarray, but pass ndarray subclasses through. Parameters a : array_like Input data, in any form that can be converted to an array. This includes scalars, lists, lists of tuples, tuples, tuples of tuples, tuples of lists, and ndarrays. dtype : data-type, optional By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional Whether to use row-major (‘C’) or column-major (‘F’) memory representation. Defaults to ‘C’. Returns out : ndarray or an ndarray subclass Array interpretation of a. If a is an ndarray or a subclass of ndarray, it is returned as-is and no copy is performed. See Also: asarray Similar function which always returns ndarrays. ascontiguousarray Convert input to a contiguous array. asfarray Convert input to a ﬂoating point ndarray. asfortranarray Convert input to an ndarray with column-major memory order. asarray_chkfinite Similar function which checks input for NaNs and Infs. fromiter Create an array from an iterator. fromfunction Construct an array by executing a function on grid positions. Examples Convert a list into an array: >>> a=[1,2] >>> np.asanyarray(a) array([1, 2]) 3.1. Array creation routines 461 NumPy Reference, Release 1.8.1 Instances of ndarray subclasses are passed through as-is: >>> a= np.matrix([1,2]) >>> np.asanyarray(a) is a True numpy.ascontiguousarray(a, dtype=None) Return a contiguous array in memory (C order). Parameters a : array_like Input array. dtype : str or dtype object, optional Data-type of returned array. Returns out : ndarray Contiguous array of same shape and content as a, with type dtype if speciﬁed. See Also: asfortranarray Convert input to an ndarray with column-major memory order. require Return an ndarray that satisﬁes requirements. ndarray.flags Information about the memory layout of the array. Examples >>> x= np.arange(6).reshape(2,3) >>> np.ascontiguousarray(x, dtype=np.float32) array([[ 0., 1., 2.], [ 3., 4., 5.]], dtype=float32) >>> x.flags[’C_CONTIGUOUS’] True numpy.asmatrix(data, dtype=None) Interpret the input as a matrix. Unlike matrix, asmatrix does not make a copy if the input is already a matrix or an ndarray. Equivalent to matrix(data, copy=False). Parameters data : array_like Input data. Returns mat : matrix data interpreted as a matrix. Examples >>> x= np.array([[1,2], [3,4]]) 462 Chapter 3. Routines NumPy Reference, Release 1.8.1 >>> m= np.asmatrix(x) >>> x[0,0]=5 >>> m matrix([[5, 2], [3, 4]]) numpy.copy(a, order=’K’) Return an array copy of the given object. Parameters a : array_like Input data. 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 :meth:ndarray.copy are very similar, but have different default values for their order= arguments.) Returns arr : ndarray Array interpretation of a. Notes This is equivalent to >>> np.array(a, copy=True) Examples Create an array x, with a reference y and a copy z: >>> x= np.array([1,2,3]) >>> y=x >>> z= np.copy(x) Note that, when we modify x, y changes, but not z: >>> x[0]= 10 >>> x[0] == y[0] True >>> x[0] == z[0] False numpy.frombuffer(buffer, dtype=ﬂoat, count=-1, offset=0) Interpret a buffer as a 1-dimensional array. Parameters buffer : buffer_like An object that exposes the buffer interface. dtype : data-type, optional Data-type of the returned array; default: ﬂoat. count : int, optional 3.1. Array creation routines 463 NumPy Reference, Release 1.8.1 Number of items to read. -1 means all data in the buffer. offset : int, optional Start reading the buffer from this offset; default: 0. Notes If the buffer has data that is not in machine byte-order, this should be speciﬁed as part of the data-type, e.g.: >>> dt= np.dtype(int) >>> dt= dt.newbyteorder(’>’) >>> np.frombuffer(buf, dtype=dt) The data of the resulting array will not be byteswapped, but will be interpreted correctly. Examples >>> s=’hello world’ >>> np.frombuffer(s, dtype=’S1’, count=5, offset=6) array([’w’, ’o’, ’r’, ’l’, ’d’], dtype=’|S1’) numpy.fromfile(ﬁle, dtype=ﬂoat, count=-1, sep=’‘) Construct an array from data in a text or binary ﬁle. A highly efﬁcient way of reading binary data with a known data-type, as well as parsing simply formatted text ﬁles. Data written using the toﬁle method can be read using this function. Parameters ﬁle : ﬁle or str Open ﬁle object or ﬁlename. dtype : data-type Data type of the returned array. For binary ﬁles, it is used to determine the size and byte-order of the items in the ﬁle. count : int Number of items to read. -1 means all items (i.e., the complete ﬁle). sep : str Separator between items if ﬁle is a text ﬁle. Empty (“”) separator means the ﬁle should be treated as binary. Spaces (” ”) in the separator match zero or more whitespace char- acters. A separator consisting only of spaces must match at least one whitespace. See Also: load, save, ndarray.tofile loadtxt More ﬂexible way of loading data from a text ﬁle. Notes Do not rely on the combination of toﬁle and fromfile for data storage, as the binary ﬁles generated are are not platform independent. In particular, no byte-order or data-type information is saved. Data can be stored in the platform independent .npy format using save and load instead. 464 Chapter 3. Routines NumPy Reference, Release 1.8.1 Examples Construct an ndarray: >>> dt= np.dtype([(’time’, [(’min’, int), (’sec’, int)]), ... (’temp’, float)]) >>> x= np.zeros((1,), dtype=dt) >>> x[’time’][’min’]= 10; x[’temp’]= 98.25 >>> x array([((10, 0), 98.25)], dtype=[(’time’, [(’min’, ’>> import os >>> fname= os.tmpnam() >>> x.tofile(fname) Read the raw data from disk: >>> np.fromfile(fname, dtype=dt) array([((10, 0), 98.25)], dtype=[(’time’, [(’min’, ’>> np.save(fname, x) >>> np.load(fname+’.npy’) array([((10, 0), 98.25)], dtype=[(’time’, [(’min’, ’>> np.fromfunction(lambda i, j: i == j, (3,3), dtype=int) array([[ True, False, False], [False, True, False], [False, False, True]], dtype=bool) >>> np.fromfunction(lambda i, j: i+ j, (3,3), dtype=int) array([[0, 1, 2], [1, 2, 3], [2, 3, 4]]) numpy.fromiter(iterable, dtype, count=-1) Create a new 1-dimensional array from an iterable object. Parameters iterable : iterable object An iterable object providing data for the array. dtype : data-type The data-type of the returned array. count : int, optional The number of items to read from iterable. The default is -1, which means all data is read. Returns out : ndarray The output array. Notes Specify count to improve performance. It allows fromiter to pre-allocate the output array, instead of resizing it on demand. Examples >>> iterable= (x *x for x in range(5)) >>> np.fromiter(iterable, np.float) array([ 0., 1., 4., 9., 16.]) numpy.fromstring(string, dtype=ﬂoat, count=-1, sep=’‘) A new 1-D array initialized from raw binary or text data in a string. Parameters string : str A string containing the data. dtype : data-type, optional The data type of the array; default: ﬂoat. For binary input data, the data must be in exactly this format. count : int, optional 466 Chapter 3. Routines NumPy Reference, Release 1.8.1 Read this number of dtype elements from the data. If this is negative (the default), the count will be determined from the length of the data. sep : str, optional If not provided or, equivalently, the empty string, the data will be interpreted as binary data; otherwise, as ASCII text with decimal numbers. Also in this latter case, this argument is interpreted as the string separating numbers in the data; extra whitespace between elements is also ignored. Returns arr : ndarray The constructed array. Raises ValueError If the string is not the correct size to satisfy the requested dtype and count. See Also: frombuffer, fromfile, fromiter Examples >>> np.fromstring(’\x01\x02’, dtype=np.uint8) array([1, 2], dtype=uint8) >>> np.fromstring(’1 2’, dtype=int, sep=’’) array([1, 2]) >>> np.fromstring(’1, 2’, dtype=int, sep=’,’) array([1, 2]) >>> np.fromstring(’\x01\x02\x03\x04\x05’, dtype=np.uint8, count=3) array([1, 2, 3], dtype=uint8) numpy.loadtxt(fname, dtype=, comments=’#’, delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0) Load data from a text ﬁle. Each row in the text ﬁle must have the same number of values. Parameters fname : ﬁle or str File, ﬁlename, or generator to read. If the ﬁlename extension is .gz or .bz2, the ﬁle is ﬁrst decompressed. Note that generators should return byte strings for Python 3k. dtype : data-type, optional Data-type of the resulting array; default: ﬂoat. If this is a record data-type, the resulting array will be 1-dimensional, and each row will be interpreted as an element of the array. In this case, the number of columns used must match the number of ﬁelds in the data- type. comments : str, optional The character used to indicate the start of a comment; default: ‘#’. delimiter : str, optional The string used to separate values. By default, this is any whitespace. converters : dict, optional 3.1. Array creation routines 467 NumPy Reference, Release 1.8.1 A dictionary mapping column number to a function that will convert that col- umn to a ﬂoat. E.g., if column 0 is a date string: converters = {0: datestr2num}. Converters can also be used to provide a default value for missing data (but see also genfromtxt): converters = {3: lambda s: float(s.strip() or 0)}. Default: None. skiprows : int, optional Skip the ﬁrst skiprows lines; default: 0. usecols : sequence, optional Which columns to read, with 0 being the ﬁrst. For example, usecols = (1,4,5) will extract the 2nd, 5th and 6th columns. The default, None, results in all columns being read. unpack : bool, optional If True, the returned array is transposed, so that arguments may be unpacked using x, y, z = loadtxt(...). When used with a record data-type, arrays are returned for each ﬁeld. Default is False. ndmin : int, optional The returned array will have at least ndmin dimensions. Otherwise mono-dimensional axes will be squeezed. Legal values: 0 (default), 1 or 2. New in version 1.6.0. Returns out : ndarray Data read from the text ﬁle. See Also: load, fromstring, fromregex genfromtxt Load data with missing values handled as speciﬁed. scipy.io.loadmat reads MATLAB data ﬁles Notes This function aims to be a fast reader for simply formatted ﬁles. The genfromtxt function provides more sophisticated handling of, e.g., lines with missing values. Examples >>> from StringIO import StringIO # StringIO behaves like a file object >>> c= StringIO("0 1 \n2 3") >>> np.loadtxt(c) array([[ 0., 1.], [ 2., 3.]]) >>> d= StringIO("M 21 72 \nF 35 58") >>> np.loadtxt(d, dtype={’names’:(’gender’,’age’,’weight’), ... ’formats’:(’S1’,’i4’,’f4’)}) array([(’M’, 21, 72.0), (’F’, 35, 58.0)], dtype=[(’gender’, ’|S1’), (’age’, ’>> c= StringIO("1,0,2 \n3,0,4") >>> x, y= np.loadtxt(c, delimiter=’,’, usecols=(0,2), unpack=True) >>> x array([ 1., 3.]) >>> y array([ 2., 4.]) 3.1.3 Creating record arrays (numpy.rec) core.records.array(obj[, dtype, shape, ...]) Construct a record array from a wide-variety of objects. core.records.fromarrays(arrayList[, dtype, ...]) create a record array from a (ﬂat) list of arrays core.records.fromrecords(recList[, dtype, ...]) create a recarray from a list of records in text form core.records.fromstring(datastring[, dtype, ...]) create a (read-only) record array from binary data contained in core.records.fromfile(fd[, dtype, shape, ...]) Create an array from binary ﬁle data numpy.core.records.array(obj, dtype=None, shape=None, offset=0, strides=None, formats=None, names=None, titles=None, aligned=False, byteorder=None, copy=True) Construct a record array from a wide-variety of objects. numpy.core.records.fromarrays(arrayList, dtype=None, shape=None, formats=None, names=None, titles=None, aligned=False, byteorder=None) create a record array from a (ﬂat) list of arrays >>> x1=np.array([1,2,3,4]) >>> x2=np.array([’a’,’dd’,’xyz’,’12’]) >>> x3=np.array([1.1,2,3,4]) >>> r= np.core.records.fromarrays([x1,x2,x3],names=’a,b,c’) >>> print r[1] (2, ’dd’, 2.0) >>> x1[1]=34 >>> r.a array([1, 2, 3, 4]) numpy.core.records.fromrecords(recList, dtype=None, shape=None, formats=None, names=None, titles=None, aligned=False, byteorder=None) create a recarray from a list of records in text form The data in the same ﬁeld can be heterogeneous, they will be promoted to the highest data type. This method is intended for creating smaller record arrays. If used to create large array without formats deﬁned r=fromrecords([(2,3.,’abc’)]*100000) it can be slow. If formats is None, then this will auto-detect formats. Use list of tuples rather than list of lists for faster processing. >>> r=np.core.records.fromrecords([(456,’dbe’,1.2),(2,’de’,1.3)], ... names=’col1,col2,col3’) >>> print r[0] (456, ’dbe’, 1.2) >>> r.col1 array([456, 2]) >>> r.col2 chararray([’dbe’, ’de’], dtype=’|S3’) 3.1. Array creation routines 469 NumPy Reference, Release 1.8.1 >>> import pickle >>> print pickle.loads(pickle.dumps(r)) [(456, ’dbe’, 1.2) (2, ’de’, 1.3)] numpy.core.records.fromstring(datastring, dtype=None, shape=None, offset=0, formats=None, names=None, titles=None, aligned=False, byteorder=None) create a (read-only) record array from binary data contained in a string numpy.core.records.fromfile(fd, dtype=None, shape=None, offset=0, formats=None, names=None, titles=None, aligned=False, byteorder=None) Create an array from binary ﬁle data If ﬁle is a string then that ﬁle is opened, else it is assumed to be a ﬁle object. >>> from tempfile import TemporaryFile >>> a= np.empty(10,dtype=’f8,i4,a5’) >>> a[5]=(0.5,10,’abcde’) >>> >>> fd=TemporaryFile() >>> a=a.newbyteorder(’<’) >>> a.tofile(fd) >>> >>> fd.seek(0) >>> r=np.core.records.fromfile(fd, formats=’f8,i4,a5’, shape=10, ... byteorder=’<’) >>> print r[5] (0.5, 10, ’abcde’) >>> r.shape (10,) 3.1.4 Creating character arrays (numpy.char) core.defchararray.array(obj[, itemsize, ...]) Create a chararray. core.defchararray.asarray(obj[, itemsize, ...]) Convert the input to a chararray, copying the data only if necessary. numpy.core.defchararray.array(obj, itemsize=None, copy=True, unicode=None, order=None) Create a chararray. Note: This class is provided for numarray backward-compatibility. New code (not concerned with numarray compatibility) should use arrays of type string_ or unicode_ and use the free functions in numpy.char for fast vectorized string operations instead. Versus a regular Numpy array of type str or unicode, this class adds the following functionality: 1.values automatically have whitespace removed from the end when indexed 2.comparison operators automatically remove whitespace from the end when comparing values 3.vectorized string operations are provided as methods (e.g. str.endswith) and inﬁx operators (e.g. +, *, %) Parameters obj : array of str or unicode-like itemsize : int, optional 470 Chapter 3. Routines NumPy Reference, Release 1.8.1 itemsize is the number of characters per scalar in the resulting array. If itemsize is None, and obj is an object array or a Python list, the itemsize will be automatically determined. If itemsize is provided and obj is of type str or unicode, then the obj string will be chunked into itemsize pieces. 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 (itemsize, unicode, order, etc.). unicode : bool, optional When true, the resulting chararray can contain Unicode characters, when false only 8-bit characters. If unicode is None and obj is one of the following: •a chararray, • an ndarray of type str or unicode • a Python str or unicode object, then the unicode setting of the output array will be automatically determined. order : {‘C’, ‘F’, ‘A’}, optional Specify the order of the array. If order is ‘C’ (default), then the array will be in C- contiguous order (last-index varies the fastest). If order is ‘F’, then the returned array will be in Fortran-contiguous order (ﬁrst-index varies the fastest). If order is ‘A’, then the returned array may be in any order (either C-, Fortran-contiguous, or even discon- tiguous). numpy.core.defchararray.asarray(obj, itemsize=None, unicode=None, order=None) Convert the input to a chararray, copying the data only if necessary. Versus a regular Numpy array of type str or unicode, this class adds the following functionality: 1.values automatically have whitespace removed from the end when indexed 2.comparison operators automatically remove whitespace from the end when comparing values 3.vectorized string operations are provided as methods (e.g. str.endswith) and inﬁx operators (e.g. +, *, %) Parameters obj : array of str or unicode-like itemsize : int, optional itemsize is the number of characters per scalar in the resulting array. If itemsize is None, and obj is an object array or a Python list, the itemsize will be automatically determined. If itemsize is provided and obj is of type str or unicode, then the obj string will be chunked into itemsize pieces. unicode : bool, optional When true, the resulting chararray can contain Unicode characters, when false only 8-bit characters. If unicode is None and obj is one of the following: •a chararray, • an ndarray of type str or ‘unicode‘ • a Python str or unicode object, then the unicode setting of the output array will be automatically determined. 3.1. Array creation routines 471 NumPy Reference, Release 1.8.1 order : {‘C’, ‘F’}, optional Specify the order of the array. If order is ‘C’ (default), then the array will be in C- contiguous order (last-index varies the fastest). If order is ‘F’, then the returned array will be in Fortran-contiguous order (ﬁrst-index varies the fastest). 3.1.5 Numerical ranges arange([start,] stop[, step,][, dtype]) Return evenly spaced values within a given interval. linspace(start, stop[, num, endpoint, retstep]) Return evenly spaced numbers over a speciﬁed interval. logspace(start, stop[, num, endpoint, base]) Return numbers spaced evenly on a log scale. meshgrid(*xi, **kwargs) Return coordinate matrices from two or more coordinate vectors. mgrid nd_grid instance which returns a dense multi-dimensional “meshgrid”. ogrid nd_grid instance which returns an open multi-dimensional “meshgrid”. numpy.arange([start ], stop[, step], dtype=None) Return evenly spaced values within a given interval. Values are generated within the half-open interval [start, stop) (in other words, the interval including start but excluding stop). For integer arguments the function is equivalent to the Python built-in range function, but returns an ndarray rather than a list. When using a non-integer step, such as 0.1, the results will often not be consistent. It is better to use linspace for these cases. Parameters start : number, optional Start of interval. The interval includes this value. The default start value is 0. stop : number End of interval. The interval does not include this value, except in some cases where step is not an integer and ﬂoating point round-off affects the length of out. step : number, optional Spacing between values. For any output out, this is the distance between two adjacent values, out[i+1] - out[i]. The default step size is 1. If step is speciﬁed, start must also be given. dtype : dtype The type of the output array. If dtype is not given, infer the data type from the other input arguments. Returns arange : ndarray Array of evenly spaced values. For ﬂoating point arguments, the length of the result is ceil((stop - start)/step). Because of ﬂoating point overﬂow, this rule may result in the last element of out being greater than stop. See Also: linspace Evenly spaced numbers with careful handling of endpoints. 472 Chapter 3. Routines NumPy Reference, Release 1.8.1 ogrid Arrays of evenly spaced numbers in N-dimensions. mgrid Grid-shaped arrays of evenly spaced numbers in N-dimensions. Examples >>> np.arange(3) array([0, 1, 2]) >>> np.arange(3.0) array([ 0., 1., 2.]) >>> np.arange(3,7) array([3, 4, 5, 6]) >>> np.arange(3,7,2) array([3, 5]) numpy.linspace(start, stop, num=50, endpoint=True, retstep=False) Return evenly spaced numbers over a speciﬁed interval. Returns num evenly spaced samples, calculated over the interval [start, stop ]. The endpoint of the interval can optionally be excluded. Parameters start : scalar The starting value of the sequence. stop : scalar The end value of the sequence, unless endpoint is set to False. In that case, the sequence consists of all but the last of num + 1 evenly spaced samples, so that stop is excluded. Note that the step size changes when endpoint is False. num : int, optional Number of samples to generate. Default is 50. endpoint : bool, optional If True, stop is the last sample. Otherwise, it is not included. Default is True. retstep : bool, optional If True, return (samples, step), where step is the spacing between samples. Returns samples : ndarray There are num equally spaced samples in the closed interval [start, stop] or the half-open interval [start, stop) (depending on whether endpoint is True or False). step : ﬂoat (only if retstep is True) Size of spacing between samples. See Also: arange Similar to linspace, but uses a step size (instead of the number of samples). logspace Samples uniformly distributed in log space. 3.1. Array creation routines 473 NumPy Reference, Release 1.8.1 Examples >>> np.linspace(2.0, 3.0, num=5) array([ 2. , 2.25, 2.5 , 2.75, 3. ]) >>> np.linspace(2.0, 3.0, num=5, endpoint=False) array([ 2. , 2.2, 2.4, 2.6, 2.8]) >>> np.linspace(2.0, 3.0, num=5, retstep=True) (array([ 2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) Graphical illustration: >>> import matplotlib.pyplot as plt >>> N=8 >>> y= np.zeros(N) >>> x1= np.linspace(0, 10, N, endpoint=True) >>> x2= np.linspace(0, 10, N, endpoint=False) >>> plt.plot(x1, y,’o’) [] >>> plt.plot(x2, y+ 0.5,’o’) [] >>> plt.ylim([-0.5,1]) (-0.5, 1) >>> plt.show() 0 2 4 6 8 10 0.4 0.2 0.0 0.2 0.4 0.6 0.8 1.0 numpy.logspace(start, stop, num=50, endpoint=True, base=10.0) Return numbers spaced evenly on a log scale. In linear space, the sequence starts at base ** start (base to the power of start) and ends with base ** stop (see endpoint below). Parameters start : ﬂoat base ** start is the starting value of the sequence. stop : ﬂoat base ** stop is the ﬁnal value of the sequence, unless endpoint is False. In that case, num + 1 values are spaced over the interval in log-space, of which all but the last (a sequence of length num) are returned. 474 Chapter 3. Routines NumPy Reference, Release 1.8.1 num : integer, optional Number of samples to generate. Default is 50. endpoint : boolean, optional If true, stop is the last sample. Otherwise, it is not included. Default is True. base : ﬂoat, optional The base of the log space. The step size between the elements in ln(samples) / ln(base) (or log_base(samples)) is uniform. Default is 10.0. Returns samples : ndarray num samples, equally spaced on a log scale. See Also: arange Similar to linspace, with the step size speciﬁed instead of the number of samples. Note that, when used with a ﬂoat endpoint, the endpoint may or may not be included. linspace Similar to logspace, but with the samples uniformly distributed in linear space, instead of log space. Notes Logspace is equivalent to the code >>> y= np.linspace(start, stop, num=num, endpoint=endpoint) ... >>> power(base, y) ... Examples >>> np.logspace(2.0, 3.0, num=4) array([ 100. , 215.443469 , 464.15888336, 1000. ]) >>> np.logspace(2.0, 3.0, num=4, endpoint=False) array([ 100. , 177.827941 , 316.22776602, 562.34132519]) >>> np.logspace(2.0, 3.0, num=4, base=2.0) array([ 4. , 5.0396842 , 6.34960421, 8. ]) Graphical illustration: >>> import matplotlib.pyplot as plt >>> N= 10 >>> x1= np.logspace(0.1,1, N, endpoint=True) >>> x2= np.logspace(0.1,1, N, endpoint=False) >>> y= np.zeros(N) >>> plt.plot(x1, y,’o’) [] >>> plt.plot(x2, y+ 0.5,’o’) [] >>> plt.ylim([-0.5,1]) (-0.5, 1) >>> plt.show() 3.1. Array creation routines 475 NumPy Reference, Release 1.8.1 1 2 3 4 5 6 7 8 9 10 0.4 0.2 0.0 0.2 0.4 0.6 0.8 1.0 numpy.meshgrid(*xi,**kwargs) Return coordinate matrices from two or more coordinate vectors. Make N-D coordinate arrays for vectorized evaluations of N-D scalar/vector ﬁelds over N-D grids, given one- dimensional coordinate arrays x1, x2,..., xn. Parameters x1, x2,..., xn : array_like 1-D arrays representing the coordinates of a grid. indexing : {‘xy’, ‘ij’}, optional Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output. See Notes for more details. sparse : bool, optional If True a sparse grid is returned in order to conserve memory. Default is False. copy : bool, optional If False, a view into the original arrays are returned in order to conserve memory. De- fault is True. Please note that sparse=False, copy=False will likely return non-contiguous arrays. Furthermore, more than one element of a broadcast array may refer to a single memory location. If you need to write to the arrays, make copies ﬁrst. Returns X1, X2,..., XN : ndarray For vectors x1, x2,..., ‘xn’ with lengths Ni=len(xi) , return (N1, N2, N3,...Nn) shaped arrays if indexing=’ij’ or (N2, N1, N3,...Nn) shaped ar- rays if indexing=’xy’ with the elements of xi repeated to ﬁll the matrix along the ﬁrst dimension for x1, the second for x2 and so on. See Also: index_tricks.mgrid Construct a multi-dimensional “meshgrid” using indexing notation. index_tricks.ogrid Construct an open multi-dimensional “meshgrid” using indexing notation. 476 Chapter 3. Routines NumPy Reference, Release 1.8.1 Notes This function supports both indexing conventions through the indexing keyword argument. Giving the string ‘ij’ returns a meshgrid with matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing. In the 2-D case with inputs of length M and N, the outputs are of shape (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing. In the 3-D case with inputs of length M, N and P, outputs are of shape (N, M, P) for ‘xy’ indexing and (M, N, P) for ‘ij’ indexing. The difference is illustrated by the following code snippet: xv, yv = meshgrid(x, y, sparse=False, indexing=’ij’) for i in range(nx): for j in range(ny): # treat xv[i,j], yv[i,j] xv, yv = meshgrid(x, y, sparse=False, indexing=’xy’) for i in range(nx): for j in range(ny): # treat xv[j,i], yv[j,i] In the 1-D and 0-D case, the indexing and sparse keywords have no effect. Examples >>> nx, ny=(3,2) >>> x= np.linspace(0,1, nx) >>> y= np.linspace(0,1, ny) >>> xv, yv= meshgrid(x, y) >>> xv array([[ 0. , 0.5, 1. ], [ 0. , 0.5, 1. ]]) >>> yv array([[ 0., 0., 0.], [ 1., 1., 1.]]) >>> xv, yv= meshgrid(x, y, sparse=True)# make sparse output arrays >>> xv array([[ 0. , 0.5, 1. ]]) >>> yv array([[ 0.], [ 1.]]) meshgrid is very useful to evaluate functions on a grid. >>> x= np.arange(-5,5, 0.1) >>> y= np.arange(-5,5, 0.1) >>> xx, yy= meshgrid(x, y, sparse=True) >>> z= np.sin(xx **2+ yy **2)/ (xx **2+ yy **2) >>> h= plt.contourf(x,y,z) numpy.mgrid = nd_grid instance which returns a dense multi-dimensional “meshgrid”. An instance of numpy.lib.index_tricks.nd_grid which returns an dense (or ﬂeshed out) mesh-grid when indexed, so that each returned argument has the same shape. The dimensions and number of the output arrays are equal to the number of indexing dimensions. If the step length is not a complex number, then the stop is not inclusive. However, if the step length is a complex number (e.g. 5j), then the integer part of its magnitude is interpreted as specifying the number of points to create between the start and stop values, where the stop value is inclusive. Returns mesh-grid ndarrays all of the same dimensions 3.1. Array creation routines 477 NumPy Reference, Release 1.8.1 See Also: numpy.lib.index_tricks.nd_grid class of ogrid and mgrid objects ogrid like mgrid but returns open (not ﬂeshed out) mesh grids r_ array concatenator Examples >>> np.mgrid[0:5,0:5] array([[[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4]], [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]]) >>> np.mgrid[-1:1:5j] array([-1. , -0.5, 0. , 0.5, 1. ]) numpy.ogrid = nd_grid instance which returns an open multi-dimensional “meshgrid”. An instance of numpy.lib.index_tricks.nd_grid which returns an open (i.e. not ﬂeshed out) mesh- grid when indexed, so that only one dimension of each returned array is greater than 1. The dimension and number of the output arrays are equal to the number of indexing dimensions. If the step length is not a complex number, then the stop is not inclusive. However, if the step length is a complex number (e.g. 5j), then the integer part of its magnitude is interpreted as specifying the number of points to create between the start and stop values, where the stop value is inclusive. Returns mesh-grid ndarrays with only one dimension 6= 1 See Also: np.lib.index_tricks.nd_grid class of ogrid and mgrid objects mgrid like ogrid but returns dense (or ﬂeshed out) mesh grids r_ array concatenator Examples >>> from numpy import ogrid >>> ogrid[-1:1:5j] array([-1. , -0.5, 0. , 0.5, 1. ]) >>> ogrid[0:5,0:5] [array([[0], [1], 478 Chapter 3. Routines NumPy Reference, Release 1.8.1 [2], [3], [4]]), array([[0, 1, 2, 3, 4]])] 3.1.6 Building matrices diag(v[, k]) Extract a diagonal or construct a diagonal array. diagflat(v[, k]) Create a two-dimensional array with the ﬂattened input as a diagonal. tri(N[, M, k, dtype]) An array with ones at and below the given diagonal and zeros elsewhere. tril(m[, k]) Lower triangle of an array. triu(m[, k]) Upper triangle of an array. vander(x[, N]) Generate a Van der Monde matrix. numpy.diag(v, k=0) Extract a diagonal or construct a diagonal array. See the more detailed documentation for numpy.diagonal if you use this function to extract a diagonal and wish to write to the resulting array; whether it returns a copy or a view depends on what version of numpy you are using. Parameters v : array_like If v is a 2-D array, return a copy of its k-th diagonal. If v is a 1-D array, return a 2-D array with v on the k-th diagonal. k : int, optional Diagonal in question. The default is 0. Use k>0 for diagonals above the main diagonal, and k<0 for diagonals below the main diagonal. Returns out : ndarray The extracted diagonal or constructed diagonal array. See Also: diagonal Return speciﬁed diagonals. diagflat Create a 2-D array with the ﬂattened input as a diagonal. trace Sum along diagonals. triu Upper triangle of an array. tril Lower triange of an array. Examples 3.1. Array creation routines 479 NumPy Reference, Release 1.8.1 >>> x= np.arange(9).reshape((3,3)) >>> x array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) >>> np.diag(x) array([0, 4, 8]) >>> np.diag(x, k=1) array([1, 5]) >>> np.diag(x, k=-1) array([3, 7]) >>> np.diag(np.diag(x)) array([[0, 0, 0], [0, 4, 0], [0, 0, 8]]) numpy.diagflat(v, k=0) Create a two-dimensional array with the ﬂattened input as a diagonal. Parameters v : array_like Input data, which is ﬂattened and set as the k-th diagonal of the output. k : int, optional Diagonal to set; 0, the default, corresponds to the “main” diagonal, a positive (negative) k giving the number of the diagonal above (below) the main. Returns out : ndarray The 2-D output array. See Also: diag MATLAB work-alike for 1-D and 2-D arrays. diagonal Return speciﬁed diagonals. trace Sum along diagonals. Examples >>> np.diagflat([[1,2], [3,4]]) array([[1, 0, 0, 0], [0, 2, 0, 0], [0, 0, 3, 0], [0, 0, 0, 4]]) >>> np.diagflat([1,2],1) array([[0, 1, 0], [0, 0, 2], [0, 0, 0]]) 480 Chapter 3. Routines NumPy Reference, Release 1.8.1 numpy.tri(N, M=None, k=0, dtype=) An array with ones at and below the given diagonal and zeros elsewhere. Parameters N: int Number of rows in the array. M: int, optional Number of columns in the array. By default, M is taken equal to N. k : int, optional The sub-diagonal at and below which the array is ﬁlled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0. dtype : dtype, optional Data type of the returned array. The default is ﬂoat. Returns tri : ndarray of shape (N, M) Array with its lower triangle ﬁlled with ones and zero elsewhere; in other words T[i,j] == 1 for i <= j + k, 0 otherwise. Examples >>> np.tri(3,5,2, dtype=int) array([[1, 1, 1, 0, 0], [1, 1, 1, 1, 0], [1, 1, 1, 1, 1]]) >>> np.tri(3,5,-1) array([[ 0., 0., 0., 0., 0.], [ 1., 0., 0., 0., 0.], [ 1., 1., 0., 0., 0.]]) numpy.tril(m, k=0) Lower triangle of an array. Return a copy of an array with elements above the k-th diagonal zeroed. Parameters m : array_like, shape (M, N) Input array. k : int, optional Diagonal above which to zero elements. k = 0 (the default) is the main diagonal, k < 0 is below it and k > 0 is above. Returns tril : ndarray, shape (M, N) Lower triangle of m, of same shape and data-type as m. See Also: triu same thing, only for the upper triangle 3.1. Array creation routines 481 NumPy Reference, Release 1.8.1 Examples >>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]],-1) array([[ 0, 0, 0], [ 4, 0, 0], [ 7, 8, 0], [10, 11, 12]]) numpy.triu(m, k=0) Upper triangle of an array. Return a copy of a matrix with the elements below the k-th diagonal zeroed. Please refer to the documentation for tril for further details. See Also: tril lower triangle of an array Examples >>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]],-1) array([[ 1, 2, 3], [ 4, 5, 6], [ 0, 8, 9], [ 0, 0, 12]]) numpy.vander(x, N=None) Generate a Van der Monde matrix. The columns of the output matrix are decreasing powers of the input vector. Speciﬁcally, the i-th output column is the input vector raised element-wise to the power of N - i - 1. Such a matrix with a geometric progression in each row is named for Alexandre-Theophile Vandermonde. Parameters x : array_like 1-D input array. N: int, optional Order of (number of columns in) the output. If N is not speciﬁed, a square array is returned (N = len(x)). Returns out : ndarray Van der Monde matrix of order N. The ﬁrst column is x^(N-1), the second x^(N-2) and so forth. Examples >>> x= np.array([1,2,3,5]) >>> N=3 >>> np.vander(x, N) array([[ 1, 1, 1], [ 4, 2, 1], [ 9, 3, 1], [25, 5, 1]]) 482 Chapter 3. Routines NumPy Reference, Release 1.8.1 >>> np.column_stack([x**(N-1-i) for i in range(N)]) array([[ 1, 1, 1], [ 4, 2, 1], [ 9, 3, 1], [25, 5, 1]]) >>> x= np.array([1,2,3,5]) >>> np.vander(x) array([[ 1, 1, 1, 1], [ 8, 4, 2, 1], [ 27, 9, 3, 1], [125, 25, 5, 1]]) The determinant of a square Vandermonde matrix is the product of the differences between the values of the input vector: >>> np.linalg.det(np.vander(x)) 48.000000000000043 >>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1) 48 3.1.7 The Matrix class mat(data[, dtype]) Interpret the input as a matrix. bmat(obj[, ldict, gdict]) Build a matrix object from a string, nested sequence, or array. numpy.mat(data, dtype=None) Interpret the input as a matrix. Unlike matrix, asmatrix does not make a copy if the input is already a matrix or an ndarray. Equivalent to matrix(data, copy=False). Parameters data : array_like Input data. Returns mat : matrix data interpreted as a matrix. Examples >>> x= np.array([[1,2], [3,4]]) >>> m= np.asmatrix(x) >>> x[0,0]=5 >>> m matrix([[5, 2], [3, 4]]) numpy.bmat(obj, ldict=None, gdict=None) Build a matrix object from a string, nested sequence, or array. 3.1. Array creation routines 483 NumPy Reference, Release 1.8.1 Parameters obj : str or array_like Input data. Names of variables in the current scope may be referenced, even if obj is a string. Returns out : matrix Returns a matrix object, which is a specialized 2-D array. See Also: matrix Examples >>> A= np.mat(’1 1; 1 1’) >>> B= np.mat(’2 2; 2 2’) >>> C= np.mat(’3 4; 5 6’) >>> D= np.mat(’7 8; 9 0’) All the following expressions construct the same block matrix: >>> np.bmat([[A, B], [C, D]]) matrix([[1, 1, 2, 2], [1, 1, 2, 2], [3, 4, 7, 8], [5, 6, 9, 0]]) >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) matrix([[1, 1, 2, 2], [1, 1, 2, 2], [3, 4, 7, 8], [5, 6, 9, 0]]) >>> np.bmat(’A,B; C,D’) matrix([[1, 1, 2, 2], [1, 1, 2, 2], [3, 4, 7, 8], [5, 6, 9, 0]]) 3.2 Array manipulation routines 3.2.1 Basic operations copyto(dst, src[, casting, where, preservena]) Copies values from one array to another, broadcasting as necessary. numpy.copyto(dst, src, casting=’same_kind’, where=None, preservena=False) Copies values from one array to another, broadcasting as necessary. Raises a TypeError if the casting rule is violated, and if where is provided, it selects which elements to copy. New in version 1.7.0. Parameters dst : ndarray The array into which values are copied. 484 Chapter 3. Routines NumPy Reference, Release 1.8.1 src : array_like The array from which values are copied. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional Controls what kind of data casting may occur when copying. • ‘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 ﬂoat64 to ﬂoat32, are allowed. • ‘unsafe’ means any data conversions may be done. where : array_like of bool, optional A boolean array which is broadcasted to match the dimensions of dst, and selects ele- ments to copy from src to dst wherever it contains the value True. preservena : bool, optional If set to True, leaves any NA values in dst untouched. This is similar to the “hard mask” feature in numpy.ma. 3.2.2 Changing array shape reshape(a, newshape[, order]) Gives a new shape to an array without changing its data. ravel(a[, order]) Return a ﬂattened array. ndarray.flat A 1-D iterator over the array. ndarray.flatten([order]) Return a copy of the array collapsed into one dimension. numpy.reshape(a, newshape, order=’C’) Gives a new shape to an array without changing its data. Parameters a : array_like Array to be reshaped. newshape : int or tuple of ints The new shape should be compatible with the original shape. If an integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions. order : {‘C’, ‘F’, ‘A’}, optional Read the elements of a using this index order, and place the elements into the reshaped array using this index order. ‘C’ means to read / write the elements using C-like index order, with the last axis index changing fastest, back to the ﬁrst axis index changing slowest. ‘F’ means to read / write the elements using Fortran-like index order, with the ﬁrst 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 indexing. ‘A’ means to read / write the elements in Fortran-like index order if a is Fortran contiguous in memory, C-like order otherwise. 3.2. Array manipulation routines 485 NumPy Reference, Release 1.8.1 Returns reshaped_array : ndarray This will be a new view object if possible; otherwise, it will be a copy. Note there is no guarantee of the memory layout (C- or Fortran- contiguous) of the returned array. See Also: ndarray.reshape Equivalent method. Notes It is not always possible to change the shape of an array without copying the data. If you want an error to be raise if the data is copied, you should assign the new shape to the shape attribute of the array: >>> a= np.zeros((10,2)) # A transpose make the array non-contiguous >>> b=a.T # Taking a view makes it possible to modify the shape without modifying the # initial object. >>> c=b.view() >>> c.shape=(20) AttributeError: incompatible shape for a non-contiguous array The order keyword gives the index ordering both for fetching the values from a, and then placing the values into the output array. For example, let’s say you have an array: >>> a= np.arange(6).reshape((3,2)) >>> a array([[0, 1], [2, 3], [4, 5]]) You can think of reshaping as ﬁrst raveling the array (using the given index order), then inserting the elements from the raveled array into the new array using the same kind of index ordering as was used for the raveling. >>> np.reshape(a, (2,3)) # C-like index ordering array([[0, 1, 2], [3, 4, 5]]) >>> np.reshape(np.ravel(a), (2,3)) # equivalent to C ravel then C reshape array([[0, 1, 2], [3, 4, 5]]) >>> np.reshape(a, (2,3), order=’F’)# Fortran-like index ordering array([[0, 4, 3], [2, 1, 5]]) >>> np.reshape(np.ravel(a, order=’F’), (2,3), order=’F’) array([[0, 4, 3], [2, 1, 5]]) Examples >>> a= np.array([[1,2,3], [4,5,6]]) >>> np.reshape(a,6) array([1, 2, 3, 4, 5, 6]) >>> np.reshape(a,6, order=’F’) array([1, 4, 2, 5, 3, 6]) 486 Chapter 3. Routines NumPy Reference, Release 1.8.1 >>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2 array([[1, 2], [3, 4], [5, 6]]) numpy.ravel(a, order=’C’) Return a ﬂattened array. A 1-D array, containing the elements of the input, is returned. A copy is made only if needed. Parameters a : array_like Input array. The elements in a are read in the order speciﬁed by order, and packed as a 1-D array. 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 ﬁrst axis index changing slowest. ‘F’ means to index the elements in Fortran-like index order, with the ﬁrst 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 a 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. Returns 1d_array : ndarray Output of the same dtype as a, and of shape (a.size,). See Also: ndarray.flat 1-D iterator over an array. ndarray.flatten 1-D array copy of the elements of an array in row-major order. Notes In C-like (row-major) order, in two dimensions, the row index varies the slowest, and the column index the quickest. This can be generalized to multiple dimensions, where row-major order implies that the index along the ﬁrst axis varies slowest, and the index along the last quickest. The opposite holds for Fortran-like, or column-major, index ordering. Examples It is equivalent to reshape(-1, order=order). >>> x= np.array([[1,2,3], [4,5,6]]) >>> print np.ravel(x) [1 2 3 4 5 6] >>> print x.reshape(-1) [1 2 3 4 5 6] 3.2. Array manipulation routines 487 NumPy Reference, Release 1.8.1 >>> print np.ravel(x, order=’F’) [1 4 2 5 3 6] When order is ‘A’, it will preserve the array’s ‘C’ or ‘F’ ordering: >>> print np.ravel(x.T) [1 4 2 5 3 6] >>> print np.ravel(x.T, order=’A’) [1 2 3 4 5 6] When order is ‘K’, it will preserve orderings that are neither ‘C’ nor ‘F’, but won’t reverse axes: >>> a= np.arange(3)[::-1]; a array([2, 1, 0]) >>> a.ravel(order=’C’) array([2, 1, 0]) >>> a.ravel(order=’K’) array([2, 1, 0]) >>> a= np.arange(12).reshape(2,3,2).swapaxes(1,2); a array([[[ 0, 2, 4], [ 1, 3, 5]], [[ 6, 8, 10], [ 7, 9, 11]]]) >>> a.ravel(order=’C’) array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11]) >>> a.ravel(order=’K’) array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) ndarray.flat A 1-D iterator over the array. This is a numpy.flatiter instance, which acts similarly to, but is not a subclass of, Python’s built-in iterator object. See Also: flatten Return a copy of the array collapsed into one dimension. flatiter Examples >>> x= np.arange(1,7).reshape(2,3) >>> x array([[1, 2, 3], [4, 5, 6]]) >>> x.flat[3] 4 >>> x.T array([[1, 4], [2, 5], [3, 6]]) >>> x.T.flat[3] 5 >>> type(x.flat) 488 Chapter 3. Routines NumPy Reference, Release 1.8.1 An assignment example: >>> x.flat=3; x array([[3, 3, 3], [3, 3, 3]]) >>> x.flat[[1,4]]=1; x array([[3, 1, 3], [3, 1, 3]]) ndarray.flatten(order=’C’) Return a copy of the array collapsed into one dimension. Parameters order : {‘C’, ‘F’, ‘A’}, optional Whether to ﬂatten in C (row-major), Fortran (column-major) order, or preserve the C/Fortran ordering from a. The default is ‘C’. Returns y : ndarray A copy of the input array, ﬂattened to one dimension. See Also: ravel Return a ﬂattened array. flat A 1-D ﬂat iterator over the array. Examples >>> a= np.array([[1,2], [3,4]]) >>> a.flatten() array([1, 2, 3, 4]) >>> a.flatten(’F’) array([1, 3, 2, 4]) 3.2.3 Transpose-like operations rollaxis(a, axis[, start]) Roll the speciﬁed axis backwards, until it lies in a given position. swapaxes(a, axis1, axis2) Interchange two axes of an array. ndarray.T Same as self.transpose(), except that self is returned if self.ndim < 2. transpose(a[, axes]) Permute the dimensions of an array. numpy.rollaxis(a, axis, start=0) Roll the speciﬁed axis backwards, until it lies in a given position. Parameters a : ndarray Input array. axis : int The axis to roll backwards. The positions of the other axes do not change relative to one another. 3.2. Array manipulation routines 489 NumPy Reference, Release 1.8.1 start : int, optional The axis is rolled until it lies before this position. The default, 0, results in a “complete” roll. Returns res : ndarray Output array. See Also: roll Roll the elements of an array by a number of positions along a given axis. Examples >>> a= np.ones((3,4,5,6)) >>> np.rollaxis(a,3,1).shape (3, 6, 4, 5) >>> np.rollaxis(a,2).shape (5, 3, 4, 6) >>> np.rollaxis(a,1,4).shape (3, 5, 6, 4) numpy.swapaxes(a, axis1, axis2) Interchange two axes of an array. Parameters a : array_like Input array. axis1 : int First axis. axis2 : int Second axis. Returns a_swapped : ndarray If a is an ndarray, then a view of a is returned; otherwise a new array is created. Examples >>> x= np.array([[1,2,3]]) >>> np.swapaxes(x,0,1) array([[1], [2], [3]]) >>> x= np.array([[[0,1],[2,3]],[[4,5],[6,7]]]) >>> x array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]) 490 Chapter 3. Routines NumPy Reference, Release 1.8.1 >>> np.swapaxes(x,0,2) array([[[0, 4], [2, 6]], [[1, 5], [3, 7]]]) ndarray.T Same as self.transpose(), except that self is returned if self.ndim < 2. Examples >>> x= np.array([[1.,2.],[3.,4.]]) >>> x array([[ 1., 2.], [ 3., 4.]]) >>> x.T array([[ 1., 3.], [ 2., 4.]]) >>> x= np.array([1.,2.,3.,4.]) >>> x array([ 1., 2., 3., 4.]) >>> x.T array([ 1., 2., 3., 4.]) numpy.transpose(a, axes=None) Permute the dimensions of an array. Parameters a : array_like Input array. axes : list of ints, optional By default, reverse the dimensions, otherwise permute the axes according to the values given. Returns p : ndarray a with its axes permuted. A view is returned whenever possible. See Also: rollaxis Examples >>> x= np.arange(4).reshape((2,2)) >>> x array([[0, 1], [2, 3]]) >>> np.transpose(x) array([[0, 2], [1, 3]]) >>> x= np.ones((1,2,3)) >>> np.transpose(x, (1,0,2)).shape (2, 1, 3) 3.2. Array manipulation routines 491 NumPy Reference, Release 1.8.1 3.2.4 Changing number of dimensions atleast_1d(*arys) Convert inputs to arrays with at least one dimension. atleast_2d(*arys) View inputs as arrays with at least two dimensions. atleast_3d(*arys) View inputs as arrays with at least three dimensions. broadcast Produce an object that mimics broadcasting. broadcast_arrays(*args) Broadcast any number of arrays against each other. expand_dims(a, axis) Expand the shape of an array. squeeze(a[, axis]) Remove single-dimensional entries from the shape of an array. numpy.atleast_1d(*arys) Convert inputs to arrays with at least one dimension. Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved. Parameters arys1, arys2, ... : array_like One or more input arrays. Returns ret : ndarray An array, or sequence of arrays, each with a.ndim >= 1. Copies are made only if necessary. See Also: atleast_2d, atleast_3d Examples >>> np.atleast_1d(1.0) array([ 1.]) >>> x= np.arange(9.0).reshape(3,3) >>> np.atleast_1d(x) array([[ 0., 1., 2.], [ 3., 4., 5.], [ 6., 7., 8.]]) >>> np.atleast_1d(x) is x True >>> np.atleast_1d(1,[3,4]) [array([1]), array([3, 4])] numpy.atleast_2d(*arys) View inputs as arrays with at least two dimensions. Parameters arys1, arys2, ... : array_like One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have two or more dimensions are preserved. Returns res, res2, ... : ndarray An array, or tuple of arrays, each with a.ndim >= 2. Copies are avoided where possible, and views with two or more dimensions are returned. 492 Chapter 3. Routines NumPy Reference, Release 1.8.1 See Also: atleast_1d, atleast_3d Examples >>> np.atleast_2d(3.0) array([[ 3.]]) >>> x= np.arange(3.0) >>> np.atleast_2d(x) array([[ 0., 1., 2.]]) >>> np.atleast_2d(x).base is x True >>> np.atleast_2d(1,[1,2], [[1,2]]) [array([[1]]), array([[1, 2]]), array([[1, 2]])] numpy.atleast_3d(*arys) View inputs as arrays with at least three dimensions. Parameters arys1, arys2, ... : array_like One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have three or more dimensions are preserved. Returns res1, res2, ... : ndarray An array, or tuple of arrays, each with a.ndim >= 3. Copies are avoided where possible, and views with three or more dimensions are returned. For example, a 1-D array of shape (N,) becomes a view of shape (1, N, 1), and a 2-D array of shape (M, N) becomes a view of shape (M, N, 1). See Also: atleast_1d, atleast_2d Examples >>> np.atleast_3d(3.0) array([[[ 3.]]]) >>> x= np.arange(3.0) >>> np.atleast_3d(x).shape (1, 3, 1) >>> x= np.arange(12.0).reshape(4,3) >>> np.atleast_3d(x).shape (4, 3, 1) >>> np.atleast_3d(x).base is x True >>> for arr in np.atleast_3d([1,2], [[1,2]], [[[1,2]]]): ... print arr, arr.shape ... [[[1] [2]]] (1, 2, 1) [[[1] 3.2. Array manipulation routines 493 NumPy Reference, Release 1.8.1 [2]]] (1, 2, 1) [[[1 2]]] (1, 1, 2) class numpy.broadcast Produce an object that mimics broadcasting. Parameters in1, in2, ... : array_like Input parameters. Returns b : broadcast object Broadcast the input parameters against one another, and return an object that encapsu- lates the result. Amongst others, it has shape and nd properties, and may be used as an iterator. Examples Manually adding two vectors, using broadcasting: >>> x= np.array([[1], [2], [3]]) >>> y= np.array([4,5,6]) >>> b= np.broadcast(x, y) >>> out= np.empty(b.shape) >>> out.flat= [u+v for (u,v) in b] >>> out array([[ 5., 6., 7.], [ 6., 7., 8.], [ 7., 8., 9.]]) Compare against built-in broadcasting: >>> x+y array([[5, 6, 7], [6, 7, 8], [7, 8, 9]]) Attributes index current index in broadcasted result iters tuple of iterators along self‘s “components.” shape Shape of broadcasted result. size Total size of broadcasted result. broadcast.index current index in broadcasted result Examples >>> x= np.array([[1], [2], [3]]) >>> y= np.array([4,5,6]) >>> b= np.broadcast(x, y) >>> b.index 0 >>> b.next(), b.next(), b.next() 494 Chapter 3. Routines NumPy Reference, Release 1.8.1 ((1, 4), (1, 5), (1, 6)) >>> b.index 3 broadcast.iters tuple of iterators along self‘s “components.” Returns a tuple of numpy.flatiter objects, one for each “component” of self. See Also: numpy.flatiter Examples >>> x= np.array([1,2,3]) >>> y= np.array([[4], [5], [6]]) >>> b= np.broadcast(x, y) >>> row, col=b.iters >>> row.next(), col.next() (1, 4) broadcast.shape Shape of broadcasted result. Examples >>> x= np.array([1,2,3]) >>> y= np.array([[4], [5], [6]]) >>> b= np.broadcast(x, y) >>> b.shape (3, 3) broadcast.size Total size of broadcasted result. Examples >>> x= np.array([1,2,3]) >>> y= np.array([[4], [5], [6]]) >>> b= np.broadcast(x, y) >>> b.size 9 Methods next x.next() -> the next value, or raise StopIteration reset() Reset the broadcasted result’s iterator(s). broadcast.next x.next() -> the next value, or raise StopIteration broadcast.reset() Reset the broadcasted result’s iterator(s). Parameters None Returns 3.2. Array manipulation routines 495 NumPy Reference, Release 1.8.1 None Examples >>> x= np.array([1,2,3]) >>> y= np.array([[4], [5], [6]] >>> b= np.broadcast(x, y) >>> b.index 0 >>> b.next(), b.next(), b.next() ((1, 4), (2, 4), (3, 4)) >>> b.index 3 >>> b.reset() >>> b.index 0 numpy.broadcast_arrays(*args) Broadcast any number of arrays against each other. Parameters ‘*args‘ : array_likes The arrays to broadcast. Returns broadcasted : list of arrays These arrays are views on the original arrays. They are typically not contiguous. Fur- thermore, more than one element of a broadcasted array may refer to a single memory location. If you need to write to the arrays, make copies ﬁrst. Examples >>> x= np.array([[1,2,3]]) >>> y= np.array([[1],[2],[3]]) >>> np.broadcast_arrays(x, y) [array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]), array([[1, 1, 1], [2, 2, 2], [3, 3, 3]])] Here is a useful idiom for getting contiguous copies instead of non-contiguous views. >>> [np.array(a) for a in np.broadcast_arrays(x, y)] [array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]), array([[1, 1, 1], [2, 2, 2], [3, 3, 3]])] numpy.expand_dims(a, axis) Expand the shape of an array. Insert a new axis, corresponding to a given position in the array shape. Parameters a : array_like Input array. 496 Chapter 3. Routines NumPy Reference, Release 1.8.1 axis : int Position (amongst axes) where new axis is to be inserted. Returns res : ndarray Output array. The number of dimensions is one greater than that of the input array. See Also: doc.indexing, atleast_1d, atleast_2d, atleast_3d Examples >>> x= np.array([1,2]) >>> x.shape (2,) The following is equivalent to x[np.newaxis,:] or x[np.newaxis]: >>> y= np.expand_dims(x, axis=0) >>> y array([[1, 2]]) >>> y.shape (1, 2) >>> y= np.expand_dims(x, axis=1)# Equivalent to x[:,newaxis] >>> y array([[1], [2]]) >>> y.shape (2, 1) Note that some examples may use None instead of np.newaxis. These are the same objects: >>> np.newaxis is None True numpy.squeeze(a, axis=None) Remove single-dimensional entries from the shape of an array. Parameters a : array_like Input data. axis : None or int or tuple of ints, optional New in version 1.7.0. Selects a subset of the single-dimensional entries in the shape. If an axis is selected with shape entry greater than one, an error is raised. Returns squeezed : ndarray The input array, but with with all or a subset of the dimensions of length 1 removed. This is always a itself or a view into a. Examples >>> x= np.array([[[0], [1], [2]]]) >>> x.shape (1, 3, 1) 3.2. Array manipulation routines 497 NumPy Reference, Release 1.8.1 >>> np.squeeze(x).shape (3,) >>> np.squeeze(x, axis=(2,)).shape (1, 3) 3.2.5 Changing kind of array asarray(a[, dtype, order]) Convert the input to an array. asanyarray(a[, dtype, order]) Convert the input to an ndarray, but pass ndarray subclasses through. asmatrix(data[, dtype]) Interpret the input as a matrix. asfarray(a[, dtype]) Return an array converted to a ﬂoat type. asfortranarray(a[, dtype]) Return an array laid out in Fortran order in memory. asscalar(a) Convert an array of size 1 to its scalar equivalent. require(a[, dtype, requirements]) Return an ndarray of the provided type that satisﬁes requirements. numpy.asarray(a, dtype=None, order=None) Convert the input to an array. Parameters a : array_like Input data, in any form that can be converted to an array. This includes lists, lists of tuples, tuples, tuples of tuples, tuples of lists and ndarrays. dtype : data-type, optional By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional Whether to use row-major (‘C’) or column-major (‘F’ for FORTRAN) memory repre- sentation. Defaults to ‘C’. Returns out : ndarray Array interpretation of a. No copy is performed if the input is already an ndarray. If a is a subclass of ndarray, a base class ndarray is returned. See Also: asanyarray Similar function which passes through subclasses. ascontiguousarray Convert input to a contiguous array. asfarray Convert input to a ﬂoating point ndarray. asfortranarray Convert input to an ndarray with column-major memory order. asarray_chkfinite Similar function which checks input for NaNs and Infs. fromiter Create an array from an iterator. 498 Chapter 3. Routines NumPy Reference, Release 1.8.1 fromfunction Construct an array by executing a function on grid positions. Examples Convert a list into an array: >>> a=[1,2] >>> np.asarray(a) array([1, 2]) Existing arrays are not copied: >>> a= np.array([1,2]) >>> np.asarray(a) is a True If dtype is set, array is copied only if dtype does not match: >>> a= np.array([1,2], dtype=np.float32) >>> np.asarray(a, dtype=np.float32) is a True >>> np.asarray(a, dtype=np.float64) is a False Contrary to asanyarray, ndarray subclasses are not passed through: >>> issubclass(np.matrix, np.ndarray) True >>> a= np.matrix([[1,2]]) >>> np.asarray(a) is a False >>> np.asanyarray(a) is a True numpy.asanyarray(a, dtype=None, order=None) Convert the input to an ndarray, but pass ndarray subclasses through. Parameters a : array_like Input data, in any form that can be converted to an array. This includes scalars, lists, lists of tuples, tuples, tuples of tuples, tuples of lists, and ndarrays. dtype : data-type, optional By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional Whether to use row-major (‘C’) or column-major (‘F’) memory representation. Defaults to ‘C’. Returns out : ndarray or an ndarray subclass Array interpretation of a. If a is an ndarray or a subclass of ndarray, it is returned as-is and no copy is performed. See Also: asarray Similar function which always returns ndarrays. 3.2. Array manipulation routines 499 NumPy Reference, Release 1.8.1 ascontiguousarray Convert input to a contiguous array. asfarray Convert input to a ﬂoating point ndarray. asfortranarray Convert input to an ndarray with column-major memory order. asarray_chkfinite Similar function which checks input for NaNs and Infs. fromiter Create an array from an iterator. fromfunction Construct an array by executing a function on grid positions. Examples Convert a list into an array: >>> a=[1,2] >>> np.asanyarray(a) array([1, 2]) Instances of ndarray subclasses are passed through as-is: >>> a= np.matrix([1,2]) >>> np.asanyarray(a) is a True numpy.asmatrix(data, dtype=None) Interpret the input as a matrix. Unlike matrix, asmatrix does not make a copy if the input is already a matrix or an ndarray. Equivalent to matrix(data, copy=False). Parameters data : array_like Input data. Returns mat : matrix data interpreted as a matrix. Examples >>> x= np.array([[1,2], [3,4]]) >>> m= np.asmatrix(x) >>> x[0,0]=5 >>> m matrix([[5, 2], [3, 4]]) numpy.asfarray(a, dtype=) Return an array converted to a ﬂoat type. 500 Chapter 3. Routines NumPy Reference, Release 1.8.1 Parameters a : array_like The input array. dtype : str or dtype object, optional Float type code to coerce input array a. If dtype is one of the ‘int’ dtypes, it is replaced with ﬂoat64. Returns out : ndarray The input a as a ﬂoat ndarray. Examples >>> np.asfarray([2,3]) array([ 2., 3.]) >>> np.asfarray([2,3], dtype=’float’) array([ 2., 3.]) >>> np.asfarray([2,3], dtype=’int8’) array([ 2., 3.]) numpy.asfortranarray(a, dtype=None) Return an array laid out in Fortran order in memory. Parameters a : array_like Input array. dtype : str or dtype object, optional By default, the data-type is inferred from the input data. Returns out : ndarray The input a in Fortran, or column-major, order. See Also: ascontiguousarray Convert input to a contiguous (C order) array. asanyarray Convert input to an ndarray with either row or column-major memory order. require Return an ndarray that satisﬁes requirements. ndarray.flags Information about the memory layout of the array. Examples >>> x= np.arange(6).reshape(2,3) >>> y= np.asfortranarray(x) >>> x.flags[’F_CONTIGUOUS’] False >>> y.flags[’F_CONTIGUOUS’] True 3.2. Array manipulation routines 501 NumPy Reference, Release 1.8.1 numpy.asscalar(a) Convert an array of size 1 to its scalar equivalent. Parameters a : ndarray Input array of size 1. Returns out : scalar Scalar representation of a. The output data type is the same type returned by the input’s item method. Examples >>> np.asscalar(np.array([24])) 24 numpy.require(a, dtype=None, requirements=None) Return an ndarray of the provided type that satisﬁes requirements. This function is useful to be sure that an array with the correct ﬂags is returned for passing to compiled code (perhaps through ctypes). Parameters a : array_like The object to be converted to a type-and-requirement-satisfying array. dtype : data-type The required data-type, the default data-type is ﬂoat64). requirements : str or list of str The requirements list can be any of the following • ‘F_CONTIGUOUS’ (‘F’) - ensure a Fortran-contiguous array • ‘C_CONTIGUOUS’ (‘C’) - ensure a C-contiguous array • ‘ALIGNED’ (‘A’) - ensure a data-type aligned array • ‘WRITEABLE’ (‘W’) - ensure a writable array • ‘OWNDATA’ (‘O’) - ensure an array that owns its own data See Also: asarray Convert input to an ndarray. asanyarray Convert to an ndarray, but pass through ndarray subclasses. ascontiguousarray Convert input to a contiguous array. asfortranarray Convert input to an ndarray with column-major memory order. ndarray.flags Information about the memory layout of the array. 502 Chapter 3. Routines NumPy Reference, Release 1.8.1 Notes The returned array will be guaranteed to have the listed requirements by making a copy if needed. Examples >>> x= np.arange(6).reshape(2,3) >>> x.flags C_CONTIGUOUS : True F_CONTIGUOUS : False OWNDATA : False WRITEABLE : True ALIGNED : True UPDATEIFCOPY : False >>> y= np.require(x, dtype=np.float32, requirements=[’A’,’O’,’W’,’F’]) >>> y.flags C_CONTIGUOUS : False F_CONTIGUOUS : True OWNDATA : True WRITEABLE : True ALIGNED : True UPDATEIFCOPY : False 3.2.6 Joining arrays column_stack(tup) Stack 1-D arrays as columns into a 2-D array. concatenate((a1, a2, ...)[, axis]) Join a sequence of arrays together. dstack(tup) Stack arrays in sequence depth wise (along third axis). hstack(tup) Stack arrays in sequence horizontally (column wise). vstack(tup) Stack arrays in sequence vertically (row wise). numpy.column_stack(tup) Stack 1-D arrays as columns into a 2-D array. Take a sequence of 1-D arrays and stack them as columns to make a single 2-D array. 2-D arrays are stacked as-is, just like with hstack. 1-D arrays are turned into 2-D columns ﬁrst. Parameters tup : sequence of 1-D or 2-D arrays. Arrays to stack. All of them must have the same ﬁrst dimension. Returns stacked : 2-D array The array formed by stacking the given arrays. See Also: hstack, vstack, concatenate Notes This function is equivalent to np.vstack(tup).T. 3.2. Array manipulation routines 503 NumPy Reference, Release 1.8.1 Examples >>> a= np.array((1,2,3)) >>> b= np.array((2,3,4)) >>> np.column_stack((a,b)) array([[1, 2], [2, 3], [3, 4]]) numpy.concatenate((a1, a2,...), axis=0) Join a sequence of arrays together. Parameters a1, a2, ... : sequence of array_like The arrays must have the same shape, except in the dimension corresponding to axis (the ﬁrst, by default). axis : int, optional The axis along which the arrays will be joined. Default is 0. Returns res : ndarray The concatenated array. See Also: ma.concatenate Concatenate function that preserves input masks. array_split Split an array into multiple sub-arrays of equal or near-equal size. split Split array into a list of multiple sub-arrays of equal size. hsplit Split array into multiple sub-arrays horizontally (column wise) vsplit Split array into multiple sub-arrays vertically (row wise) dsplit Split array into multiple sub-arrays along the 3rd axis (depth). hstack Stack arrays in sequence horizontally (column wise) vstack Stack arrays in sequence vertically (row wise) dstack Stack arrays in sequence depth wise (along third dimension) Notes When one or more of the arrays to be concatenated is a MaskedArray, this function will return a MaskedArray object instead of an ndarray, but the input masks are not preserved. In cases where a MaskedArray is expected as input, use the ma.concatenate function from the masked array module instead. 504 Chapter 3. Routines NumPy Reference, Release 1.8.1 Examples >>> a= np.array([[1,2], [3,4]]) >>> b= np.array([[5,6]]) >>> np.concatenate((a, b), axis=0) array([[1, 2], [3, 4], [5, 6]]) >>> np.concatenate((a, b.T), axis=1) array([[1, 2, 5], [3, 4, 6]]) This function will not preserve masking of MaskedArray inputs. >>> a= np.ma.arange(3) >>> a[1]= np.ma.masked >>> b= np.arange(2,5) >>> a masked_array(data = [0 -- 2], mask = [False True False], fill_value = 999999) >>> b array([2, 3, 4]) >>> np.concatenate([a, b]) masked_array(data = [0 1 2 2 3 4], mask = False, fill_value = 999999) >>> np.ma.concatenate([a, b]) masked_array(data = [0 -- 2 2 3 4], mask = [False True False False False False], fill_value = 999999) numpy.dstack(tup) Stack arrays in sequence depth wise (along third axis). Takes a sequence of arrays and stack them along the third axis to make a single array. Rebuilds arrays divided by dsplit. This is a simple way to stack 2D arrays (images) into a single 3D array for processing. Parameters tup : sequence of arrays Arrays to stack. All of them must have the same shape along all but the third axis. Returns stacked : ndarray The array formed by stacking the given arrays. See Also: vstack Stack along ﬁrst axis. hstack Stack along second axis. concatenate Join arrays. dsplit Split array along third axis. 3.2. Array manipulation routines 505 NumPy Reference, Release 1.8.1 Notes Equivalent to np.concatenate(tup, axis=2). Examples >>> a= np.array((1,2,3)) >>> b= np.array((2,3,4)) >>> np.dstack((a,b)) array([[[1, 2], [2, 3], [3, 4]]]) >>> a= np.array([[1],[2],[3]]) >>> b= np.array([[2],[3],[4]]) >>> np.dstack((a,b)) array([[[1, 2]], [[2, 3]], [[3, 4]]]) numpy.hstack(tup) Stack arrays in sequence horizontally (column wise). Take a sequence of arrays and stack them horizontally to make a single array. Rebuild arrays divided by hsplit. Parameters tup : sequence of ndarrays All arrays must have the same shape along all but the second axis. Returns stacked : ndarray The array formed by stacking the given arrays. See Also: vstack Stack arrays in sequence vertically (row wise). dstack Stack arrays in sequence depth wise (along third axis). concatenate Join a sequence of arrays together. hsplit Split array along second axis. Notes Equivalent to np.concatenate(tup, axis=1) Examples >>> a= np.array((1,2,3)) >>> b= np.array((2,3,4)) >>> np.hstack((a,b)) array([1, 2, 3, 2, 3, 4]) >>> a= np.array([[1],[2],[3]]) >>> b= np.array([[2],[3],[4]]) 506 Chapter 3. Routines NumPy Reference, Release 1.8.1 >>> np.hstack((a,b)) array([[1, 2], [2, 3], [3, 4]]) numpy.vstack(tup) Stack arrays in sequence vertically (row wise). Take a sequence of arrays and stack them vertically to make a single array. Rebuild arrays divided by vsplit. Parameters tup : sequence of ndarrays Tuple containing arrays to be stacked. The arrays must have the same shape along all but the ﬁrst axis. Returns stacked : ndarray The array formed by stacking the given arrays. See Also: hstack Stack arrays in sequence horizontally (column wise). dstack Stack arrays in sequence depth wise (along third dimension). concatenate Join a sequence of arrays together. vsplit Split array into a list of multiple sub-arrays vertically. Notes Equivalent to np.concatenate(tup, axis=0) if tup contains arrays that are at least 2-dimensional. Examples >>> a= np.array([1,2,3]) >>> b= np.array([2,3,4]) >>> np.vstack((a,b)) array([[1, 2, 3], [2, 3, 4]]) >>> a= np.array([[1], [2], [3]]) >>> b= np.array([[2], [3], [4]]) >>> np.vstack((a,b)) array([[1], [2], [3], [2], [3], [4]]) 3.2.7 Splitting arrays 3.2. Array manipulation routines 507 NumPy Reference, Release 1.8.1 array_split(ary, indices_or_sections[, axis]) Split an array into multiple sub-arrays. dsplit(ary, indices_or_sections) Split array into multiple sub-arrays along the 3rd axis (depth). hsplit(ary, indices_or_sections) Split an array into multiple sub-arrays horizontally (column-wise). split(ary, indices_or_sections[, axis]) Split an array into multiple sub-arrays. vsplit(ary, indices_or_sections) Split an array into multiple sub-arrays vertically (row-wise). numpy.array_split(ary, indices_or_sections, axis=0) Split an array into multiple sub-arrays. Please refer to the split documentation. The only difference between these functions is that array_split allows indices_or_sections to be an integer that does not equally divide the axis. See Also: split Split array into multiple sub-arrays of equal size. Examples >>> x= np.arange(8.0) >>> np.array_split(x,3) [array([ 0., 1., 2.]), array([ 3., 4., 5.]), array([ 6., 7.])] numpy.dsplit(ary, indices_or_sections) Split array into multiple sub-arrays along the 3rd axis (depth). Please refer to the split documentation. dsplit is equivalent to split with axis=2, the array is always split along the third axis provided the array dimension is greater than or equal to 3. See Also: split Split an array into multiple sub-arrays of equal size. Examples >>> x= np.arange(16.0).reshape(2,2,4) >>> x array([[[ 0., 1., 2., 3.], [ 4., 5., 6., 7.]], [[ 8., 9., 10., 11.], [ 12., 13., 14., 15.]]]) >>> np.dsplit(x,2) [array([[[ 0., 1.], [ 4., 5.]], [[ 8., 9.], [ 12., 13.]]]), array([[[ 2., 3.], [ 6., 7.]], [[ 10., 11.], [ 14., 15.]]])] >>> np.dsplit(x, np.array([3,6])) [array([[[ 0., 1., 2.], [ 4., 5., 6.]], [[ 8., 9., 10.], [ 12., 13., 14.]]]), array([[[ 3.], 508 Chapter 3. Routines NumPy Reference, Release 1.8.1 [ 7.]], [[ 11.], [ 15.]]]), array([], dtype=float64)] numpy.hsplit(ary, indices_or_sections) Split an array into multiple sub-arrays horizontally (column-wise). Please refer to the split documentation. hsplit is equivalent to split with axis=1, the array is always split along the second axis regardless of the array dimension. See Also: split Split an array into multiple sub-arrays of equal size. Examples >>> x= np.arange(16.0).reshape(4,4) >>> x array([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.], [ 12., 13., 14., 15.]]) >>> np.hsplit(x,2) [array([[ 0., 1.], [ 4., 5.], [ 8., 9.], [ 12., 13.]]), array([[ 2., 3.], [ 6., 7.], [ 10., 11.], [ 14., 15.]])] >>> np.hsplit(x, np.array([3,6])) [array([[ 0., 1., 2.], [ 4., 5., 6.], [ 8., 9., 10.], [ 12., 13., 14.]]), array([[ 3.], [ 7.], [ 11.], [ 15.]]), array([], dtype=float64)] With a higher dimensional array the split is still along the second axis. >>> x= np.arange(8.0).reshape(2,2,2) >>> x array([[[ 0., 1.], [ 2., 3.]], [[ 4., 5.], [ 6., 7.]]]) >>> np.hsplit(x,2) [array([[[ 0., 1.]], [[ 4., 5.]]]), array([[[ 2., 3.]], [[ 6., 7.]]])] 3.2. Array manipulation routines 509 NumPy Reference, Release 1.8.1 numpy.split(ary, indices_or_sections, axis=0) Split an array into multiple sub-arrays. Parameters ary : ndarray Array to be divided into sub-arrays. indices_or_sections : int or 1-D array If indices_or_sections is an integer, N, the array will be divided into N equal arrays along axis. If such a split is not possible, an error is raised. If indices_or_sections is a 1-D array of sorted integers, the entries indicate where along axis the array is split. For example, [2, 3] would, for axis=0, result in • ary[:2] • ary[2:3] • ary[3:] If an index exceeds the dimension of the array along axis, an empty sub-array is returned correspondingly. axis : int, optional The axis along which to split, default is 0. Returns sub-arrays : list of ndarrays A list of sub-arrays. Raises ValueError If indices_or_sections is given as an integer, but a split does not result in equal division. See Also: array_split Split an array into multiple sub-arrays of equal or near-equal size. Does not raise an exception if an equal division cannot be made. hsplit Split array into multiple sub-arrays horizontally (column-wise). vsplit Split array into multiple sub-arrays vertically (row wise). dsplit Split array into multiple sub-arrays along the 3rd axis (depth). concatenate Join arrays together. hstack Stack arrays in sequence horizontally (column wise). vstack Stack arrays in sequence vertically (row wise). dstack Stack arrays in sequence depth wise (along third dimension). 510 Chapter 3. Routines NumPy Reference, Release 1.8.1 Examples >>> x= np.arange(9.0) >>> np.split(x,3) [array([ 0., 1., 2.]), array([ 3., 4., 5.]), array([ 6., 7., 8.])] >>> x= np.arange(8.0) >>> np.split(x, [3,5,6, 10]) [array([ 0., 1., 2.]), array([ 3., 4.]), array([ 5.]), array([ 6., 7.]), array([], dtype=float64)] numpy.vsplit(ary, indices_or_sections) Split an array into multiple sub-arrays vertically (row-wise). Please refer to the split documentation. vsplit is equivalent to split with axis=0 (default), the array is always split along the ﬁrst axis regardless of the array dimension. See Also: split Split an array into multiple sub-arrays of equal size. Examples >>> x= np.arange(16.0).reshape(4,4) >>> x array([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.], [ 12., 13., 14., 15.]]) >>> np.vsplit(x,2) [array([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.]]), array([[ 8., 9., 10., 11.], [ 12., 13., 14., 15.]])] >>> np.vsplit(x, np.array([3,6])) [array([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]]), array([[ 12., 13., 14., 15.]]), array([], dtype=float64)] With a higher dimensional array the split is still along the ﬁrst axis. >>> x= np.arange(8.0).reshape(2,2,2) >>> x array([[[ 0., 1.], [ 2., 3.]], [[ 4., 5.], [ 6., 7.]]]) >>> np.vsplit(x,2) [array([[[ 0., 1.], [ 2., 3.]]]), array([[[ 4., 5.], [ 6., 7.]]])] 3.2. Array manipulation routines 511 NumPy Reference, Release 1.8.1 3.2.8 Tiling arrays tile(A, reps) Construct an array by repeating A the number of times given by reps. repeat(a, repeats[, axis]) Repeat elements of an array. numpy.tile(A, reps) Construct an array by repeating A the number of times given by reps. If reps has length d, the result will have dimension of max(d, A.ndim). If A.ndim < d,A is promoted to be d-dimensional by prepending new axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication, or shape (1, 1, 3) for 3-D replication. If this is not the desired behavior, promote A to d-dimensions manually before calling this function. If A.ndim > d, reps is promoted to A.ndim by pre-pending 1’s to it. Thus for an A of shape (2, 3, 4, 5), a reps of (2, 2) is treated as (1, 1, 2, 2). Parameters A: array_like The input array. reps : array_like The number of repetitions of A along each axis. Returns c : ndarray The tiled output array. See Also: repeat Repeat elements of an array. Examples >>> a= np.array([0,1,2]) >>> np.tile(a,2) array([0, 1, 2, 0, 1, 2]) >>> np.tile(a, (2,2)) array([[0, 1, 2, 0, 1, 2], [0, 1, 2, 0, 1, 2]]) >>> np.tile(a, (2,1,2)) array([[[0, 1, 2, 0, 1, 2]], [[0, 1, 2, 0, 1, 2]]]) >>> b= np.array([[1,2], [3,4]]) >>> np.tile(b,2) array([[1, 2, 1, 2], [3, 4, 3, 4]]) >>> np.tile(b, (2,1)) array([[1, 2], [3, 4], [1, 2], [3, 4]]) numpy.repeat(a, repeats, axis=None) Repeat elements of an array. 512 Chapter 3. Routines NumPy Reference, Release 1.8.1 Parameters a : array_like Input array. repeats : {int, array of ints} The number of repetitions for each element. repeats is broadcasted to ﬁt the shape of the given axis. axis : int, optional The axis along which to repeat values. By default, use the ﬂattened input array, and return a ﬂat output array. Returns repeated_array : ndarray Output array which has the same shape as a, except along the given axis. See Also: tile Tile an array. Examples >>> x= np.array([[1,2],[3,4]]) >>> np.repeat(x,2) array([1, 1, 2, 2, 3, 3, 4, 4]) >>> np.repeat(x,3, axis=1) array([[1, 1, 1, 2, 2, 2], [3, 3, 3, 4, 4, 4]]) >>> np.repeat(x, [1,2], axis=0) array([[1, 2], [3, 4], [3, 4]]) 3.2.9 Adding and removing elements delete(arr, obj[, axis]) Return a new array with sub-arrays along an axis deleted. insert(arr, obj, values[, axis]) Insert values along the given axis before the given indices. append(arr, values[, axis]) Append values to the end of an array. resize(a, new_shape) Return a new array with the speciﬁed shape. trim_zeros(ﬁlt[, trim]) Trim the leading and/or trailing zeros from a 1-D array or sequence. unique(ar[, return_index, return_inverse]) Find the unique elements of an array. numpy.delete(arr, obj, axis=None) Return a new array with sub-arrays along an axis deleted. For a one dimensional array, this returns those entries not returned by arr[obj]. Parameters arr : array_like Input array. obj : slice, int or array of ints 3.2. Array manipulation routines 513 NumPy Reference, Release 1.8.1 Indicate which sub-arrays to remove. axis : int, optional The axis along which to delete the subarray deﬁned by obj. If axis is None, obj is applied to the ﬂattened array. Returns out : ndarray A copy of arr with the elements speciﬁed by obj removed. Note that delete does not occur in-place. If axis is None, out is a ﬂattened array. See Also: insert Insert elements into an array. append Append elements at the end of an array. Notes Often it is preferable to use a boolean mask. For example: >>> mask= np.ones(len(arr), dtype=bool) >>> mask[[0,2,4]]= False >>> result= arr[mask,...] Is equivalent to np.delete(arr, [0,2,4], axis=0), but allows further use of mask. Examples >>> arr= np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) >>> arr array([[ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12]]) >>> np.delete(arr,1,0) array([[ 1, 2, 3, 4], [ 9, 10, 11, 12]]) >>> np.delete(arr, np.s_[::2],1) array([[ 2, 4], [ 6, 8], [10, 12]]) >>> np.delete(arr, [1,3,5], None) array([ 1, 3, 5, 7, 8, 9, 10, 11, 12]) numpy.insert(arr, obj, values, axis=None) Insert values along the given axis before the given indices. Parameters arr : array_like Input array. obj : int, slice or sequence of ints Object that deﬁnes the index or indices before which values is inserted. New in version 1.8.0. Support for multiple insertions when obj is a single scalar or a sequence with one element (similar to calling insert multiple times). 514 Chapter 3. Routines NumPy Reference, Release 1.8.1 values : array_like Values to insert into arr. If the type of values is different from that of arr, values is converted to the type of arr. values should be shaped so that arr[...,obj,...] = values is legal. axis : int, optional Axis along which to insert values. If axis is None then arr is ﬂattened ﬁrst. Returns out : ndarray A copy of arr with values inserted. Note that insert does not occur in-place: a new array is returned. If axis is None, out is a ﬂattened array. See Also: append Append elements at the end of an array. concatenate Join a sequence of arrays together. delete Delete elements from an array. Notes Note that for higher dimensional inserts obj=0 behaves very different from obj=[0] just like arr[:,0,:] = values is different from arr[:,[0],:] = values. Examples >>> a= np.array([[1,1], [2,2], [3,3]]) >>> a array([[1, 1], [2, 2], [3, 3]]) >>> np.insert(a,1,5) array([1, 5, 1, 2, 2, 3, 3]) >>> np.insert(a,1,5, axis=1) array([[1, 5, 1], [2, 5, 2], [3, 5, 3]]) Difference between sequence and scalars: >>> np.insert(a, [1], [[1],[2],[3]], axis=1) array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) >>> np.array_equal(np.insert(a,1,[1,2,3], axis=1), ... np.insert(a, [1], [[1],[2],[3]], axis=1)) True >>> b=a.flatten() >>> b array([1, 1, 2, 2, 3, 3]) >>> np.insert(b, [2,2], [5,6]) array([1, 1, 5, 6, 2, 2, 3, 3]) 3.2. Array manipulation routines 515 NumPy Reference, Release 1.8.1 >>> np.insert(b, slice(2,4), [5,6]) array([1, 1, 5, 2, 6, 2, 3, 3]) >>> np.insert(b, [2,2], [7.13, False]) # type casting array([1, 1, 7, 0, 2, 2, 3, 3]) >>> x= np.arange(8).reshape(2,4) >>> idx=(1,3) >>> np.insert(x, idx, 999, axis=1) array([[ 0, 999, 1, 2, 999, 3], [ 4, 999, 5, 6, 999, 7]]) numpy.append(arr, values, axis=None) Append values to the end of an array. Parameters arr : array_like Values are appended to a copy of this array. values : array_like These values are appended to a copy of arr. It must be of the correct shape (the same shape as arr, excluding axis). If axis is not speciﬁed, values can be any shape and will be ﬂattened before use. axis : int, optional The axis along which values are appended. If axis is not given, both arr and values are ﬂattened before use. Returns append : ndarray A copy of arr with values appended to axis. Note that append does not occur in-place: a new array is allocated and ﬁlled. If axis is None, out is a ﬂattened array. See Also: insert Insert elements into an array. delete Delete elements from an array. Examples >>> np.append([1,2,3], [[4,5,6], [7,8,9]]) array([1, 2, 3, 4, 5, 6, 7, 8, 9]) When axis is speciﬁed, values must have the correct shape. >>> np.append([[1,2,3], [4,5,6]], [[7,8,9]], axis=0) array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> np.append([[1,2,3], [4,5,6]], [7,8,9], axis=0) Traceback (most recent call last): ... ValueError: arrays must have same number of dimensions 516 Chapter 3. Routines NumPy Reference, Release 1.8.1 numpy.resize(a, new_shape) Return a new array with the speciﬁed shape. If the new array is larger than the original array, then the new array is ﬁlled with repeated copies of a. Note that this behavior is different from a.resize(new_shape) which ﬁlls with zeros instead of repeated copies of a. Parameters a : array_like Array to be resized. new_shape : int or tuple of int Shape of resized array. Returns reshaped_array : ndarray The new array is formed from the data in the old array, repeated if necessary to ﬁll out the required number of elements. The data are repeated in the order that they are stored in memory. See Also: ndarray.resize resize an array in-place. Examples >>> a=np.array([[0,1],[2,3]]) >>> np.resize(a,(1,4)) array([[0, 1, 2, 3]]) >>> np.resize(a,(2,4)) array([[0, 1, 2, 3], [0, 1, 2, 3]]) numpy.trim_zeros(ﬁlt, trim=’fb’) Trim the leading and/or trailing zeros from a 1-D array or sequence. Parameters ﬁlt : 1-D array or sequence Input array. trim : str, optional A string with ‘f’ representing trim from front and ‘b’ to trim from back. Default is ‘fb’, trim zeros from both front and back of the array. Returns trimmed : 1-D array or sequence The result of trimming the input. The input data type is preserved. Examples >>> a= np.array((0,0,0,1,2,3,0,2,1,0)) >>> np.trim_zeros(a) array([1, 2, 3, 0, 2, 1]) >>> np.trim_zeros(a,’b’) array([0, 0, 0, 1, 2, 3, 0, 2, 1]) 3.2. Array manipulation routines 517 NumPy Reference, Release 1.8.1 The input data type is preserved, list/tuple in means list/tuple out. >>> np.trim_zeros([0,1,2,0]) [1, 2] numpy.unique(ar, return_index=False, return_inverse=False) Find the unique elements of an array. Returns the sorted unique elements of an array. There are two optional outputs in addition to the unique elements: the indices of the input array that give the unique values, and the indices of the unique array that reconstruct the input array. Parameters ar : array_like Input array. This will be ﬂattened if it is not already 1-D. return_index : bool, optional If True, also return the indices of ar that result in the unique array. return_inverse : bool, optional If True, also return the indices of the unique array that can be used to reconstruct ar. Returns unique : ndarray The sorted unique values. unique_indices : ndarray, optional The indices of the ﬁrst occurrences of the unique values in the (ﬂattened) original array. Only provided if return_index is True. unique_inverse : ndarray, optional The indices to reconstruct the (ﬂattened) original array from the unique array. Only provided if return_inverse is True. See Also: numpy.lib.arraysetops Module with a number of other functions for performing set operations on arrays. Examples >>> np.unique([1,1,2,2,3,3]) array([1, 2, 3]) >>> a= np.array([[1,1], [2,3]]) >>> np.unique(a) array([1, 2, 3]) Return the indices of the original array that give the unique values: >>> a= np.array([’a’,’b’,’b’,’c’,’a’]) >>> u, indices= np.unique(a, return_index=True) >>> u array([’a’, ’b’, ’c’], dtype=’|S1’) >>> indices array([0, 1, 3]) >>> a[indices] 518 Chapter 3. Routines NumPy Reference, Release 1.8.1 array([’a’, ’b’, ’c’], dtype=’|S1’) Reconstruct the input array from the unique values: >>> a= np.array([1,2,6,4,2,3,2]) >>> u, indices= np.unique(a, return_inverse=True) >>> u array([1, 2, 3, 4, 6]) >>> indices array([0, 1, 4, 3, 1, 2, 1]) >>> u[indices] array([1, 2, 6, 4, 2, 3, 2]) 3.2.10 Rearranging elements fliplr(m) Flip array in the left/right direction. flipud(m) Flip array in the up/down direction. reshape(a, newshape[, order]) Gives a new shape to an array without changing its data. roll(a, shift[, axis]) Roll array elements along a given axis. rot90(m[, k]) Rotate an array by 90 degrees in the counter-clockwise direction. numpy.fliplr(m) Flip array in the left/right direction. Flip the entries in each row in the left/right direction. Columns are preserved, but appear in a different order than before. Parameters m : array_like Input array. Returns f : ndarray A view of m with the columns reversed. Since a view is returned, this operation is O(1). See Also: flipud Flip array in the up/down direction. rot90 Rotate array counterclockwise. Notes Equivalent to A[:,::-1]. Does not require the array to be two-dimensional. Examples >>> A= np.diag([1.,2.,3.]) >>> A array([[ 1., 0., 0.], [ 0., 2., 0.], [ 0., 0., 3.]]) 3.2. Array manipulation routines 519 NumPy Reference, Release 1.8.1 >>> np.fliplr(A) array([[ 0., 0., 1.], [ 0., 2., 0.], [ 3., 0., 0.]]) >>> A= np.random.randn(2,3,5) >>> np.all(np.fliplr(A)==A[:,::-1,...]) True numpy.flipud(m) Flip array in the up/down direction. Flip the entries in each column in the up/down direction. Rows are preserved, but appear in a different order than before. Parameters m : array_like Input array. Returns out : array_like A view of m with the rows reversed. Since a view is returned, this operation is O(1). See Also: fliplr Flip array in the left/right direction. rot90 Rotate array counterclockwise. Notes Equivalent to A[::-1,...]. Does not require the array to be two-dimensional. Examples >>> A= np.diag([1.0,2,3]) >>> A array([[ 1., 0., 0.], [ 0., 2., 0.], [ 0., 0., 3.]]) >>> np.flipud(A) array([[ 0., 0., 3.], [ 0., 2., 0.], [ 1., 0., 0.]]) >>> A= np.random.randn(2,3,5) >>> np.all(np.flipud(A)==A[::-1,...]) True >>> np.flipud([1,2]) array([2, 1]) numpy.reshape(a, newshape, order=’C’) Gives a new shape to an array without changing its data. Parameters a : array_like 520 Chapter 3. Routines NumPy Reference, Release 1.8.1 Array to be reshaped. newshape : int or tuple of ints The new shape should be compatible with the original shape. If an integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions. order : {‘C’, ‘F’, ‘A’}, optional Read the elements of a using this index order, and place the elements into the reshaped array using this index order. ‘C’ means to read / write the elements using C-like index order, with the last axis index changing fastest, back to the ﬁrst axis index changing slowest. ‘F’ means to read / write the elements using Fortran-like index order, with the ﬁrst 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 indexing. ‘A’ means to read / write the elements in Fortran-like index order if a is Fortran contiguous in memory, C-like order otherwise. Returns reshaped_array : ndarray This will be a new view object if possible; otherwise, it will be a copy. Note there is no guarantee of the memory layout (C- or Fortran- contiguous) of the returned array. See Also: ndarray.reshape Equivalent method. Notes It is not always possible to change the shape of an array without copying the data. If you want an error to be raise if the data is copied, you should assign the new shape to the shape attribute of the array: >>> a= np.zeros((10,2)) # A transpose make the array non-contiguous >>> b=a.T # Taking a view makes it possible to modify the shape without modifying the # initial object. >>> c=b.view() >>> c.shape=(20) AttributeError: incompatible shape for a non-contiguous array The order keyword gives the index ordering both for fetching the values from a, and then placing the values into the output array. For example, let’s say you have an array: >>> a= np.arange(6).reshape((3,2)) >>> a array([[0, 1], [2, 3], [4, 5]]) You can think of reshaping as ﬁrst raveling the array (using the given index order), then inserting the elements from the raveled array into the new array using the same kind of index ordering as was used for the raveling. >>> np.reshape(a, (2,3)) # C-like index ordering array([[0, 1, 2], [3, 4, 5]]) >>> np.reshape(np.ravel(a), (2,3)) # equivalent to C ravel then C reshape array([[0, 1, 2], 3.2. Array manipulation routines 521 NumPy Reference, Release 1.8.1 [3, 4, 5]]) >>> np.reshape(a, (2,3), order=’F’)# Fortran-like index ordering array([[0, 4, 3], [2, 1, 5]]) >>> np.reshape(np.ravel(a, order=’F’), (2,3), order=’F’) array([[0, 4, 3], [2, 1, 5]]) Examples >>> a= np.array([[1,2,3], [4,5,6]]) >>> np.reshape(a,6) array([1, 2, 3, 4, 5, 6]) >>> np.reshape(a,6, order=’F’) array([1, 4, 2, 5, 3, 6]) >>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2 array([[1, 2], [3, 4], [5, 6]]) numpy.roll(a, shift, axis=None) Roll array elements along a given axis. Elements that roll beyond the last position are re-introduced at the ﬁrst. Parameters a : array_like Input array. shift : int The number of places by which elements are shifted. axis : int, optional The axis along which elements are shifted. By default, the array is ﬂattened before shifting, after which the original shape is restored. Returns res : ndarray Output array, with the same shape as a. See Also: rollaxis Roll the speciﬁed axis backwards, until it lies in a given position. Examples >>> x= np.arange(10) >>> np.roll(x,2) array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]) >>> x2= np.reshape(x, (2,5)) >>> x2 array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]) >>> np.roll(x2,1) 522 Chapter 3. Routines NumPy Reference, Release 1.8.1 array([[9, 0, 1, 2, 3], [4, 5, 6, 7, 8]]) >>> np.roll(x2,1, axis=0) array([[5, 6, 7, 8, 9], [0, 1, 2, 3, 4]]) >>> np.roll(x2,1, axis=1) array([[4, 0, 1, 2, 3], [9, 5, 6, 7, 8]]) numpy.rot90(m, k=1) Rotate an array by 90 degrees in the counter-clockwise direction. The ﬁrst two dimensions are rotated; therefore, the array must be at least 2-D. Parameters m : array_like Array of two or more dimensions. k : integer Number of times the array is rotated by 90 degrees. Returns y : ndarray Rotated array. See Also: fliplr Flip an array horizontally. flipud Flip an array vertically. Examples >>> m= np.array([[1,2],[3,4]], int) >>> m array([[1, 2], [3, 4]]) >>> np.rot90(m) array([[2, 4], [1, 3]]) >>> np.rot90(m,2) array([[4, 3], [2, 1]]) 3.3 Binary operations 3.3.1 Elementwise bit operations bitwise_and(x1, x2[, out]) Compute the bit-wise AND of two arrays element-wise. bitwise_or(x1, x2[, out]) Compute the bit-wise OR of two arrays element-wise. bitwise_xor(x1, x2[, out]) Compute the bit-wise XOR of two arrays element-wise. Continued on next page 3.3. Binary operations 523 NumPy Reference, Release 1.8.1 Table 3.20 – continued from previous page invert(x[, out]) Compute bit-wise inversion, or bit-wise NOT, element-wise. left_shift(x1, x2[, out]) Shift the bits of an integer to the left. right_shift(x1, x2[, out]) Shift the bits of an integer to the right. numpy.bitwise_and(x1, x2[, out ]) = Compute the bit-wise AND of two arrays element-wise. Computes the bit-wise AND of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator &. Parameters x1, x2 : array_like Only integer and boolean types are handled. Returns out : array_like Result. See Also: logical_and, bitwise_or, bitwise_xor binary_repr Return the binary representation of the input number as a string. Examples The number 13 is represented by 00001101. Likewise, 17 is represented by 00010001. The bit-wise AND of 13 and 17 is therefore 000000001, or 1: >>> np.bitwise_and(13, 17) 1 >>> np.bitwise_and(14, 13) 12 >>> np.binary_repr(12) ’1100’ >>> np.bitwise_and([14,3], 13) array([12, 1]) >>> np.bitwise_and([11,7], [4,25]) array([0, 1]) >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) array([ 2, 4, 16]) >>> np.bitwise_and([True, True], [False, True]) array([False, True], dtype=bool) numpy.bitwise_or(x1, x2[, out ]) = Compute the bit-wise OR of two arrays element-wise. Computes the bit-wise OR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator |. Parameters x1, x2 : array_like Only integer and boolean types are handled. out : ndarray, optional 524 Chapter 3. Routines NumPy Reference, Release 1.8.1 Array into which the output is placed. Its type is preserved and it must be of the right shape to hold the output. See doc.ufuncs. Returns out : array_like Result. See Also: logical_or, bitwise_and, bitwise_xor binary_repr Return the binary representation of the input number as a string. Examples The number 13 has the binaray representation 00001101. Likewise, 16 is represented by 00010000. The bit-wise OR of 13 and 16 is then 000111011, or 29: >>> np.bitwise_or(13, 16) 29 >>> np.binary_repr(29) ’11101’ >>> np.bitwise_or(32,2) 34 >>> np.bitwise_or([33,4],1) array([33, 5]) >>> np.bitwise_or([33,4], [1,2]) array([33, 6]) >>> np.bitwise_or(np.array([2,5, 255]), np.array([4,4,4])) array([ 6, 5, 255]) >>> np.array([2,5, 255])| np.array([4,4,4]) array([ 6, 5, 255]) >>> np.bitwise_or(np.array([2,5, 255, 2147483647L], dtype=np.int32), ... np.array([4,4,4, 2147483647L], dtype=np.int32)) array([ 6, 5, 255, 2147483647]) >>> np.bitwise_or([True, True], [False, True]) array([ True, True], dtype=bool) numpy.bitwise_xor(x1, x2[, out ]) = Compute the bit-wise XOR of two arrays element-wise. Computes the bit-wise XOR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator ^. Parameters x1, x2 : array_like Only integer and boolean types are handled. Returns out : array_like Result. See Also: logical_xor, bitwise_and, bitwise_or 3.3. Binary operations 525 NumPy Reference, Release 1.8.1 binary_repr Return the binary representation of the input number as a string. Examples The number 13 is represented by 00001101. Likewise, 17 is represented by 00010001. The bit-wise XOR of 13 and 17 is therefore 00011100, or 28: >>> np.bitwise_xor(13, 17) 28 >>> np.binary_repr(28) ’11100’ >>> np.bitwise_xor(31,5) 26 >>> np.bitwise_xor([31,3],5) array([26, 6]) >>> np.bitwise_xor([31,3], [5,6]) array([26, 5]) >>> np.bitwise_xor([True, True], [False, True]) array([ True, False], dtype=bool) numpy.invert(x[, out ]) = Compute bit-wise inversion, or bit-wise NOT, element-wise. Computes the bit-wise NOT of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator ~. For signed integer inputs, the two’s complement is returned. In a two’s-complement system negative numbers are represented by the two’s complement of the absolute value. This is the most common method of representing signed integers on computers [R32]. A N-bit two’s-complement system can represent every integer in the range −2N−1 to +2N−1 − 1. Parameters x1 : array_like Only integer and boolean types are handled. Returns out : array_like Result. See Also: bitwise_and, bitwise_or, bitwise_xor, logical_not binary_repr Return the binary representation of the input number as a string. Notes bitwise_not is an alias for invert: >>> np.bitwise_not is np.invert True References [R32] 526 Chapter 3. Routines NumPy Reference, Release 1.8.1 Examples We’ve seen that 13 is represented by 00001101. The invert or bit-wise NOT of 13 is then: >>> np.invert(np.array([13], dtype=uint8)) array([242], dtype=uint8) >>> np.binary_repr(x, width=8) ’00001101’ >>> np.binary_repr(242, width=8) ’11110010’ The result depends on the bit-width: >>> np.invert(np.array([13], dtype=uint16)) array([65522], dtype=uint16) >>> np.binary_repr(x, width=16) ’0000000000001101’ >>> np.binary_repr(65522, width=16) ’1111111111110010’ When using signed integer types the result is the two’s complement of the result for the unsigned type: >>> np.invert(np.array([13], dtype=int8)) array([-14], dtype=int8) >>> np.binary_repr(-14, width=8) ’11110010’ Booleans are accepted as well: >>> np.invert(array([True, False])) array([False, True], dtype=bool) numpy.left_shift(x1, x2[, out ]) = Shift the bits of an integer to the left. Bits are shifted to the left by appending x2 0s at the right of x1. Since the internal representation of numbers is in binary format, this operation is equivalent to multiplying x1 by 2**x2. Parameters x1 : array_like of integer type Input values. x2 : array_like of integer type Number of zeros to append to x1. Has to be non-negative. Returns out : array of integer type Return x1 with bits shifted x2 times to the left. See Also: right_shift Shift the bits of an integer to the right. binary_repr Return the binary representation of the input number as a string. 3.3. Binary operations 527 NumPy Reference, Release 1.8.1 Examples >>> np.binary_repr(5) ’101’ >>> np.left_shift(5,2) 20 >>> np.binary_repr(20) ’10100’ >>> np.left_shift(5,[1,2,3]) array([10, 20, 40]) numpy.right_shift(x1, x2[, out ]) = Shift the bits of an integer to the right. Bits are shifted to the right x2. Because the internal representation of numbers is in binary format, this operation is equivalent to dividing x1 by 2**x2. Parameters x1 : array_like, int Input values. x2 : array_like, int Number of bits to remove at the right of x1. Returns out : ndarray, int Return x1 with bits shifted x2 times to the right. See Also: left_shift Shift the bits of an integer to the left. binary_repr Return the binary representation of the input number as a string. Examples >>> np.binary_repr(10) ’1010’ >>> np.right_shift(10,1) 5 >>> np.binary_repr(5) ’101’ >>> np.right_shift(10,[1,2,3]) array([5, 2, 1]) 3.3.2 Bit packing packbits(myarray[, axis]) Packs the elements of a binary-valued array into bits in a uint8 array. unpackbits(myarray[, axis]) Unpacks elements of a uint8 array into a binary-valued output array. 528 Chapter 3. Routines NumPy Reference, Release 1.8.1 numpy.packbits(myarray, axis=None) Packs the elements of a binary-valued array into bits in a uint8 array. The result is padded to full bytes by inserting zero bits at the end. Parameters myarray : array_like An integer type array whose elements should be packed to bits. axis : int, optional The dimension over which bit-packing is done. None implies packing the ﬂattened array. Returns packed : ndarray Array of type uint8 whose elements represent bits corresponding to the logical (0 or nonzero) value of the input elements. The shape of packed has the same number of dimensions as the input (unless axis is None, in which case the output is 1-D). See Also: unpackbits Unpacks elements of a uint8 array into a binary-valued output array. Examples >>> a= np.array([[[1,0,1], ... [0,1,0]], ... [[1,1,0], ... [0,0,1]]]) >>> b= np.packbits(a, axis=-1) >>> b array([[[160],[64]],[[192],[32]]], dtype=uint8) Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000, and 32 = 0010 0000. numpy.unpackbits(myarray, axis=None) Unpacks elements of a uint8 array into a binary-valued output array. Each element of myarray represents a bit-ﬁeld that should be unpacked into a binary-valued output array. The shape of the output array is either 1-D (if axis is None) or the same shape as the input array with unpacking done along the axis speciﬁed. Parameters myarray : ndarray, uint8 type Input array. axis : int, optional Unpacks along this axis. Returns unpacked : ndarray, uint8 type The elements are binary-valued (0 or 1). See Also: packbits Packs the elements of a binary-valued array into bits in a uint8 array. 3.3. Binary operations 529 NumPy Reference, Release 1.8.1 Examples >>> a= np.array([[2], [7], [23]], dtype=np.uint8) >>> a array([[ 2], [ 7], [23]], dtype=uint8) >>> b= np.unpackbits(a, axis=1) >>> b array([[0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8) 3.3.3 Output formatting binary_repr(num[, width]) Return the binary representation of the input number as a string. numpy.binary_repr(num, width=None) Return the binary representation of the input number as a string. For negative numbers, if width is not given, a minus sign is added to the front. If width is given, the two’s complement of the number is returned, with respect to that width. In a two’s-complement system negative numbers are represented by the two’s complement of the absolute value. This is the most common method of representing signed integers on computers [R16]. A N-bit two’s- complement system can represent every integer in the range −2N−1 to +2N−1 − 1. Parameters num : int Only an integer decimal number can be used. width : int, optional The length of the returned string if num is positive, the length of the two’s complement if num is negative. Returns bin : str Binary representation of num or two’s complement of num. See Also: base_repr Return a string representation of a number in the given base system. Notes binary_repr is equivalent to using base_repr with base 2, but about 25x faster. References [R16] 530 Chapter 3. Routines NumPy Reference, Release 1.8.1 Examples >>> np.binary_repr(3) ’11’ >>> np.binary_repr(-3) ’-11’ >>> np.binary_repr(3, width=4) ’0011’ The two’s complement is returned when the input number is negative and width is speciﬁed: >>> np.binary_repr(-3, width=4) ’1101’ 3.4 String operations This module provides a set of vectorized string operations for arrays of type numpy.string_ or numpy.unicode_. All of them are based on the string methods in the Python standard library. 3.4.1 String operations add(x1, x2) Return element-wise string concatenation for two arrays of str or unicode. multiply(a, i) Return (a * i), that is string multiple concatenation, element-wise. mod(a, values) Return (a % i), that is pre-Python 2.6 string formatting capitalize(a) Return a copy of a with only the ﬁrst character of each element capitalized. center(a, width[, ﬁllchar]) Return a copy of a with its elements centered in a string of length width. decode(a[, encoding, errors]) Calls str.decode element-wise. encode(a[, encoding, errors]) Calls str.encode element-wise. join(sep, seq) Return a string which is the concatenation of the strings in the sequence seq. ljust(a, width[, ﬁllchar]) Return an array with the elements of a left-justiﬁed in a string of length width. lower(a) Return an array with the elements converted to lowercase. lstrip(a[, chars]) For each element in a, return a copy with the leading characters removed. partition(a, sep) Partition each element in a around sep. replace(a, old, new[, count]) For each element in a, return a copy of the string with all occurrences of substring old replaced by new. rjust(a, width[, ﬁllchar]) Return an array with the elements of a right-justiﬁed in a string of length width. rpartition(a, sep) Partition (split) each element around the right-most separator. rsplit(a[, sep, maxsplit]) For each element in a, return a list of the words in the string, using sep as the delimiter string. rstrip(a[, chars]) For each element in a, return a copy with the trailing characters removed. split(a[, sep, maxsplit]) For each element in a, return a list of the words in the string, using sep as the delimiter string. splitlines(a[, keepends]) For each element in a, return a list of the lines in the element, breaking at line boundaries. strip(a[, chars]) For each element in a, return a copy with the leading and trailing characters removed. swapcase(a) Return element-wise a copy of the string with uppercase characters converted to lowercase and vice versa. title(a) Return element-wise title cased version of string or unicode. translate(a, table[, deletechars]) For each element in a, return a copy of the string where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table. upper(a) Return an array with the elements converted to uppercase. zfill(a, width) Return the numeric string left-ﬁlled with zeros numpy.core.defchararray.add(x1, x2) Return element-wise string concatenation for two arrays of str or unicode. Arrays x1 and x2 must have the same shape. 3.4. String operations 531 NumPy Reference, Release 1.8.1 Parameters x1 : array_like of str or unicode Input array. x2 : array_like of str or unicode Input array. Returns add : ndarray Output array of string_ or unicode_, depending on input types of the same shape as x1 and x2. numpy.core.defchararray.multiply(a, i) Return (a * i), that is string multiple concatenation, element-wise. Values in i of less than 0 are treated as 0 (which yields an empty string). Parameters a : array_like of str or unicode i : array_like of ints Returns out : ndarray Output array of str or unicode, depending on input types numpy.core.defchararray.mod(a, values) Return (a % i), that is pre-Python 2.6 string formatting (iterpolation), element-wise for a pair of array_likes of str or unicode. Parameters a : array_like of str or unicode values : array_like of values These values will be element-wise interpolated into the string. Returns out : ndarray Output array of str or unicode, depending on input types See Also: str.__mod__ numpy.core.defchararray.capitalize(a) Return a copy of a with only the ﬁrst character of each element capitalized. Calls str.capitalize element-wise. For 8-bit strings, this method is locale-dependent. Parameters a : array_like of str or unicode Input array of strings to capitalize. Returns out : ndarray Output array of str or unicode, depending on input types 532 Chapter 3. Routines NumPy Reference, Release 1.8.1 See Also: str.capitalize Examples >>> c= np.array([’a1b2’,’1b2a’,’b2a1’,’2a1b’],’S4’); c array([’a1b2’, ’1b2a’, ’b2a1’, ’2a1b’], dtype=’|S4’) >>> np.char.capitalize(c) array([’A1b2’, ’1b2a’, ’B2a1’, ’2a1b’], dtype=’|S4’) numpy.core.defchararray.center(a, width, ﬁllchar=’ ‘) Return a copy of a with its elements centered in a string of length width. Calls str.center element-wise. Parameters a : array_like of str or unicode width : int The length of the resulting strings ﬁllchar : str or unicode, optional The padding character to use (default is space). Returns out : ndarray Output array of str or unicode, depending on input types See Also: str.center numpy.core.defchararray.decode(a, encoding=None, errors=None) Calls str.decode element-wise. The set of available codecs comes from the Python standard library, and may be extended at runtime. For more information, see the codecs module. Parameters a : array_like of str or unicode encoding : str, optional The name of an encoding errors : str, optional Speciﬁes how to handle encoding errors Returns out : ndarray See Also: str.decode Notes The type of the result will depend on the encoding speciﬁed. 3.4. String operations 533 NumPy Reference, Release 1.8.1 Examples >>> c= np.array([’aAaAaA’,’ aA’,’abBABba’]) >>> c array([’aAaAaA’, ’ aA ’, ’abBABba’], dtype=’|S7’) >>> np.char.encode(c, encoding=’cp037’) array([’\x81\xc1\x81\xc1\x81\xc1’, ’@@\x81\xc1@@’, ’\x81\x82\xc2\xc1\xc2\x82\x81’], dtype=’|S7’) numpy.core.defchararray.encode(a, encoding=None, errors=None) Calls str.encode element-wise. The set of available codecs comes from the Python standard library, and may be extended at runtime. For more information, see the codecs module. Parameters a : array_like of str or unicode encoding : str, optional The name of an encoding errors : str, optional Speciﬁes how to handle encoding errors Returns out : ndarray See Also: str.encode Notes The type of the result will depend on the encoding speciﬁed. numpy.core.defchararray.join(sep, seq) Return a string which is the concatenation of the strings in the sequence seq. Calls str.join element-wise. Parameters sep : array_like of str or unicode seq : array_like of str or unicode Returns out : ndarray Output array of str or unicode, depending on input types See Also: str.join numpy.core.defchararray.ljust(a, width, ﬁllchar=’ ‘) Return an array with the elements of a left-justiﬁed in a string of length width. Calls str.ljust element-wise. Parameters a : array_like of str or unicode 534 Chapter 3. Routines NumPy Reference, Release 1.8.1 width : int The length of the resulting strings ﬁllchar : str or unicode, optional The character to use for padding Returns out : ndarray Output array of str or unicode, depending on input type See Also: str.ljust numpy.core.defchararray.lower(a) Return an array with the elements converted to lowercase. Call str.lower element-wise. For 8-bit strings, this method is locale-dependent. Parameters a : array_like, {str, unicode} Input array. Returns out : ndarray, {str, unicode} Output array of str or unicode, depending on input type See Also: str.lower Examples >>> c= np.array([’A1B C’,’1BCA’,’BCA1’]); c array([’A1B C’, ’1BCA’, ’BCA1’], dtype=’|S5’) >>> np.char.lower(c) array([’a1b c’, ’1bca’, ’bca1’], dtype=’|S5’) numpy.core.defchararray.lstrip(a, chars=None) For each element in a, return a copy with the leading characters removed. Calls str.lstrip element-wise. Parameters a : array-like, {str, unicode} Input array. chars : {str, unicode}, optional The chars argument is a string specifying the set of characters to be removed. If omitted or None, the chars argument defaults to removing whitespace. The chars argument is not a preﬁx; rather, all combinations of its values are stripped. Returns out : ndarray, {str, unicode} 3.4. String operations 535 NumPy Reference, Release 1.8.1 Output array of str or unicode, depending on input type See Also: str.lstrip Examples >>> c= np.array([’aAaAaA’,’ aA’,’abBABba’]) >>> c array([’aAaAaA’, ’ aA ’, ’abBABba’], dtype=’|S7’) The ‘a’ variable is unstripped from c[1] because whitespace leading. >>> np.char.lstrip(c,’a’) array([’AaAaA’, ’ aA ’, ’bBABba’], dtype=’|S7’) >>> np.char.lstrip(c,’A’)# leaves c unchanged array([’aAaAaA’, ’ aA ’, ’abBABba’], dtype=’|S7’) >>> (np.char.lstrip(c,’’) == np.char.lstrip(c,’’)).all() ... # XXX: is this a regression? this line now returns False ... # np.char.lstrip(c,’’) does not modify c at all. True >>> (np.char.lstrip(c,’’) == np.char.lstrip(c, None)).all() True numpy.core.defchararray.partition(a, sep) Partition each element in a around sep. Calls str.partition element-wise. For each element in a, split the element as the ﬁrst occurrence of sep, and return 3 strings containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return 3 strings containing the string itself, followed by two empty strings. Parameters a : array_like, {str, unicode} Input array sep : {str, unicode} Separator to split each string element in a. Returns out : ndarray, {str, unicode} Output array of str or unicode, depending on input type. The output array will have an extra dimension with 3 elements per input element. See Also: str.partition numpy.core.defchararray.replace(a, old, new, count=None) For each element in a, return a copy of the string with all occurrences of substring old replaced by new. Calls str.replace element-wise. Parameters a : array-like of str or unicode 536 Chapter 3. Routines NumPy Reference, Release 1.8.1 old, new : str or unicode count : int, optional If the optional argument count is given, only the ﬁrst count occurrences are replaced. Returns out : ndarray Output array of str or unicode, depending on input type See Also: str.replace numpy.core.defchararray.rjust(a, width, ﬁllchar=’ ‘) Return an array with the elements of a right-justiﬁed in a string of length width. Calls str.rjust element-wise. Parameters a : array_like of str or unicode width : int The length of the resulting strings ﬁllchar : str or unicode, optional The character to use for padding Returns out : ndarray Output array of str or unicode, depending on input type See Also: str.rjust numpy.core.defchararray.rpartition(a, sep) Partition (split) each element around the right-most separator. Calls str.rpartition element-wise. For each element in a, split the element as the last occurrence of sep, and return 3 strings containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return 3 strings containing the string itself, followed by two empty strings. Parameters a : array_like of str or unicode Input array sep : str or unicode Right-most separator to split each element in array. Returns out : ndarray Output array of string or unicode, depending on input type. The output array will have an extra dimension with 3 elements per input element. See Also: str.rpartition 3.4. String operations 537 NumPy Reference, Release 1.8.1 numpy.core.defchararray.rsplit(a, sep=None, maxsplit=None) For each element in a, return a list of the words in the string, using sep as the delimiter string. Calls str.rsplit element-wise. Except for splitting from the right, rsplit behaves like split. Parameters a : array_like of str or unicode sep : str or unicode, optional If sep is not speciﬁed or None, any whitespace string is a separator. maxsplit : int, optional If maxsplit is given, at most maxsplit splits are done, the rightmost ones. Returns out : ndarray Array of list objects See Also: str.rsplit, split numpy.core.defchararray.rstrip(a, chars=None) For each element in a, return a copy with the trailing characters removed. Calls str.rstrip element-wise. Parameters a : array-like of str or unicode chars : str or unicode, optional The chars argument is a string specifying the set of characters to be removed. If omitted or None, the chars argument defaults to removing whitespace. The chars argument is not a sufﬁx; rather, all combinations of its values are stripped. Returns out : ndarray Output array of str or unicode, depending on input type See Also: str.rstrip Examples >>> c= np.array([’aAaAaA’,’abBABba’], dtype=’S7’); c array([’aAaAaA’, ’abBABba’], dtype=’|S7’) >>> np.char.rstrip(c,’a’) array([’aAaAaA’, ’abBABb’], dtype=’|S7’) >>> np.char.rstrip(c,’A’) array([’aAaAa’, ’abBABba’], dtype=’|S7’) numpy.core.defchararray.split(a, sep=None, maxsplit=None) For each element in a, return a list of the words in the string, using sep as the delimiter string. Calls str.rsplit element-wise. 538 Chapter 3. Routines NumPy Reference, Release 1.8.1 Parameters a : array_like of str or unicode sep : str or unicode, optional If sep is not speciﬁed or None, any whitespace string is a separator. maxsplit : int, optional If maxsplit is given, at most maxsplit splits are done. Returns out : ndarray Array of list objects See Also: str.split, rsplit numpy.core.defchararray.splitlines(a, keepends=None) For each element in a, return a list of the lines in the element, breaking at line boundaries. Calls str.splitlines element-wise. Parameters a : array_like of str or unicode keepends : bool, optional Line breaks are not included in the resulting list unless keepends is given and true. Returns out : ndarray Array of list objects See Also: str.splitlines numpy.core.defchararray.strip(a, chars=None) For each element in a, return a copy with the leading and trailing characters removed. Calls str.rstrip element-wise. Parameters a : array-like of str or unicode chars : str or unicode, optional The chars argument is a string specifying the set of characters to be removed. If omitted or None, the chars argument defaults to removing whitespace. The chars argument is not a preﬁx or sufﬁx; rather, all combinations of its values are stripped. Returns out : ndarray Output array of str or unicode, depending on input type See Also: str.strip 3.4. String operations 539 NumPy Reference, Release 1.8.1 Examples >>> c= np.array([’aAaAaA’,’ aA’,’abBABba’]) >>> c array([’aAaAaA’, ’ aA ’, ’abBABba’], dtype=’|S7’) >>> np.char.strip(c) array([’aAaAaA’, ’aA’, ’abBABba’], dtype=’|S7’) >>> np.char.strip(c,’a’)# ’a’ unstripped from c[1] because whitespace leads array([’AaAaA’, ’ aA ’, ’bBABb’], dtype=’|S7’) >>> np.char.strip(c,’A’)# ’A’ unstripped from c[1] because (unprinted) ws trails array([’aAaAa’, ’ aA ’, ’abBABba’], dtype=’|S7’) numpy.core.defchararray.swapcase(a) Return element-wise a copy of the string with uppercase characters converted to lowercase and vice versa. Calls str.swapcase element-wise. For 8-bit strings, this method is locale-dependent. Parameters a : array_like, {str, unicode} Input array. Returns out : ndarray, {str, unicode} Output array of str or unicode, depending on input type See Also: str.swapcase Examples >>> c=np.array([’a1B c’,’1b Ca’,’b Ca1’,’cA1b’],’S5’); c array([’a1B c’, ’1b Ca’, ’b Ca1’, ’cA1b’], dtype=’|S5’) >>> np.char.swapcase(c) array([’A1b C’, ’1B cA’, ’B cA1’, ’Ca1B’], dtype=’|S5’) numpy.core.defchararray.title(a) Return element-wise title cased version of string or unicode. Title case words start with uppercase characters, all remaining cased characters are lowercase. Calls str.title element-wise. For 8-bit strings, this method is locale-dependent. Parameters a : array_like, {str, unicode} Input array. Returns out : ndarray Output array of str or unicode, depending on input type 540 Chapter 3. Routines NumPy Reference, Release 1.8.1 See Also: str.title Examples >>> c=np.array([’a1b c’,’1b ca’,’b ca1’,’ca1b’],’S5’); c array([’a1b c’, ’1b ca’, ’b ca1’, ’ca1b’], dtype=’|S5’) >>> np.char.title(c) array([’A1B C’, ’1B Ca’, ’B Ca1’, ’Ca1B’], dtype=’|S5’) numpy.core.defchararray.translate(a, table, deletechars=None) For each element in a, return a copy of the string where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table. Calls str.translate element-wise. Parameters a : array-like of str or unicode table : str of length 256 deletechars : str Returns out : ndarray Output array of str or unicode, depending on input type See Also: str.translate numpy.core.defchararray.upper(a) Return an array with the elements converted to uppercase. Calls str.upper element-wise. For 8-bit strings, this method is locale-dependent. Parameters a : array_like, {str, unicode} Input array. Returns out : ndarray, {str, unicode} Output array of str or unicode, depending on input type See Also: str.upper Examples >>> c= np.array([’a1b c’,’1bca’,’bca1’]); c array([’a1b c’, ’1bca’, ’bca1’], dtype=’|S5’) >>> np.char.upper(c) array([’A1B C’, ’1BCA’, ’BCA1’], dtype=’|S5’) 3.4. String operations 541 NumPy Reference, Release 1.8.1 numpy.core.defchararray.zfill(a, width) Return the numeric string left-ﬁlled with zeros Calls str.zﬁll element-wise. Parameters a : array_like, {str, unicode} Input array. width : int Width of string to left-ﬁll elements in a. Returns out : ndarray, {str, unicode} Output array of str or unicode, depending on input type See Also: str.zfill 3.4.2 Comparison Unlike the standard numpy comparison operators, the ones in the char module strip trailing whitespace characters before performing the comparison. equal(x1, x2) Return (x1 == x2) element-wise. not_equal(x1, x2) Return (x1 != x2) element-wise. greater_equal(x1, x2) Return (x1 >= x2) element-wise. less_equal(x1, x2) Return (x1 <= x2) element-wise. greater(x1, x2) Return (x1 > x2) element-wise. less(x1, x2) Return (x1 < x2) element-wise. numpy.core.defchararray.equal(x1, x2) Return (x1 == x2) element-wise. Unlike numpy.equal, this comparison is performed by ﬁrst stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns out : {ndarray, bool} Output array of bools, or a single bool if x1 and x2 are scalars. See Also: not_equal, greater_equal, less_equal, greater, less numpy.core.defchararray.not_equal(x1, x2) Return (x1 != x2) element-wise. Unlike numpy.not_equal, this comparison is performed by ﬁrst stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. 542 Chapter 3. Routines NumPy Reference, Release 1.8.1 Parameters x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns out : {ndarray, bool} Output array of bools, or a single bool if x1 and x2 are scalars. See Also: equal, greater_equal, less_equal, greater, less numpy.core.defchararray.greater_equal(x1, x2) Return (x1 >= x2) element-wise. Unlike numpy.greater_equal, this comparison is performed by ﬁrst stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns out : {ndarray, bool} Output array of bools, or a single bool if x1 and x2 are scalars. See Also: equal, not_equal, less_equal, greater, less numpy.core.defchararray.less_equal(x1, x2) Return (x1 <= x2) element-wise. Unlike numpy.less_equal, this comparison is performed by ﬁrst stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns out : {ndarray, bool} Output array of bools, or a single bool if x1 and x2 are scalars. See Also: equal, not_equal, greater_equal, greater, less numpy.core.defchararray.greater(x1, x2) Return (x1 > x2) element-wise. Unlike numpy.greater, this comparison is performed by ﬁrst stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns out : {ndarray, bool} 3.4. String operations 543 NumPy Reference, Release 1.8.1 Output array of bools, or a single bool if x1 and x2 are scalars. See Also: equal, not_equal, greater_equal, less_equal, less numpy.core.defchararray.less(x1, x2) Return (x1 < x2) element-wise. Unlike numpy.greater, this comparison is performed by ﬁrst stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns out : {ndarray, bool} Output array of bools, or a single bool if x1 and x2 are scalars. See Also: equal, not_equal, greater_equal, less_equal, greater 3.4.3 String information count(a, sub[, start, end]) Returns an array with the number of non-overlapping occurrences of substring sub in the range [start, end]. find(a, sub[, start, end]) For each element, return the lowest index in the string where substring sub is found. index(a, sub[, start, end]) Like find, but raises ValueError when the substring is not found. isalpha(a) Returns true for each element if all characters in the string are alphabetic and there is at least one character, false otherwise. isdecimal(a) For each element, return True if there are only decimal isdigit(a) Returns true for each element if all characters in the string are digits and there is at least one character, false otherwise. islower(a) Returns true for each element if all cased characters in the string are lowercase and there is at least one cased character, false otherwise. isnumeric(a) For each element, return True if there are only numeric isspace(a) Returns true for each element if there are only whitespace characters in the string and there is at least one character, false otherwise. istitle(a) Returns true for each element if the element is a titlecased string and there is at least one character, false otherwise. isupper(a) Returns true for each element if all cased characters in the string are uppercase and there is at least one character, false otherwise. rfind(a, sub[, start, end]) For each element in a, return the highest index in the string where substring sub is found, such that sub is contained within [start, end]. rindex(a, sub[, start, end]) Like rfind, but raises ValueError when the substring sub is startswith(a, preﬁx[, start, end]) Returns a boolean array which is True where the string element numpy.core.defchararray.count(a, sub, start=0, end=None) Returns an array with the number of non-overlapping occurrences of substring sub in the range [start, end]. Calls str.count element-wise. Parameters a : array_like of str or unicode sub : str or unicode The substring to search for. start, end : int, optional Optional arguments start and end are interpreted as slice notation to specify the range in which to count. 544 Chapter 3. Routines NumPy Reference, Release 1.8.1 Returns out : ndarray Output array of ints. See Also: str.count Examples >>> c= np.array([’aAaAaA’,’ aA’,’abBABba’]) >>> c array([’aAaAaA’, ’ aA ’, ’abBABba’], dtype=’|S7’) >>> np.char.count(c,’A’) array([3, 1, 1]) >>> np.char.count(c,’aA’) array([3, 1, 0]) >>> np.char.count(c,’A’, start=1, end=4) array([2, 1, 1]) >>> np.char.count(c,’A’, start=1, end=3) array([1, 0, 0]) numpy.core.defchararray.find(a, sub, start=0, end=None) For each element, return the lowest index in the string where substring sub is found. Calls str.ﬁnd element-wise. For each element, return the lowest index in the string where substring sub is found, such that sub is contained in the range [start, end]. Parameters a : array_like of str or unicode sub : str or unicode start, end : int, optional Optional arguments start and end are interpreted as in slice notation. Returns out : ndarray or int Output array of ints. Returns -1 if sub is not found. See Also: str.find numpy.core.defchararray.index(a, sub, start=0, end=None) Like find, but raises ValueError when the substring is not found. Calls str.index element-wise. Parameters a : array_like of str or unicode sub : str or unicode start, end : int, optional Returns out : ndarray Output array of ints. Returns -1 if sub is not found. 3.4. String operations 545 NumPy Reference, Release 1.8.1 See Also: find, str.find numpy.core.defchararray.isalpha(a) Returns true for each element if all characters in the string are alphabetic and there is at least one character, false otherwise. Calls str.isalpha element-wise. For 8-bit strings, this method is locale-dependent. Parameters a : array_like of str or unicode Returns out : ndarray Output array of bools See Also: str.isalpha numpy.core.defchararray.isdecimal(a) For each element, return True if there are only decimal characters in the element. Calls unicode.isdecimal element-wise. Decimal characters include digit characters, and all characters that that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Parameters a : array_like, unicode Input array. Returns out : ndarray, bool Array of booleans identical in shape to a. See Also: unicode.isdecimal numpy.core.defchararray.isdigit(a) Returns true for each element if all characters in the string are digits and there is at least one character, false otherwise. Calls str.isdigit element-wise. For 8-bit strings, this method is locale-dependent. Parameters a : array_like of str or unicode Returns out : ndarray Output array of bools See Also: str.isdigit 546 Chapter 3. Routines NumPy Reference, Release 1.8.1 numpy.core.defchararray.islower(a) Returns true for each element if all cased characters in the string are lowercase and there is at least one cased character, false otherwise. Calls str.islower element-wise. For 8-bit strings, this method is locale-dependent. Parameters a : array_like of str or unicode Returns out : ndarray Output array of bools See Also: str.islower numpy.core.defchararray.isnumeric(a) For each element, return True if there are only numeric characters in the element. Calls unicode.isnumeric element-wise. Numeric characters include digit characters, and all characters that have the Unicode numeric value property, e.g. U+2155, VULGAR FRACTION ONE FIFTH. Parameters a : array_like, unicode Input array. Returns out : ndarray, bool Array of booleans of same shape as a. See Also: unicode.isnumeric numpy.core.defchararray.isspace(a) Returns true for each element if there are only whitespace characters in the string and there is at least one character, false otherwise. Calls str.isspace element-wise. For 8-bit strings, this method is locale-dependent. Parameters a : array_like of str or unicode Returns out : ndarray Output array of bools See Also: str.isspace numpy.core.defchararray.istitle(a) Returns true for each element if the element is a titlecased string and there is at least one character, false otherwise. Call str.istitle element-wise. 3.4. String operations 547 NumPy Reference, Release 1.8.1 For 8-bit strings, this method is locale-dependent. Parameters a : array_like of str or unicode Returns out : ndarray Output array of bools See Also: str.istitle numpy.core.defchararray.isupper(a) Returns true for each element if all cased characters in the string are uppercase and there is at least one character, false otherwise. Call str.isupper element-wise. For 8-bit strings, this method is locale-dependent. Parameters a : array_like of str or unicode Returns out : ndarray Output array of bools See Also: str.isupper numpy.core.defchararray.rfind(a, sub, start=0, end=None) For each element in a, return the highest index in the string where substring sub is found, such that sub is contained within [start, end]. Calls str.rﬁnd element-wise. Parameters a : array-like of str or unicode sub : str or unicode start, end : int, optional Optional arguments start and end are interpreted as in slice notation. Returns out : ndarray Output array of ints. Return -1 on failure. See Also: str.rfind numpy.core.defchararray.rindex(a, sub, start=0, end=None) Like rfind, but raises ValueError when the substring sub is not found. Calls str.rindex element-wise. Parameters a : array-like of str or unicode sub : str or unicode 548 Chapter 3. Routines NumPy Reference, Release 1.8.1 start, end : int, optional Returns out : ndarray Output array of ints. See Also: rfind, str.rindex numpy.core.defchararray.startswith(a, preﬁx, start=0, end=None) Returns a boolean array which is True where the string element in a starts with preﬁx, otherwise False. Calls str.startswith element-wise. Parameters a : array_like of str or unicode preﬁx : str start, end : int, optional With optional start, test beginning at that position. With optional end, stop comparing at that position. Returns out : ndarray Array of booleans See Also: str.startswith 3.4.4 Convenience class chararray Provides a convenient view on arrays of string and unicode values. class numpy.core.defchararray.chararray Provides a convenient view on arrays of string and unicode values. Note: The chararray class exists for backwards compatibility with Numarray, it is not recommended for new development. Starting from numpy 1.4, if one needs arrays of strings, it is recommended to use arrays of dtype object_, string_ or unicode_, and use the free functions in the numpy.char module for fast vectorized string operations. Versus a regular Numpy array of type str or unicode, this class adds the following functionality: 1.values automatically have whitespace removed from the end when indexed 2.comparison operators automatically remove whitespace from the end when comparing values 3.vectorized string operations are provided as methods (e.g. endswith) and inﬁx operators (e.g. "+", "*", "%") chararrays should be created using numpy.char.array or numpy.char.asarray, rather than this con- structor directly. This constructor creates the array, using buffer (with offset and strides) if it is not None. If buffer 3.4. String operations 549 NumPy Reference, Release 1.8.1 is None, then constructs a new array with strides in “C order”, unless both len(shape) >= 2 and order=’Fortran’, in which case strides is in “Fortran order”. Parameters shape : tuple Shape of the array. itemsize : int, optional Length of each array element, in number of characters. Default is 1. unicode : bool, optional Are the array elements of type unicode (True) or string (False). Default is False. buffer : int, optional Memory address of the start of the array data. Default is None, in which case a new array is created. offset : int, optional Fixed stride displacement from the beginning of an axis? Default is 0. Needs to be >=0. strides : array_like of ints, optional Strides for the array (see ndarray.strides for full description). Default is None. order : {‘C’, ‘F’}, optional The order in which the array data is stored in memory: ‘C’ -> “row major” order (the default), ‘F’ -> “column major” (Fortran) order. Examples >>> charar= np.chararray((3,3)) >>> charar[:]=’a’ >>> charar chararray([[’a’, ’a’, ’a’], [’a’, ’a’, ’a’], [’a’, ’a’, ’a’]], dtype=’|S1’) >>> charar= np.chararray(charar.shape, itemsize=5) >>> charar[:]=’abc’ >>> charar chararray([[’abc’, ’abc’, ’abc’], [’abc’, ’abc’, ’abc’], [’abc’, ’abc’, ’abc’]], dtype=’|S5’) Attributes T Same as self.transpose(), except that self is returned if self.ndim < 2. base Base object if memory is from some other object. ctypes An object to simplify the interaction of the array with the ctypes module. data Python buffer object pointing to the start of the array’s data. dtype Data-type of the array’s elements. flags Information about the memory layout of the array. flat A 1-D iterator over the array. Continued on next page 550 Chapter 3. Routines NumPy Reference, Release 1.8.1 Table 3.27 – continued from previous page imag The imaginary part of the array. itemsize Length of one array element in bytes. nbytes Total bytes consumed by the elements of the array. ndim Number of array dimensions. real The real part of the array. shape Tuple of array dimensions. size Number of elements in the array. strides Tuple of bytes to step in each dimension when traversing an array. chararray.T Same as self.transpose(), except that self is returned if self.ndim < 2. Examples >>> x= np.array([[1.,2.],[3.,4.]]) >>> x array([[ 1., 2.], [ 3., 4.]]) >>> x.T array([[ 1., 3.], [ 2., 4.]]) >>> x= np.array([1.,2.,3.,4.]) >>> x array([ 1., 2., 3., 4.]) >>> x.T array([ 1., 2., 3., 4.]) chararray.base Base object if memory is from some other object. Examples The base of an array that owns its memory is None: >>> 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 chararray.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 c : Python object Possessing attributes data, shape, strides, etc. 3.4. String operations 551 NumPy Reference, Release 1.8.1 See Also: numpy.ctypeslib 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): •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 ﬂags 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]. •shape (c_intp*self.ndim): A ctypes array of length self.ndim where the basetype is the C-integer corresponding to dtype(‘p’) on this platform. This base-type could be c_int, c_long, or c_longlong depending on the platform. The c_intp type is deﬁned accordingly in numpy.ctypeslib. The ctypes array contains the shape of the underlying array. •strides (c_intp*self.ndim): 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. •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 ﬂoating-point data: self.data_as(ctypes.POINTER(ctypes.c_double)). •shape_as(obj): Return the shape tuple as an array of some other c-types type. For example: self.shape_as(ctypes.c_short). •strides_as(obj): Return the strides tuple as an array of some other c-types type. For example: self.strides_as(ctypes.c_longlong). Be careful using the ctypes attribute - especially on temporary arrays or arrays constructed on the ﬂy. For example, calling (a+b).ctypes.data_as(ctypes.c_void_p) returns a pointer to memory that is invalid because the array created as (a+b) is deallocated before the next Python statement. You can avoid this problem using either c=a+b or ct=(a+b).ctypes. In the latter case, ct will hold a reference to the array until ct is deleted or re-assigned. 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 ctypes >>> x array([[0, 1], [2, 3]]) >>> x.ctypes.data 30439712 >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents c_long(0) >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents c_longlong(4294967296L) >>> x.ctypes.shape 552 Chapter 3. Routines NumPy Reference, Release 1.8.1 >>> x.ctypes.shape_as(ctypes.c_long) >>> x.ctypes.strides >>> x.ctypes.strides_as(ctypes.c_longlong) chararray.data Python buffer object pointing to the start of the array’s data. chararray.dtype Data-type of the array’s elements. Parameters None Returns d : numpy dtype object See Also: numpy.dtype Examples >>> x array([[0, 1], [2, 3]]) >>> x.dtype dtype(’int32’) >>> type(x.dtype) chararray.flags Information about the memory layout of the array. Notes The flags object can be accessed dictionary-like (as in a.flags[’WRITEABLE’]), or by using low- ercased attribute names (as in a.flags.writeable). Short ﬂag names are only supported in dictionary access. Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED ﬂags can be changed by the user, via direct assignment to the attribute or dictionary entry, or by calling ndarray.setflags. The array ﬂags cannot be set arbitrarily: •UPDATEIFCOPY 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 arbi- trary 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. 3.4. String operations 553 NumPy Reference, Release 1.8.1 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. OWN- DATA (O) The array owns the memory it uses or borrows it from another object. WRITE- ABLE (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. UP- DATEIF- COPY (U) This array is a copy of some other array. When this array is deallocated, 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. chararray.flat A 1-D iterator over the array. This is a numpy.flatiter instance, which acts similarly to, but is not a subclass of, Python’s built-in iterator object. See Also: flatten Return a copy of the array collapsed into one dimension. flatiter Examples >>> x= np.arange(1,7).reshape(2,3) >>> x array([[1, 2, 3], [4, 5, 6]]) >>> x.flat[3] 4 >>> x.T array([[1, 4], [2, 5], [3, 6]]) 554 Chapter 3. Routines NumPy Reference, Release 1.8.1 >>> x.T.flat[3] 5 >>> type(x.flat)