numpy.matrix#

class numpy.matrix(data, dtype=None, copy=True)[source]#

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).

Note

It is no longer recommended to use this class, even for linear algebra. Instead use regular arrays. The class may be removed in the future.

Parameters:

dataarray_like or string: If data is a string, it is interpreted as a matrix with commas or spaces separating columns, and semicolons separating rows.
dtypedata-type: Data-type of the output matrix.
copybool: If data is already an ndarray, then this flag 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')
>>> a
matrix([[1, 2],
        [3, 4]])

>>> np.matrix([[1, 2], [3, 4]])
matrix([[1, 2],
        [3, 4]])

Attributes:

A: Return self as an ndarray object.
A1: Return self as a flattened ndarray.
H: Returns the (complex) conjugate transpose of self.
I: Returns the (multiplicative) inverse of invertible self.
T: Returns the transpose of the matrix.
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.
device
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.
itemset
itemsize: Length of one array element in bytes.
mT: View of the matrix transposed array.
nbytes: Total bytes consumed by the elements of the array.
ndim: Number of array dimensions.
newbyteorder
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.

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])	Indexes of the maximum values along an axis.
`argmin`([axis, out])	Indexes 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 specified type.
`byteswap`([inplace])	Swap the bytes of the array elements
`choose`(choices[, out, mode])	Use an index array to construct a new array from a set of choices.
`clip`([min, max, out])	Return an array whose values are limited to `[min, max]`.
`compress`(condition[, axis, out])	Return 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 specified diagonals.
`dump`(file)	Dump a pickle of the array to the specified file.
`dumps`()	Returns the pickle of the array as a string.
`fill`(value)	Fill the array with a scalar value.
`flatten`([order])	Return a flattened copy of the matrix.
`getA`()	Return self as an `ndarray` object.
`getA1`()	Return self as a flattened `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 field of the given array as a certain type.
`item`(*args)	Copy an element of an array to a standard Python scalar and return it.
`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.
`nonzero`()	Return the indices of the elements that are non-zero.
`partition`(kth[, axis, kind, order])	Partially sorts the elements in the array in such a way that the value of the element in k-th position is in the position it would be in a sorted array.
`prod`([axis, dtype, out])	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 flattened matrix.
`repeat`(repeats[, axis])	Repeat elements of an array.
`reshape`(shape, /, *[, order, copy])	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 specified place in a field defined by a data-type.
`setflags`([write, align, uic])	Set array flags WRITEABLE, ALIGNED, WRITEBACKIFCOPY, respectively.
`sort`([axis, kind, order])	Sort an array in-place.
`squeeze`([axis])	Return a possibly reshaped matrix.
`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.
`tobytes`([order])	Construct Python bytes containing the raw data bytes in the array.
`tofile`(fid[, sep, format])	Write array to a file as text or binary (default).
`tolist`()	Return the matrix as a (possibly nested) list.
`tostring`([order])	A compatibility alias for `tobytes`, with exactly the same behavior.
`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.

dot
to_device