# scipy.sparse.csr_array#

class scipy.sparse.csr_array(arg1, shape=None, dtype=None, copy=False)[source]#

Compressed Sparse Row array.

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

where D is a 2-D ndarray

csr_array(S)

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

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

to construct an empty array with shape (M, N) dtype is optional, defaulting to dtype=’d’.

csr_array((data, (row_ind, col_ind)), [shape=(M, N)])

where `data`, `row_ind` and `col_ind` satisfy the relationship `a[row_ind[k], col_ind[k]] = data[k]`.

csr_array((data, indices, indptr), [shape=(M, N)])

is the standard CSR representation where the column indices for row i are stored in `indices[indptr[i]:indptr[i+1]]` and their corresponding values are stored in `data[indptr[i]:indptr[i+1]]`. If the shape parameter is not supplied, the array dimensions are inferred from the index arrays.

Notes

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

• efficient arithmetic operations CSR + CSR, CSR * CSR, etc.

• efficient row slicing

• fast matrix vector products

• slow column slicing operations (consider CSC)

• changes to the sparsity structure are expensive (consider LIL or DOK)

Canonical Format
• Within each row, indices are sorted by column.

• There are no duplicate entries.

Examples

```>>> import numpy as np
>>> from scipy.sparse import csr_array
>>> csr_array((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
```
```>>> row = np.array([0, 0, 1, 2, 2, 2])
>>> col = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csr_array((data, (row, col)), shape=(3, 3)).toarray()
array([[1, 0, 2],
[0, 0, 3],
[4, 5, 6]])
```
```>>> indptr = np.array([0, 2, 3, 6])
>>> indices = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csr_array((data, indices, indptr), shape=(3, 3)).toarray()
array([[1, 0, 2],
[0, 0, 3],
[4, 5, 6]])
```

Duplicate entries are summed together:

```>>> row = np.array([0, 1, 2, 0])
>>> col = np.array([0, 1, 1, 0])
>>> data = np.array([1, 2, 4, 8])
>>> csr_array((data, (row, col)), shape=(3, 3)).toarray()
array([[9, 0, 0],
[0, 2, 0],
[0, 4, 0]])
```

As an example of how to construct a CSR array incrementally, the following snippet builds a term-document array from texts:

```>>> docs = [["hello", "world", "hello"], ["goodbye", "cruel", "world"]]
>>> indptr = [0]
>>> indices = []
>>> data = []
>>> vocabulary = {}
>>> for d in docs:
...     for term in d:
...         index = vocabulary.setdefault(term, len(vocabulary))
...         indices.append(index)
...         data.append(1)
...     indptr.append(len(indices))
...
>>> csr_array((data, indices, indptr), dtype=int).toarray()
array([[2, 1, 0, 0],
[0, 1, 1, 1]])
```
Attributes:
dtypedtype

Data type of the array

`shape`2-tuple

The shape of the array.

ndimint

Number of dimensions (this is always 2)

`nnz`

Number of stored values, including explicit zeros.

`size`

Number of stored values.

data

CSR format data array of the array

indices

CSR format index array of the array

indptr

CSR format index pointer array of the array

`has_sorted_indices`

Whether the indices are sorted

`has_canonical_format`

Whether the array/matrix has sorted indices and no duplicates

`T`

Transpose.

Methods

 Element-wise arcsin. Element-wise arcsinh. Element-wise arctan. Element-wise arctanh. `argmax`([axis, out]) Return indices of maximum elements along an axis. `argmin`([axis, out]) Return indices of minimum elements along an axis. `asformat`(format[, copy]) Return this array/matrix in the passed format. Upcast array/matrix to a floating point format (if necessary) `astype`(dtype[, casting, copy]) Cast the array/matrix elements to a specified type. Element-wise ceil. `check_format`([full_check]) Check whether the array/matrix respects the CSR or CSC format. `conj`([copy]) Element-wise complex conjugation. `conjugate`([copy]) Element-wise complex conjugation. Returns a copy of this array/matrix. Number of non-zero entries, equivalent to Element-wise deg2rad. `diagonal`([k]) Returns the kth diagonal of the array/matrix. `dot`(other) Ordinary dot product Remove zero entries from the array/matrix Element-wise expm1. Element-wise floor. Return the Hermitian transpose of this array/matrix. Get shape of a sparse array/matrix. Returns a copy of column j of the array/matrix, as an (m x 1) sparse array/matrix (column vector). Sparse array/matrix storage format. Maximum number of elements to display when printed. `getnnz`([axis]) Number of stored values, including explicit zeros. Returns a copy of row i of the array/matrix, as a (1 x n) sparse array/matrix (row vector). Element-wise log1p. `max`([axis, out]) Return the maximum of the array/matrix or maximum along an axis. `maximum`(other) Element-wise maximum between this and another array/matrix. `mean`([axis, dtype, out]) Compute the arithmetic mean along the specified axis. `min`([axis, out]) Return the minimum of the array/matrix or maximum along an axis. `minimum`(other) Element-wise minimum between this and another array/matrix. `multiply`(other) Point-wise multiplication by another array/matrix, vector, or scalar. `nanmax`([axis, out]) Return the maximum of the array/matrix or maximum along an axis, ignoring any NaNs. `nanmin`([axis, out]) Return the minimum of the array/matrix or minimum along an axis, ignoring any NaNs. Nonzero indices of the array/matrix. `power`(n[, dtype]) This function performs element-wise power. Remove empty space after all non-zero elements. Element-wise rad2deg. `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` Element-wise rint. `set_shape`(shape) `setdiag`(values[, k]) Set diagonal or off-diagonal elements of the array/matrix. Element-wise sign. Element-wise sin. Element-wise sinh. Sort the indices of this array/matrix in place Return a copy of this array/matrix with sorted indices Element-wise sqrt. `sum`([axis, dtype, out]) Sum the array/matrix elements over a given axis. Eliminate duplicate entries by adding them together Element-wise tan. Element-wise tanh. `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 array/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. Element-wise trunc.
 __getitem__ __mul__