Skip to main content
`Ctrl`+`K`
scipy.sparse.

# dok_matrix

class scipy.sparse.dok_matrix(arg1, shape=None, dtype=None, copy=False, *, maxprint=None)

  Dictionary Of Keys based sparse matrix.

  This is an efficient structure for constructing sparse matrices incrementally.

  Warning

  SciPy sparse is shifting from a sparse matrix interface to a sparse array interface. In the next few releases we expect to deprecate the sparse matrix interface. For documentation of the matrix interface, see the spmatrix interface docs. For guidance on converting existing code to sparse arrays, see Migration from spmatrix to sparray.

  This can be instantiated in several ways:
    dok_matrix(D)

      where D is a 2-D ndarray

    dok_matrix(S)

      with another sparse array or matrix S (equivalent to S.todok())

    dok_matrix((M,N), [dtype])

      create the matrix with initial shape (M,N) dtype is optional, defaulting to dtype=’d’

  Attributes:
    dtype dtype

      Data type of the matrix

    `shape` 2-tuple

      Get shape of a sparse matrix.

    ndim int

      Number of dimensions (this is always 2)

    `format` str

      Format string for matrix.

    `nnz` int

      Number of stored values, including explicit zeros.

    `size` int

      Number of stored values.

    `T` dok_matrix

      Transpose.

    `mT` dok_matrix

      Matrix transpose.

  Methods

  `__len__`() | Return len(self).
  `__mul__`(other) |
  `__pow__`(power) |
  `asformat`(format[, copy]) | Return this array/matrix in the passed format.
  `asfptype`() | Upcast matrix to a floating point format (if necessary)
  `astype`(dtype[, casting, copy]) | Cast the array/matrix elements to a specified type.
  `clear`() | Remove all items from the dok_array.
  `conj`([copy]) | Element-wise complex conjugation.
  `conjugate`([copy]) | Element-wise complex conjugation.
  `copy`() | Returns a copy of this array/matrix.
  `count_nonzero`([axis]) | Number of non-zero entries.
  `diagonal`([k]) | Returns the kth diagonal of the array/matrix.
  `dot`(other) | Ordinary dot product.
  `fromkeys`(iterable[, value]) | Create a new dictionary with keys from iterable and values set to value.
  `get`(key[, default]) | This provides dict.get method functionality with type checking.
  `getH`() | Return the Hermitian transpose of this matrix.
  `get_shape`() | Get shape of a sparse matrix.
  `getcol`(j) | Returns a copy of column j of the matrix, as an (m x 1) sparse matrix (column vector).
  `getformat`() | Matrix storage format
  `getmaxprint`() | Maximum number of elements to display when printed.
  `getnnz`([axis]) | Number of stored values, including explicit zeros.
  `getrow`(i) | Returns a copy of row i of the matrix, as a (1 x n) sparse matrix (row vector).
  `items`() | Return a set-like object providing a view on the array's items.
  `keys`() | Return a set-like object providing a view on the dict's keys.
  `maximum`(other) | Element-wise maximum between this and another array/matrix.
  `mean`([axis, dtype, out]) | Compute the arithmetic mean along the specified axis.
  `minimum`(other) | Element-wise minimum between this and another array/matrix.
  `multiply`(other) | Element-wise multiplication by another array/matrix.
  `nonzero`() | Nonzero indices of the array/matrix.
  `pop`(key[, default]) | Remove specified key and return the corresponding value.
  `popitem`() | Remove and return a (key, value) pair as a 2-tuple, returned in LIFO (last-in, first-out) order.
  `power`(n[, dtype]) | Element-wise power.
  `reshape`(self, shape[, order, copy]) | Gives a new shape to a sparse array/matrix without changing its data.
  `resize`(*shape) | Resize the array/matrix in-place to dimensions given by `shape`.
  `set_shape`(shape) | Set the shape of the matrix in-place
  `setdefault`(key[, default]) | Insert key with a value of default if key is not in the dictionary.
  `setdiag`(values[, k]) | Set diagonal or off-diagonal elements of the array/matrix.
  `sum`([axis, dtype, out]) | Sum the array/matrix elements over a given axis.
  `toarray`([order, out]) | Return a dense ndarray representation of this sparse array/matrix.
  `tobsr`([blocksize, copy]) | Convert this array/matrix to Block Sparse Row format.
  `tocoo`([copy]) | Convert this array/matrix to COOrdinate format.
  `tocsc`([copy]) | Convert this array/matrix to Compressed Sparse Column format.
  `tocsr`([copy]) | Convert this array/matrix to Compressed Sparse Row format.
  `todense`([order, out]) | Return a dense representation of this sparse matrix.
  `todia`([copy]) | Convert this array/matrix to sparse DIAgonal format.
  `todok`([copy]) | Convert this array/matrix to Dictionary Of Keys format.
  `tolil`([copy]) | Convert this array/matrix to List of Lists format.
  `trace`([offset]) | Returns the sum along diagonals of the sparse array/matrix.
  `transpose`([axes, copy]) | Reverses the dimensions of the sparse array/matrix.
  `update`(val) | Update values from a dict, sparse dok or iterable of 2-tuples like `.items()`.
  `values`() | Return an object providing a view on the dict's values.

  __add__ |
  __getitem__ |
  __matmul__ |
  __rmatmul__ |
  __rmul__ |
  __truediv__ |

  Notes

  Sparse matrices can be used in arithmetic operations: they support addition, subtraction, multiplication, division, and matrix power.

  - Allows for efficient O(1) access of individual elements.

  - Duplicates are not allowed.

  - Can be efficiently converted to a coo_matrix once constructed.

  Examples

      >>> import numpy as np
      >>> from scipy.sparse import dok_matrix
      >>> S = dok_matrix((5, 5), dtype=np.float32)
      >>> for i in range(5):
      ...     for j in range(5):
      ...         S[i, j] = i + j    # Update element