NumPy/SciPy Cheat Sheet

numpy.matrix(arg, dtype=None)  Reference

arg:
   The data to construct the matrix from, given as
     (1) a standard Python array; or
     (2) a string with columns separated by commas or spaces and rows separated by semicolons.
dtype (str, optional):
   The type of the entries in the matrix (e.g., 'integer', 'float', 'string', etc.).


Examples:

>>> numpy.matrix("1 2; 3 4")
[[1 2]
 [3 4]]

>>> numpy.matrix([[1, 2], [3, 4]], dtype='float')
[[1.0 2.0]
 [3.0 4.0]]

numpy.array(arg, dtype=None, ndmin=0)  Reference

arg:
   The data to construct the matrix from, given as:
      (1) a standard array; or
      (2) a function that returns an array.
dtype (str, optional):
   The type of the entries in the matrix ('integer', 'float', 'string', etc.).
ndmin (int, optional):
   The minimum number of dimensions that the array should have.


Examples:

>>> numpy.array([[1, 2], [3, 4]])
[[1 2]
 [3 4]]

>>> numpy.array([[1, 2], [3, 4]], dtype='float')
[[1.0 2.0]
 [3.0 4.0]]

>>> numpy.array([[1, 2], [3, 4]], ndmin=3)
[[[1 2]
  [3 4]]]

scipy.sparse.csr_matrix(arg, shape=None, dtype=None)  Reference
scipy.sparse.csc_matrix(arg, shape=None, dtype=None)  Reference

arg:
   The data to create the CSR matrix from, given as 
     * a dense matrix; or
     * another sparse matrix; or
     * a tuple (m, n), to construct an empty matrix with shape (n, m); or
     * a tuple (data, (rows, cols), to construct a matrix A where A[rows[k], cols[k]] = data[k]; or
     * a tuple (data, indices, indptr)
shape (int or sequence of ints):
   The dimensions of the matrix to create.
dtype (str, optional):
   The type of the entries in the matrix ('integer', 'float', 'string', etc.).


Examples:

>>> scipy.sparse.csr_matrix([[1, 2, 3], [0, 0, 1], [0, 1, 3]])
[[1 2 3]
 [0 0 1]
 [0 1 3]]  # (transformed to a dense matrix for visualization).

>>> scipy.sparse.csc_matrix([[1, 2, 3], [0, 0, 1], [0, 1, 3]])
[[1 2 3]
 [0 0 1]
 [0 1 3]]  # (transformed to a dense matrix for visualization).

>>> values = [1, 2, 3]
>>> rows   = [0, 0, 1]
>>> cols   = [0, 1, 3]
>>> scipy.sparse.csr_matrix((values, (rows, columns)), shape=[5, 5], dtype=int)
[[1 2 0 0]
 [0 0 0 3]
 [0 0 0 0]
 [0 0 0 0]]  # (transformed to a dense matrix for visualization).

>>> values = [1, 2, 3]
>>> rows   = [0, 0, 1]
>>> cols   = [0, 1, 3]
>>> scipy.sparse.csc_matrix((values, (rows, columns)), shape=[5, 5], dtype=int)
[[1 2 0 0]
 [0 0 0 3]
 [0 0 0 0]
 [0 0 0 0]]  # (transformed to a dense matrix for visualization).

numpy.empty(shape, dtype=float)  Reference

shape (int or sequence of ints):
   The dimensions of the array to create.
dtype (str, optional):
   The type of the entries in the matrix ('integer', 'float', 'string', etc.).


Examples:

>>> numpy.empty(3)
[6.95052181e-310 1.74512682e-316 1.58101007e-322]

>>> numpy.empty([3, 2], dtype='int')
[[140045355821992 140045355821992]
 [140045136216840 140045136244784]
 [140045125643544 140045153116544]]

numpy.zeros(shape, dtype=float)  Reference

shape (int or sequence of ints):
   The dimensions of the array to create.
dtype (str, optional):
   The type of the entries in the matrix ('integer', 'float', 'string', etc.).


Examples

>>> numpy.zeros(3)
[0.0, 0.0, 0.0]

>>> numpy.zeros([3, 2], dtype='int')
[[0 0]
 [0 0]
 [0 0]]

numpy.ones(shape, dtype=float)  Reference

shape (int or sequence of ints):
   The dimensions of the array to create.
dtype (str, optional):
   The type of the entries in the matrix ('integer', 'float', 'string', etc.).


Examples:

>>> numpy.ones(3)
[1.0, 1.0, 1.0]

>>> numpy.ones([3, 2], dtype='int')
[[1 1]
 [1 1]
 [1 1]]

numpy.diag(arg, k=0)  Reference

arg (1-dim array):
   The entries of the diagonal.
k (int, optional):
   The diagonal in question. Use k > 0 for diagonals above the main diagonal, and k < 0 for diagonals below the main diagonal. 


Examples:

>>> numpy.diag([1, 2, 3])
[[1 0 0]
 [0 2 0]
 [0 0 3]]

>>> numpy.diag([1, 2, 3], k=1)
[[0 1 0 0]
 [0 0 2 0]
 [0 0 0 3]
 [0 0 0 0]]

>>> numpy.diag([1, 2, 3], k=-1)
[[0 0 0 0]
 [1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]]

scipy.sparse.diags(diagonals, offsets=0, dtype=None)  Reference

diagonals (sequence of arrays):
   The entries of the matrix diagonals.
offsets (sequence of ints or int, optional):
   The diagonals in question. k = 0 is the main diagonal; k > 0 is the k-th upper diagonal; k < 0 is the k-th lower diagonal
dtype (str, optional):
   The type of the entries in the matrix ('integer', 'float', 'string', etc.).


Examples:

>>> scipy.sparse.diags([1, 2, 3])
[[1.0 0.0 0.0]
 [0.0 2.0 0.0]
 [0.0 0.0 3.0]]  # (transformed to a dense matrix for visualization).

>>> scipy.sparse.diags([[1, 2, 3], [4, 5, 6]], offsets=[0, 1])
[[1.0 4.0 0.0]
 [0.0 2.0 5.0]
 [0.0 0.0 3.0]]  # (transformed to a dense matrix for visualization).

numpy.identity(n, dtype=float)  Reference

n (int):
   The dimension of the array to create (the output is a n x n array).
dtype (str, optional):
   The type of the entries in the matrix ('integer', 'float', 'string', etc.).


Examples:

>>> numpy.identity(3)
[[1.0, 0.0, 0.0]
 [0.0, 1.0, 0.0]
 [0.0, 0.0, 1.0]]

>>> numpy.identity(3, dtype=int)
[[1, 0, 0]
 [0, 1, 0]
 [0, 0, 1]]

scipy.sparse.identity(n, dtype=float, format="csr")  Reference

n (int):
   The dimension of the array to create.
dtype (str, optional):
   The type of the entries in the matrix ('integer', 'float', 'string', etc.).
format (str, optional)
   The sparse format of the array, e.g. "csr" or "csc".


Examples:

>>> scipy.sparse.identity(3)
[[1.0, 0.0, 0.0]
 [0.0, 1.0, 0.0]
 [0.0, 0.0, 1.0]]  # (transformed to a dense matrix for visualization).

>>> scipy.sparse.identity(3, dtype=int)
[[1, 0, 0]
 [0, 1, 0]
 [0, 0, 1]]  # (transformed to a dense matrix for visualization).

numpy.triu(arg, k=0)  # Zero entries in the upper triangle of an array.  Reference
numpy.tril(arg, k=0)  # Zero entries in the lower triangle of an array.  Reference

arg (array):
   The original array.
k (int, optional):
   Diagonal above which to zero entries. k = 0 is the main diagonal, k < 0 is below it and k > 0 is above.


Examples:

>>> numpy.triu([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
[[1 2 3]
 [0 5 6]
 [0 0 9]]

>>> numpy.triu([[1, 2, 3], [4, 5, 6], [7, 8, 9]], k=1)
[[0 2 3]
 [0 0 6]
 [0 0 0]]

>>> numpy.tril([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
[[1 0 0]
 [4 5 0]
 [7 8 9]]

>>> numpy.tril([[1, 2, 3], [4, 5, 6], [7, 8, 9]], k=-1)
[[0 0 0]
 [4 0 0]
 [7 8 0]]

scipy.sparse.triu(arg, k=0, format="csr")  # Zero entries in the upper triangle of an array.  Reference
scipy.sparse.tril(arg, k=0, format="csr")  # Zero entries in the lower triangle of an array.  Reference

arg (array):
   The original array.
k (int, optional):
   Diagonal above which to zero entries. k = 0 is the main diagonal, k < 0 is below it and k > 0 is above.
format (str, optional)
   The sparse format of the array, e.g. "csr" or "csc".


Examples:

>>> scipy.sparse.triu([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
[[1 2 3]
 [0 5 6]
 [0 0 9]]  # (transformed to a dense matrix for visualization).

>>> scipy.sparse.triu([[1, 2, 3], [4, 5, 6], [7, 8, 9]], k=1)
[[0 2 3]
 [0 0 6]
 [0 0 0]]  # (transformed to a dense matrix for visualization).

>>> scipy.sparse.tril([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
[[1 0 0]
 [4 5 0]
 [7 8 9]]  # (transformed to a dense matrix for visualization).

>>> scipy.sparse.tril([[1, 2, 3], [4, 5, 6], [7, 8, 9]], k=-1)
[[0 0 0]
 [4 0 0]
 [7 8 0]]  # (transformed to a dense matrix for visualization).

numpy.tril(arg, k=0)  # Zero entries in the lower triangle of an array.  Reference
A + c

A (matrix or array):
   The matrix/array.
c (constant):
   The constant.

Examples:

>>> A = np.matrix([[2, 1], [3, 5]], dtype=float)
>>> A + 4
[[6 5]
 [7 9]]

A * c

A (matrix or array):
   The matrix/array.
c (constant):
   The constant.

Examples:

>>> A = np.matrix([[2, 1], [3, 5]], dtype=float)
>>> A * 4
[[8 4]
 [12 20]]

A * c

A (sparse matrix):
   The matrix.
c (constant):
   The constant.

Examples:

>>> A = csr_matrix([[1, 0], [0, 1], [3, 2]], dtype=float)
>>> A * 4
[[4 0]
 [0 4]
 [12 8]] # (transformed to a dense matrix for visualization).

A * B
A.dot(B)   Reference

A (dense matrix or sparse matrix):
   The first matrix/array.
B (dense matrix or sparse matrix):
   The second matrix/array.


Examples:

>>> A = numpy.array([[1, 2], [3, 4]])
>>> M1_sparse = csr_matrix([[1, 0], [0, 1], [3, 2]], dtype=float)
>>> M1_dense = A_sparse.todense()
>>> M2_dense = numpy.matrix([[2, 1], [3, 4]], dtype=float)
>>> M2_sparse = csr_matrix(B_dense)


## Dense array with dense array.
>>> A * A  # no normal, but element-wise matrix multiplication.
[[ 1  4]
 [ 9 16]]

>>> A.dot(A)  # normal matrix multiplication.
[[ 7 10]
 [15 22]]


## Dense matrix with dense matrix.
>>> M1_dense * M2_dense  # normal matrix multiplication.
[[  2.,   1.],
 [  3.,   4.],
 [ 12.,  11.]]  # result is a dense matrix

>>> M1_dense.dot(M2_dense)  # same as M1_dense * M2_dense
[[  2.,   1.],
 [  3.,   4.],
 [ 12.,  11.]]  # result is a dense matrix


## Sparse matrix with sparse matrix.
>>> X = M1_sparse * M2_sparse  # normal matrix multiplication.
>>> X.todense()  
[[  2.,   1.],
 [  3.,   4.],
 [ 12.,  11.]]  # result is a sparse matrix.

>>> X = M1_sparse.dot(M2_sparse)  # same as M1_sparse * M2_sparse
>>> X.todense()  
[[  2.,   1.],
 [  3.,   4.],
 [ 12.,  11.]]  # result is a sparse matrix.


## Sparse matrix with dense matrix.
>>> M1_sparse * M2_dense  # normal matrix multiplication.
[[  2.,   1.],
 [  3.,   4.],
 [ 12.,  11.]]  # result is a dense matrix.

>>> M1_sparse.dot(M2_dense)  #  same as M1_sparse * M2_dense
[[  2.,   1.],
 [  3.,   4.],
 [ 12.,  11.]]  # result is a dense matrix.


## Dense matrix with sparse matrix.
>>> M1_dense * M2_sparse  # normal matrix multiplication.
[[  2.,   1.],
 [  3.,   4.],
 [ 12.,  11.]]  # result is a dense matrix.

>>> M1_dense.dot(M2_sparse)  # computes M1_dense.dot(np.array(M2_sparse)) 
matrix([[ <2x2 sparse matrix of type '<class 'numpy.float64'>'
        with 4 stored elements in Compressed Sparse Row format>,
         <2x2 sparse matrix of type '<class 'numpy.float64'>'
        with 4 stored elements in Compressed Sparse Row format>],
        [ <2x2 sparse matrix of type '<class 'numpy.float64'>'
        with 4 stored elements in Compressed Sparse Row format>,
         <2x2 sparse matrix of type '<class 'numpy.float64'>'
        with 4 stored elements in Compressed Sparse Row format>],
        [ <2x2 sparse matrix of type '<class 'numpy.float64'>'
        with 4 stored elements in Compressed Sparse Row format>,
         <2x2 sparse matrix of type '<class 'numpy.float64'>'
        with 4 stored elements in Compressed Sparse Row format>]], dtype=object)

numpy.round(A, decimals)  Reference

A (dense matrix or sparse matrix):
   The matrix/array.
decimal (int, optional):
   Number of decimal places to round to (default: 0).


Examples:

>>> A_dense = np.array([[1.11, 2.22, 3.33], [4.44, 5.55, 6.66]])
>>> A_sparse = scipy.sparse.csr_matrix(A_dense)

>>> np.round(A_dense)
[[1. 2. 3.]
 [4. 6. 7.]]

>>> np.round(A_dense, 1)
[[1.1 2.2 3.3]
 [4.4 5.6 6.7]]

>>> np.round(A_sparse, 1)
(0, 0)  1.1
(0, 1)  2.2
(0, 2)  3.3
(1, 0)  4.4
(1, 1)  5.6
(1, 2)  6.7

numpy.min(A, axis)  Reference

A (dense matrix or sparse matrix):
   The matrix/array.
axis (int or tuple of ints, optional):
   Axis or axes along which to operate. By default, flattened input is used.


Examples:

>>> A_dense = np.array([[5, 0, 1], [4, 3, 2]])
>>> A_sparse = scipy.sparse.csr_matrix(A_dense)

>>> np.min(A_dense)
0

>>> np.min(A_dense, axis=0)
[4, 0, 1]

>>> np.min(A_dense, axis=1)
[0, 2]

>>> np.min(A_sparse, axis=1)
(1, 0)  2

numpy.argmin(A, axis)  Reference

A (dense matrix or sparse matrix):
   The matrix/array.
axis (int or tuple of ints, optional):
   Axis or axes along which to operate. By default, flattened input is used.


Examples:

>>> A_dense = np.array([[5, 0, 1], [4, 3, 2]])
>>> A_sparse = scipy.sparse.csr_matrix(A_dense)

>>> np.argmin(A_dense)
1

>>> np.argmin(A_dense, axis=0)
[1, 0, 0]

>>> np.argmin(A_dense, axis=1)
[1, 2]

>>> np.argmin(A_sparse, axis=1)
[[1]
 [2]]

numpy.argsort(A, axis)  Reference

A (dense matrix):
   The matrix/array.
axis (int or tuple of ints, optional):
   Axis or axes along which to operate. By default, flattened input is used.


Examples:

>>> A_dense = np.array([[0, 4, 0], [4, 3, 2]])
>>> A_sparse = scipy.sparse.csr_matrix(A_dense)

>>> np.argsort(A_dense)
[[0 2 1]
 [2 1 0]]

>>> np.argsort(A_dense, axis=0)
[[0 1 0]
 [1 0 1]]

>>> np.argsort(A_dense, axis=1)
[[0 2 1]
 [2 1 0]]

numpy.where(condition[, A, B])  Reference

condition (bool):
   When True, yield A, otherwise yield B.
A, B (array_like, optional):
   Values from which to choose.


Examples:

>>> A = numpy.array([[5, 4, 3], [2, 1, 0]])
>>> B = numpy.array([[0, 1, 2], [3, 4, 5]])

>>> np.where(x > 3, x, y)
[[5 4 2]
 [3 4 5]]