Каковы различия между массивами numpy и матрицами? Какой из них мне использовать?

каковы преимущества и недостатки каждого?

из того, что я видел, либо один может работать в качестве замены для другого, если нужно, так что я должен беспокоиться об использовании обоих или я должен придерживаться только одного из них?

повлияет ли стиль программы на мой выбор? Я занимаюсь машинным обучением с помощью numpy, поэтому действительно много матриц, но также много векторов (массивов).

4 ответов


матрицы Numpy строго 2-мерные, в то время как массивы numpy (ndarrays) являются N-мерный. Объекты Matrix являются подклассом ndarray, поэтому они наследуют все атрибуты и методы ndarrays.

главным преимуществом матриц numpy является то, что они обеспечивают удобную нотацию для умножения матрицы: если A и b-матрицы, то a*b-их матрица товар.

import numpy as np

a=np.mat('4 3; 2 1')
b=np.mat('1 2; 3 4')
print(a)
# [[4 3]
#  [2 1]]
print(b)
# [[1 2]
#  [3 4]]
print(a*b)
# [[13 20]
#  [ 5  8]]

С другой стороны, начиная с Python 3.5, NumPy поддерживает матрицу infix умножение с помощью @ оператор, поэтому вы можете достичь того же удобства умножения матрицы с ndarrays в Python >= 3.5.

import numpy as np

a=np.array([[4, 3], [2, 1]])
b=np.array([[1, 2], [3, 4]])
print(a@b)
# [[13 20]
#  [ 5  8]]

и матричные объекты, и ndarrays имеют .T чтобы вернуть транспонирование, но матрицу объекты также имеют .H для конъюгата транспонировать, и .I для обратной.

напротив, массивы numpy последовательно соблюдают правило, что операции прикладной элемент-мудрый (за исключением нового @ оператор). Таким образом, если a и b являются массивами numpy, то a*b массив формируется путем умножения компонентов по элементам:

c=np.array([[4, 3], [2, 1]])
d=np.array([[1, 2], [3, 4]])
print(c*d)
# [[4 6]
#  [6 4]]

чтобы получить результат умножения матрицы, вы используете np.dot (или @ в Python >= 3.5, как показано выше):

print(np.dot(c,d))
# [[13 20]
#  [ 5  8]]

на ** оператор также ведет себя по-разному:

print(a**2)
# [[22 15]
#  [10  7]]
print(c**2)
# [[16  9]
#  [ 4  1]]

С a - это матрица, a**2 возвращает матрицу продукта a*a. С c - это ndarray, c**2 возвращает ndarray с квадратом каждого компонента элемент-мудрый.

существуют и другие технические различия между матричными объектами и ndarrays (с НП.ravel, выбор элемента и поведение последовательности).

главным преимуществом массивов numpy является то, что они более общие, чем 2-мерных матриц. Что происходит, когда вам нужен трехмерный массив? Затем вы должны использовать ndarray, а не матрицы. Таким образом, обучение использованию матрицы объекты работы-вы необходимо изучить операции с объектами matrix и операции ndarray.

написание программы, которая использует как матрицы, так и массивы, затрудняет вашу жизнь потому что вы должны отслеживать, какой тип объекта ваши переменные, чтобы умножение возвращает то, чего вы не ожидаете.

напротив, если вы придерживаетесь исключительно ndarrays, то вы можете сделать все матричные объекты могут делать и многое другое, за исключением слегка отличающихся функции/записи.

если вы не готов отказаться от визуальной привлекательности включает в себя матрицу продукта нотация (которая может быть достигнута почти так же элегантно с ndarrays в Python >= 3.5), то я думаю, что массивы NumPy-это определенно путь.

PS. Конечно, вам действительно не нужно выбирать одно за счет другого, с np.asmatrix и np.asarray позволяет конвертировать один в другой (as пока массив 2-мерный).


существует краткий обзор различий между NumPy arrays vs NumPy matrixes здесь.


Scipy.org рекомендует использовать массивы:

*'array' или 'matrix'? Что я должен использовать? - Короткий ответ:

использовать массивы.

  • Они являются стандартным типом вектор / матрица / тензор numpy. Многие функции numpy возвращают массивы, а не матрицы.

  • существует четкое различие между операциями по элементам и операции линейной алгебры.

  • вы можете иметь стандартные векторы или векторы строк/столбцов, если хотите.

единственным недостатком использования тип массива является то, что вам придется использовать dot вместо * умножить (уменьшить) два тензора (скалярное произведение, умножение вектора матрицы etc.).


просто добавить один случай в список unutbu.

одним из самых больших практических различий для меня numpy ndarrays по сравнению с матрицами numpy или матричными языками, такими как matlab, является то, что размерность не сохраняется в операциях сокращения. Матрицы всегда 2d, в то время как среднее значение массива, например, имеет одно измерение меньше.

например, унизить строки матрицы или массива:

с матрицей

>>> m = np.mat([[1,2],[2,3]])
>>> m
matrix([[1, 2],
        [2, 3]])
>>> mm = m.mean(1)
>>> mm
matrix([[ 1.5],
        [ 2.5]])
>>> mm.shape
(2, 1)
>>> m - mm
matrix([[-0.5,  0.5],
        [-0.5,  0.5]])

С массив

>>> a = np.array([[1,2],[2,3]])
>>> a
array([[1, 2],
       [2, 3]])
>>> am = a.mean(1)
>>> am.shape
(2,)
>>> am
array([ 1.5,  2.5])
>>> a - am #wrong
array([[-0.5, -0.5],
       [ 0.5,  0.5]])
>>> a - am[:, np.newaxis]  #right
array([[-0.5,  0.5],
       [-0.5,  0.5]])

Я также думаю, что смешивание массивов и матриц порождает много "счастливых" часов отладки. Однако, составляющей.разреженные матрицы всегда являются матрицами в терминах операторов, таких как умножение.


как уже упоминали другие, возможно, главное преимущество matrix было ли это удобным обозначением для умножения матрицы.

однако, в Python 3.5, наконец, есть специальный оператор infix для умножения матрицы: @.

С последними версиями NumPy его можно использовать с ndarrays:

A = numpy.ones((1, 3))
B = numpy.ones((3, 3))
A @ B

так что в наши дни, даже больше, когда вы сомневаетесь, вы должны придерживаться ndarray.