# numpy.matrix

class numpy.matrix(data, dtype=None, copy=True)

  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.

  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

      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.

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

  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.
  `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.
  `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 the 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 flattened matrix.
  `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 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 |