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

Examples

```>>> import numpy as np
>>> 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. Complex-conjugate all elements. 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. 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. Return self as an `ndarray` object. Return self as a flattened `ndarray`. Returns the (complex) conjugate transpose of self. Returns the (multiplicative) inverse of invertible self. 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. 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). 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