SciPy Cheat Sheet: Linear Algebra in Python

By now, you will have already learned that NumPy, one of the fundamental packages for scientific computing, forms at least for a part the fundament of other important packages that you might use used for data manipulation and machine learning with Python. One of those packages is SciPy, another one of the core packages for scientific computing in Python that provides mathematical algorithms and convenience functions built on the NumPy extension of Python. 

You might now wonder why this library might come in handy for data science. 

Well, SciPy has many modules that will help you to understand some of the basic components that you need to master when you're learning data science, namely, math, stats and machine learning. You can find out what other things you need to tackle to learn data science here. You'll see that for statistics, for example, a module like scipy.stats, etc. will definitely be of interest to you.

The other topic that was mentioned was machine learning: here, the scipy.linalg and scipy.sparse modules will offer everything that you're looking for to understand machine learning concepts such as eigenvalues, regression, and matrix multiplication...

But, what is maybe the most obvious is that most machine learning techniques deal with high-dimensional data and that data is often represented as matrices. What's more, you'll need to understand how to manipulate these matrices.  

That is why DataCamp has made a SciPy cheat sheet that will help you to master linear algebra with Python. 

Take a look by clicking on the button below:

You'll see that this SciPy cheat sheet covers the basics of linear algebra that you need to get started: it provides a brief explanation of what the library has to offer and how you can use it to interact with NumPy, and goes on to summarize topics in linear algebra, such as matrix creation, matrix functions, basic routines that you can perform with matrices, and matrix decompositions from scipy.linalg. Sparse matrices are also included, with their own routines, functions, and decompositions from the scipy.sparse module. 

(Above is the printable version of this cheat sheet)

help(scipy.linalg.diagsvd)

import numpy as np

a : np.array([1,2,3])

b : np.array([(1+5j,2j,3j), (4j,5j,6j)])

c : np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]])

np.mgrid[0:5,0:5]

np.ogrid[0:2,0:2]

np.r_[3,[0]*5,-1:1:10j]

np.c_[b,c]

np.transpose(b)

b.flatten()

np.hstack((b,c))

np.vstack((a,b))

np.hsplit(c,2)

np.vpslit(d,2)

from numpy import poly1d

p : poly1d([3,4,5])

def myfunc(a):      
   if a ‹ 0:  
      return a*2      
   else:      
      return a/2

np.vectorize(myfunc)

np.real(b)

np.imag(b)

np.real_if_close(c,tol:1000)

np.cast['f'](np.pi)

np.angle(b,deg:True)

g : np.linspace(0,np.pi,num:5)

g [3:] +: np.pi

np.unwrap(g)

np.logspace(0,10,3)

np.select([c<4],[c*2])

misc.factorial(a)

misc.comb(10,3,exact:True)

misc.central_diff_weights(3)

misc.derivative(myfunc,1.0)

from scipy import linalg, sparse

A : np.matrix(np.random.random((2,2)))

B : np.asmatrix(b)

C : np.mat(np.random.random((10,5)))

D : np.mat([[3,4], [5,6]])

A.I

linalg.inv(A)

A.T

A.H

np.trace(A)

linalg.norm(A)

linalg.norm(A,1)

linalg.norm(A,np.inf)

np.linalg.matrix_rank(C)

linalg.det(A)

linalg.solve(A,b)

E : np.mat(a).T

linalg.lstsq(F,E)

linalg.pinv(C)

linalg.pinv2(C)

F : np.eye(3, k:1)

G : np.mat(np.identity(2))

C[C > 0.5] : 0

H : sparse.csr_matrix(C)

I : sparse.csc_matrix(D)

J : sparse.dok_matrix(A)

E.todense()

sparse.isspmatrix_csc(A)

sparse.linalg.inv(I)

sparse.linalg.norm(I)

sparse.linalg.spsolve(H,I)

la, v : sparse.linalg.eigs(F,1)

sparse.linalg.svds(H, 2)

sparse.linalg.expm(I)

np.add(A,D)

np.subtract(A,D)

np.divide(A,D)

A @ D

np.multiply(D,A)

np.dot(A,D)

np.vdot(A,D)

np.inner(A,D)

np.outer(A,D)

np.tensordot(A,D)

np.kron(A,D)

linalg.expm(A)

linalg.expm2(A)

linalg.expm3(D)

linalg.logm(A)

linalg.sinm(D)

linalg.cosm(D)

linalg.tanm(A)

linalg.sinhm(D)

linalg.coshm(D)

linalg.tanhm(A)

np.signm(A)

linalg.sqrtm(A)

linalg.funm(A, lambda x: x*x)

la, v : linalg.eig(A)

l1, l2 : la

v[:,0]

v[:,1]

linalg.eigvals(A)

U,s,Vh : linalg.svd(B)

M,N : B.shape

Sig : linalg.diagsvd(s,M,N)

P,L,U : linalg.lu(C)

np.info(np.matrix)