Array manipulation routines#

Basic operations#

`copyto`(dst, src[, casting, where])	Copies values from one array to another, broadcasting as necessary.
`ndim`(a)	Return the number of dimensions of an array.
`shape`(a)	Return the shape of an array.
`size`(a[, axis])	Return the number of elements along a given axis.

Changing array shape#

`reshape`(a, /[, shape, newshape, order, copy])	Gives a new shape to an array without changing its data.
`ravel`(a[, order])	Return a contiguous flattened array.
`ndarray.flat`	A 1-D iterator over the array.
`ndarray.flatten`([order])	Return a copy of the array collapsed into one dimension.

Transpose-like operations#

`moveaxis`(a, source, destination)	Move axes of an array to new positions.
`rollaxis`(a, axis[, start])	Roll the specified axis backwards, until it lies in a given position.
`swapaxes`(a, axis1, axis2)	Interchange two axes of an array.
`ndarray.T`	View of the transposed array.
`transpose`(a[, axes])	Returns an array with axes transposed.
`permute_dims`(a[, axes])	Returns an array with axes transposed.
`matrix_transpose`(x, /)	Transposes a matrix (or a stack of matrices) `x`.

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_to`(array, shape[, subok])	Broadcast an array to a new shape.
`broadcast_arrays`(*args[, subok])	Broadcast any number of arrays against each other.
`expand_dims`(a, axis)	Expand the shape of an array.
`squeeze`(a[, axis])	Remove axes of length one from a.

Changing kind of array#

`asarray`(a[, dtype, order, device, copy, like])	Convert the input to an array.
`asanyarray`(a[, dtype, order, like])	Convert the input to an ndarray, but pass ndarray subclasses through.
`asmatrix`(data[, dtype])	Interpret the input as a matrix.
`asfortranarray`(a[, dtype, like])	Return an array (ndim >= 1) laid out in Fortran order in memory.
`ascontiguousarray`(a[, dtype, like])	Return a contiguous array (ndim >= 1) in memory (C order).
`asarray_chkfinite`(a[, dtype, order])	Convert the input to an array, checking for NaNs or Infs.
`require`(a[, dtype, requirements, like])	Return an ndarray of the provided type that satisfies requirements.

Joining arrays#

`concatenate`([axis, out, dtype, casting])	Join a sequence of arrays along an existing axis.
`concat`([axis, out, dtype, casting])	Join a sequence of arrays along an existing axis.
`stack`(arrays[, axis, out, dtype, casting])	Join a sequence of arrays along a new axis.
`block`(arrays)	Assemble an nd-array from nested lists of blocks.
`vstack`(tup, *[, dtype, casting])	Stack arrays in sequence vertically (row wise).
`hstack`(tup, *[, dtype, casting])	Stack arrays in sequence horizontally (column wise).
`dstack`(tup)	Stack arrays in sequence depth wise (along third axis).
`column_stack`(tup)	Stack 1-D arrays as columns into a 2-D array.

Splitting arrays#

`split`(ary, indices_or_sections[, axis])	Split an array into multiple sub-arrays as views into ary.
`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).
`vsplit`(ary, indices_or_sections)	Split an array into multiple sub-arrays vertically (row-wise).

Tiling arrays#

`tile`(A, reps)	Construct an array by repeating A the number of times given by reps.
`repeat`(a, repeats[, axis])	Repeat each element of an array after themselves

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 specified shape.
`trim_zeros`(filt[, 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.
`pad`(array, pad_width[, mode])	Pad an array.

Rearranging elements#

`flip`(m[, axis])	Reverse the order of elements in an array along the given axis.
`fliplr`(m)	Reverse the order of elements along axis 1 (left/right).
`flipud`(m)	Reverse the order of elements along axis 0 (up/down).
`reshape`(a, /[, shape, newshape, order, copy])	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, axes])	Rotate an array by 90 degrees in the plane specified by axes.