MATLAB–Python cheatsheet

Dependencies and Setup

In the Python code we assume that you have already run import numpy as np

Creating Vectors

Operation

MATLAB

Python

Row vector: size (1, n)

 
A = [1 2 3]

A = np.array([1, 2, 3]).reshape(1, 3)

Column vector: size (n, 1)

 
A = [1; 2; 3]

A = np.array([1, 2, 3]).reshape(3, 1)

1d array: size (n, )

Not possible

 
A = np.array([1, 2, 3])

Integers from j to n with step size k

 
A = j:k:n

A = np.arange(j, n+1, k)

Linearly spaced vector of k points

 
A = linspace(1, 5, k)

A = np.linspace(1, 5, k)

Creating Matrices

Operation

MATLAB

Python

Create a matrix

 
A = [1 2; 3 4]

A = np.array([[1, 2], [3, 4]])

2 x 2 matrix of zeros

 
A = zeros(2, 2)

A = np.zeros((2, 2))

2 x 2 matrix of ones

 
A = ones(2, 2)

A = np.ones((2, 2))

2 x 2 identity matrix

 
A = eye(2, 2)

A = np.eye(2)

Diagonal matrix

 
A = diag([1 2 3])

A = np.diag([1, 2, 3])

Uniform random numbers

 
A = rand(2, 2)

A = np.random.rand(2, 2)

Normal random numbers

 
A = randn(2, 2)

A = np.random.randn(2, 2)

Sparse Matrices

 
A = sparse(2, 2)
A(1, 2) = 4
A(2, 2) = 1

from scipy.sparse import coo_matrix

A = coo_matrix(([4, 1],
                ([0, 1], [1, 1])),
                shape=(2, 2))

Tridiagonal Matrices

 
A = [1 2 3 NaN;
     4 5 6 7;
     NaN 8 9 0]
spdiags(A',[-1 0 1], 4, 4)

import sp.sparse as sp
diagonals = [[4, 5, 6, 7], [1, 2, 3], [8, 9, 10]]
sp.diags(diagonals, [0, -1, 2]).toarray()

Manipulating Vectors and Matrices

Operation

MATLAB

Python

Transpose

 
A.'

A.T

Complex conjugate transpose (Adjoint)

 
A'

A.conj()

Concatenate horizontally

 
A = [[1 2] [1 2]]

or

A = horzcat([1 2], [1 2])

B = np.array([1, 2])
A = np.hstack((B, B))

Concatenate vertically

 
A = [[1 2]; [1 2]]

or

A = vertcat([1 2], [1 2])

B = np.array([1, 2])
A = np.vstack((B, B))

Reshape (to 5 rows, 2 columns)

 
A = reshape(1:10, 5, 2)

A = A.reshape(5, 2)

Convert matrix to vector

 
A(:)

A = A.flatten()

Flip left/right

 
fliplr(A)

np.fliplr(A)

Flip up/down

 
flipud(A)

np.flipud(A)

Repeat matrix (3 times in the row dimension, 4 times in the column dimension)

 
repmat(A, 3, 4)

np.tile(A, (4, 3))

Preallocating/Similar

 
x = rand(10)
y = zeros(size(x, 1), size(x, 2))

N/A similar type

 
x = np.random.rand(3, 3)
y = np.empty_like(x)

# new dims
y = np.empty((2, 3))

Broadcast a function over a collection/matrix/vector

 
f = @(x) x.^2
g = @(x, y) x + 2 + y.^2
x = 1:10
y = 2:11
f(x)
g(x, y)

Functions broadcast directly

 
def f(x):
    return x**2
def g(x, y):
    return x + 2 + y**2
x = np.arange(1, 10, 1)
y = np.arange(2, 11, 1)
f(x)
g(x, y)

Functions broadcast directly

Accessing Vector/Matrix Elements

Operation

MATLAB

Python

Access one element

 
A(2, 2)

A[1, 1]

Access specific rows

 
A(1:4, :)

A[0:4, :]

Access specific columns

 
A(:, 1:4)

A[:, 0:4]

Remove a row

 
A([1 2 4], :)

A[[0, 1, 3], :]

Diagonals of matrix

 
diag(A)

np.diag(A)

Get dimensions of matrix

 
[nrow ncol] = size(A)

nrow, ncol = np.shape(A)

Mathematical Operations

Operation

MATLAB

Python

Dot product

 
dot(A, B)

np.dot(A, B) or A @ B

Matrix multiplication

 
A * B

A @ B

Inplace matrix multiplication

Not possible

 
x = np.array([1, 2]).reshape(2, 1)
A = np.array(([1, 2], [3, 4]))
y = np.empty_like(x)
np.matmul(A, x, y)

Element-wise multiplication

 
A .* B

A * B

Matrix to a power

 
A^2

np.linalg.matrix_power(A, 2)

Matrix to a power, elementwise

 
A.^2

A**2

Inverse

 
inv(A)

or

A^(-1)

np.linalg.inv(A)

Determinant

 
det(A)

np.linalg.det(A)

Eigenvalues and eigenvectors

 
[vec, val] = eig(A)

val, vec = np.linalg.eig(A)

Euclidean norm

 
norm(A)

np.linalg.norm(A)

Solve linear system Ax=b (when A is square)

 
A\b

np.linalg.solve(A, b)

Solve least squares problem Ax=b (when A is rectangular)

 
A\b

np.linalg.lstsq(A, b)

Sum / max / min

Operation

MATLAB

Python

Sum / max / min of each column

 
sum(A, 1)
max(A, [], 1)
min(A, [], 1)

sum(A, 0)
np.amax(A, 0)
np.amin(A, 0)

Sum / max / min of each row

 
sum(A, 2)
max(A, [], 2)
min(A, [], 2)

sum(A, 1)
np.amax(A, 1)
np.amin(A, 1)

Sum / max / min of entire matrix

 
sum(A(:))
max(A(:))
min(A(:))

np.sum(A)
np.amax(A)
np.amin(A)

Cumulative sum / max / min by row

 
cumsum(A, 1)
cummax(A, 1)
cummin(A, 1)

np.cumsum(A, 0)
np.maximum.accumulate(A, 0)
np.minimum.accumulate(A, 0)

Cumulative sum / max / min by column

 
cumsum(A, 2)
cummax(A, 2)
cummin(A, 2)

np.cumsum(A, 1)
np.maximum.accumulate(A, 1)
np.minimum.accumulate(A, 1)

Programming

Operation

MATLAB

Python

Comment one line

 
% This is a comment

# This is a comment

Comment block

 
%{
Comment block
%}

# Block
# comment
# following PEP8

For loop

 
for i = 1:N
   % do something
end

for i in range(n):
    # do something

While loop

 
while i <= N
   % do something
end

while i <= N:
    # do something

If

 
if i <= N
   % do something
end

if i <= N:
   # do something

If / else

 
if i <= N
   % do something
else
   % do something else
end

if i <= N:
    # do something
else:
    # so something else

Print text and variable

 
x = 10
fprintf('x = %d \n', x)

x = 10
print(f'x = {x}')

Function: anonymous

 
f = @(x) x^2

f = lambda x: x**2

Function

 
function out  = f(x)
   out = x^2
end

def f(x):
    return x**2

Tuples

 
t = {1 2.0 "test"}
t{1}

Can use cells but watch performance

 
t = (1, 2.0, "test")
t[0]

Named Tuples/ Anonymous Structures

 
m.x = 1
m.y = 2

m.x

from collections import namedtuple

mdef = namedtuple('m', 'x y')
m = mdef(1, 2)

m.x

Closures

 
a = 2.0
f = @(x) a + x
f(1.0)

a = 2.0
def f(x):
    return a + x
f(1.0)

Inplace Modification

No consistent or simple syntax to achieve this

 
def f(x):
    x **=2
    return

x = np.random.rand(10)
f(x)