NumPy для пользователей MATLAB

ndims(a)

np.ndim(a) или a.ndim

количество измерений массива a

numel(a)

np.size(a) или a.size

количество элементов массива a

size(a)

np.shape(a) или a.shape

«размер» массива a

size(a,n)

a.shape[n-1]

получить количество элементов n-го измерения массива a. (Обратите внимание, что MATLAB использует индексацию с 1, а Python — с 0. См. примечание ИНДЕКСИРОВАНИЕ)

[ 1 2 3; 4 5 6 ]

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

определить двумерный массив 2x3

[ a b; c d ]

np.block([[a, b], [c, d]])

построить матрицу из блоков a, b, c, и d

a(end)

a[-1]

доступ к последнему элементу в векторе MATLAB (1xn или nx1) или одномерном массиве NumPy a (длина n)

a(2,5)

a[1, 4]

доступ к элементу во второй строке, пятом столбце двумерного массива a

a(2,:)

a[1] или a[1, :]

вся вторая строка двумерного массива a

a(1:5,:)

a[0:5] или a[:5] или a[0:5, :]

первые 5 строк двумерного массива a

a(end-4:end,:)

a[-5:]

последние 5 строк двумерного массива a

a(1:3,5:9)

a[0:3, 4:9]

Первые три строки и пятый по девятый столбцы двумерного массива, a.

a([2,4,5],[1,3])

a[np.ix_([1, 3, 4], [0, 2])]

строки 2, 4 и 5 и столбцы 1 и 3. Это позволяет изменять матрицу и не требует обычного среза.

a(3:2:21,:)

a[2:21:2,:]

каждая вторая строка a, начиная с третьей и заканчивая двадцать первой

a(1:2:end,:)

a[::2, :]

каждая вторая строка a, начиная с первой

a(end:-1:1,:) или flipud(a)

a[::-1,:]

a со строками в обратном порядке

a([1:end 1],:)

a[np.r_[:len(a),0]]

a с копией первой строки, добавленной в конец

a.'

a.transpose() или a.T

транспонирование a

a'

a.conj().transpose() или a.conj().T

сопряженное транспонирование a

a * b

a @ b

умножение матриц

a .* b

a * b

умножение по элементам

a./b

a/b

деление по элементам

a.^3

a**3

возведение в степень по элементам

(a > 0.5)

(a > 0.5)

матрица, i,j-й элемент которой равен (a_ij > 0.5). Результат MATLAB — массив логических значений 0 и 1. Результат NumPy — массив булевых значений False и True.

find(a > 0.5)

np.nonzero(a > 0.5)

найти индексы, где (a > 0.5)

a(:,find(v > 0.5))

a[:,np.nonzero(v > 0.5)[0]]

извлечь столбцы a где вектор v > 0.5

a(:,find(v>0.5))

a[:, v.T > 0.5]

извлечь столбцы a где столбец-вектор v > 0.5

a(a<0.5)=0

a[a < 0.5]=0

a с элементами, меньшими 0.5, обнулёнными

a .* (a>0.5)

a * (a > 0.5)

a с элементами, меньшими 0.5, обнулёнными

a(:) = 3

a[:] = 3

установить все значения на одно скалярное значение

y=x

y = x.copy()

NumPy присваивает по ссылке

y=x(2,:)

y = x[1, :].copy()

Срезы NumPy по ссылке

y=x(:)

y = x.flatten()

преобразовать массив в вектор (обратите внимание, что это принудительно создаёт копию). Чтобы получить такой же порядок данных, как в MATLAB, используйте x.flatten('F').

1:10

np.arange(1., 11.) или np.r_[1.:11.] или np.r_[1:10:10j]

создание возрастающего вектора (см. примечание ДИАПАЗОНЫ)

0:9

np.arange(10.) или np.r_[:10.] или np.r_[:9:10j]

создание возрастающего вектора (см. примечание ДИАПАЗОНЫ)

[1:10]'

np.arange(1.,11.)[:, np.newaxis]

создание столбца-вектора

zeros(3,4)

np.zeros((3, 4))

двумерный массив 3x4, заполненный нулями с плавающей точкой двойной точности (64 бита)

zeros(3,4,5)

np.zeros((3, 4, 5))

трёхмерный массив 3x4x5, заполненный нулями с плавающей точкой двойной точности (64 бита)

ones(3,4)

np.ones((3, 4))

двумерный массив 3x4, заполненный единицами с плавающей точкой двойной точности (64 бита)

eye(3)

np.eye(3)

единичная матрица 3x3

diag(a)

np.diag(a)

возвращает вектор диагональных элементов двумерного массива, a

diag(v,0)

np.diag(v, 0)

возвращает квадратную диагональную матрицу, ненулевые значения которой — элементы вектора, v

rng(42,'twister')
rand(3,4)

from numpy.random import default_rng
rng = default_rng(42)
rng.random(3, 4)

или более старая версия: random.rand((3, 4))

сгенерировать случайный массив 3x4 с генератором случайных чисел по умолчанию и seed = 42

linspace(1,3,4)

np.linspace(1,3,4)

4 равномерно распределённых образца между 1 и 3 включительно

[x,y]=meshgrid(0:8,0:5)

np.mgrid[0:9.,0:6.] или np.meshgrid(r_[0:9.],r_[0:6.])

два двумерных массива: один с x-значениями, другой с y-значениями

ogrid[0:9.,0:6.] или np.ix_(np.r_[0:9.],np.r_[0:6.]

наиболее эффективный способ вычисления функций на сетке

[x,y]=meshgrid([1,2,4],[2,4,5])

np.meshgrid([1,2,4],[2,4,5])

np.ix_([1,2,4],[2,4,5])

наиболее эффективный способ вычисления функций на сетке

repmat(a, m, n)

np.tile(a, (m, n))

создать m на n копий a

[a b]

np.concatenate((a,b),1) или np.hstack((a,b)) или np.column_stack((a,b)) или np.c_[a,b]

склеить столбцы a и b

[a; b]

np.concatenate((a,b)) или np.vstack((a,b)) или np.r_[a,b]

склеить строки a и b

max(max(a))

a.max() или np.nanmax(a)

максимальный элемент a (с ndims(a)<=2 для MATLAB, если есть NaN, nanmax проигнорирует их и вернёт наибольшее значение)

max(a)

a.max(0)

максимальный элемент каждого столбца массива a

max(a,[],2)

a.max(1)

максимальный элемент каждой строки массива a

max(a,b)

np.maximum(a, b)

сравнивает a и b поэлементно и возвращает максимальное значение из каждой пары

norm(v)

np.sqrt(v @ v) или np.linalg.norm(v)

норма L2 вектора v

a & b

logical_and(a,b)

поэлементный оператор AND (ufunc NumPy) См. примечание LOGICOPS

a | b

np.logical_or(a,b)

поэлементный оператор OR (ufunc NumPy) См. примечание LOGICOPS

bitand(a,b)

a & b

оператор поразрядного И (встроенный в Python и ufunc NumPy)

bitor(a,b)

a | b

оператор поразрядного ИЛИ (встроенный в Python и ufunc NumPy)

inv(a)

linalg.inv(a)

обратная матрица квадратной 2D матрицы a

pinv(a)

linalg.pinv(a)

псевдообратная 2D матрица a

rank(a)

np.linalg.matrix_rank(a)

ранг матрицы 2D массива a

a\b

linalg.solve(a, b) если a квадратная; linalg.lstsq(a, b) в противном случае

решение уравнения a x = b для x

b/a

Решить a.T x.T = b.T вместо

решение уравнения x a = b для x

[U,S,V]=svd(a)

U, S, Vh = linalg.svd(a); V = Vh.T

разложение по сингулярным значениям a

chol(a)

linalg.cholesky(a)

разложение Холецкого 2D массива

[V,D]=eig(a)

D,V = linalg.eig(a)

собственные значения \(\lambda\) и собственные векторы \(v\) a, где \(\mathbf{a} v = \lambda v\)

[V,D]=eig(a,b)

D,V = linalg.eig(a, b)

собственные значения \(\lambda\) и собственные векторы \(v\) a, b где \(\mathbf{a} v = \lambda \mathbf{b} v\)

[V,D]=eigs(a,3)

D,V = eigs(a, k=3)

найти k=3 наибольшие собственные значения и собственные векторы 2D массива, a

[Q,R]=qr(a,0)

Q,R = linalg.qr(a)

QR-разложение

[L,U,P]=lu(a) где a==P'*L*U

P,L,U = linalg.lu(a) где a == P@L@U

LU-разложение с частичным выбором ведущего элемента (примечание: P(MATLAB) == transpose(P(NumPy)))

conjgrad

cg

решение методом сопряжённых градиентов

fft(a)

np.fft.fft(a)

преобразование Фурье a

ifft(a)

np.fft.ifft(a)

обратное преобразование Фурье a

sort(a)

np.sort(a) или a.sort(axis=0)

сортировка каждой колонки 2D массива, a

sort(a, 2)

np.sort(a, axis=1) или a.sort(axis=1)

сортировка каждой строки 2D массива, a

[b,I]=sortrows(a,1)

I = np.argsort(a[:, 0]); b = a[I,:]

сохранить массив a как массив b со строками, отсортированными по первой колонке

x = Z\y

x = linalg.lstsq(Z, y)

выполнить линейную регрессию вида \(\mathbf{Zx}=\mathbf{y}\)

decimate(x, q)

signal.resample(x, np.ceil(len(x)/q))

децимация с применением фильтра нижних частот

unique(a)

np.unique(a)

вектор уникальных значений в массиве a

squeeze(a)

a.squeeze()

удаление одноэлементных размерностей массива a. Обратите внимание, что MATLAB всегда возвращает массивы 2D или выше, а NumPy — 0D или выше