NumPy: базовые операции над массивами

Базовые операции

Математические операции над массивами выполняются поэлементно. Создается новый массив, который заполняется результатами действия оператора.

>>> import numpy as np>>> a = np.array([20, 30, 40, 50])>>> b = np.arange(4)>>> a + barray([20, 31, 42, 53])>>> a - barray([20, 29, 38, 47])>>> a * barray([ 0, 30, 80, 150])>>> a / b # При делении на 0 возвращается inf (бесконечность)array([ inf, 30. , 20. , 16.66666667])<string>:1: RuntimeWarning: divide by zero encountered in true_divide>>> a ** barray([ 1, 30, 1600, 125000])>>> a % b # При взятии остатка от деления на 0 возвращается 0<string>:1: RuntimeWarning: divide by zero encountered in remainderarray([0, 0, 0, 2])

Для этого, естественно, массивы должны быть одинаковых размеров.

>>> c = np.array([[1, 2, 3], [4, 5, 6]])>>> d = np.array([[1, 2], [3, 4], [5, 6]])>>> c + dTraceback (most recent call last): File "<input>", line 1, in <module>ValueError: operands could not be broadcast together with shapes (2,3) (3,2)

Также можно производить математические операции между массивом и числом. В этом случае к каждому элементу прибавляется (или что вы там делаете) это число.

>>> a + 1array([21, 31, 41, 51])>>> a ** 3array([ 8000, 27000, 64000, 125000])>>> a < 35 # И фильтрацию можно проводитьarray([ True, True, False, False], dtype=bool)

NumPy также предоставляет множество математических операций для обработки массивов:

>>> np.cos(a)array([ 0.40808206, 0.15425145, -0.66693806, 0.96496603])>>> np.arctan(a)array([ 1.52083793, 1.53747533, 1.54580153, 1.55079899])>>> np.sinh(a)array([ 2.42582598e+08, 5.34323729e+12, 1.17692633e+17, 2.59235276e+21])

Полный список можно посмотреть здесь (кстати, нужно ли их переводить?)

Многие унарные операции, такие как, например, вычисление суммы всех элементов массива, представлены также и в виде методов класса ndarray.

>>> a = np.array([[1, 2, 3], [4, 5, 6]])>>> np.sum(a)21>>> a.sum()21>>> a.min()1>>> a.max()6

По умолчанию, эти операции применяются к массиву, как если бы он был списком чисел, независимо от его формы. Однако, указав параметр axis, можно применить операцию для указанной оси массива:

>>> a.min(axis=0) # Наименьшее число в каждом столбцеarray([1, 2, 3])>>> a.min(axis=1) # Наименьшее число в каждой строкеarray([1, 4])

Индексы, срезы, итерации

Одномерные массивы осуществляют операции индексирования, срезов и итераций очень схожим образом с обычными списками и другими последовательностями Python (разве что удалять с помощью срезов нельзя).

>>> a = np.arange(10) ** 3>>> aarray([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])>>> a[1]1>>> a[3:7]array([ 27, 64, 125, 216])>>> a[3:7] = 8>>> aarray([ 0, 1, 8, 8, 8, 8, 8, 343, 512, 729])>>> a[::-1]array([729, 512, 343, 8, 8, 8, 8, 8, 1, 0])>>> del a[4:6]Traceback (most recent call last): File "<input>", line 1, in <module>ValueError: cannot delete array elements >>> for i in a:... print(i ** (1/3))...0.01.02.02.02.02.02.07.08.09.0

У многомерных массивов на каждую ось приходится один индекс. Индексы передаются в виде последовательности чисел, разделенных запятыми (то бишь, кортежами):

>>> b = np.array([[ 0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33], [40, 41, 42, 43]])>>> b[2,3] # Вторая строка, третий столбец23>>> b[(2,3)]23>>> b[2][3] # Можно и так23>>> b[:,2] # Третий столбецarray([ 2, 12, 22, 32, 42])>>> b[:2] # Первые две строкиarray([[ 0, 1, 2, 3], [10, 11, 12, 13]])>>> b[1:3, : : ] # Вторая и третья строкиarray([[10, 11, 12, 13], [20, 21, 22, 23]])

Когда индексов меньше, чем осей, отсутствующие индексы предполагаются дополненными с помощью срезов:

>>> b[-1] # Последняя строка. Эквивалентно b[-1,:]array([40, 41, 42, 43])

b[i] можно читать как b[i, <столько символов ':', сколько нужно>]. В NumPy это также может быть записано с помощью точек, как b[i, ...].

Например, если x имеет ранг 5 (то есть у него 5 осей), тогда

· x[1, 2, ...] эквивалентно x[1, 2, :, :, :],

· x[... , 3] то же самое, что x[:, :, :, :, 3] и

· x[4, ... , 5, :] это x[4, :, :, 5, :].

>>> a = np.array(([[0, 1, 2], [10, 12, 13]], [[100, 101, 102], [110, 112, 113]]))>>> a.shape(2, 2, 3)>>> a[1, ...] # то же, что a[1, : , :] или a[1]array([[100, 101, 102], [110, 112, 113]])>>> c[... ,2] # то же, что a[: , : ,2]array([[ 2, 13], [102, 113]])

Итерирование многомерных массивов начинается с первой оси:

>>> for row in a:... print(row)...[[ 0 1 2] [10 12 13]][[100 101 102] [110 112 113]]

Однако, если нужно перебрать поэлементно весь массив, как если бы он был одномерным, для этого можно использовать атрибут flat:

>>> for el in a.flat:... print(el)...012101213100101102110112113

Манипуляции с формой

Как уже говорилось, у массива есть форма (shape), определяемая числом элементов вдоль каждой оси:

>>> aarray([[[ 0, 1, 2], [ 10, 12, 13]], [[100, 101, 102], [110, 112, 113]]])>>> a.shape(2, 2, 3)

Форма массива может быть изменена с помощью различных команд:

>>> a.ravel() # Делает массив плоскимarray([ 0, 1, 2, 10, 12, 13, 100, 101, 102, 110, 112, 113])>>> a.shape = (6, 2) # Изменение формы>>> aarray([[ 0, 1], [ 2, 10], [ 12, 13], [100, 101], [102, 110], [112, 113]])>>> a.transpose() # Транспонированиеarray([[ 0, 2, 12, 100, 102, 112], [ 1, 10, 13, 101, 110, 113]])>>> a.reshape((3, 4)) # Изменение формыarray([[ 0, 1, 2, 10], [ 12, 13, 100, 101], [102, 110, 112, 113]])

Порядок элементов в массиве в результате функции ravel() соответствует обычному "C-стилю", то есть, чем правее индекс, тем он "быстрее изменяется": за элементом a[0,0] следует a[0,1]. Если одна форма массива была изменена на другую, массив переформировывается также в "C-стиле". Функции ravel() и reshape() также могут работать (при использовании дополнительного аргумента) в FORTRAN-стиле, в котором быстрее изменяется более левый индекс.

>>> aarray([[ 0, 1], [ 2, 10], [ 12, 13], [100, 101], [102, 110], [112, 113]])>>> a.reshape((3, 4), order='F')array([[ 0, 100, 1, 101], [ 2, 102, 10, 110], [ 12, 112, 13, 113]])

Метод reshape() возвращает ее аргумент с измененной формой, в то время как метод resize() изменяет сам массив:

>>> a.resize((2, 6))>>> aarray([[ 0, 1, 2, 10, 12, 13], [100, 101, 102, 110, 112, 113]])

Если при операции такой перестройки один из аргументов задается как -1, то он автоматически рассчитывается в соответствии с остальными заданными:

>>> a.reshape((3, -1))array([[ 0, 1, 2, 10], [ 12, 13, 100, 101], [102, 110, 112, 113]])

Объединение массивов

Несколько массивов могут быть объединены вместе вдоль разных осей с помощью функций hstack и vstack.

 

hstack() объединяет массивы по первым осям, vstack() — по последним:

>>> a = np.array([[1, 2], [3, 4]])>>> b = np.array([[5, 6], [7, 8]])>>> np.vstack((a, b))array([[1, 2], [3, 4], [5, 6], [7, 8]])>>> np.hstack((a, b))array([[1, 2, 5, 6], [3, 4, 7, 8]])

Функция column_stack() объединяет одномерные массивы в качестве столбцов двумерного массива:

>>> np.column_stack((a, b))array([[1, 2, 5, 6], [3, 4, 7, 8]])

Аналогично для строк имеется функция row_stack().

>>> np.row_stack((a, b))array([[1, 2], [3, 4], [5, 6], [7, 8]])

Разбиение массива

Используя hsplit() вы можете разбить массив вдоль горизонтальной оси, указав либо число возвращаемых массивов одинаковой формы, либо номера столбцов, после которых массив разрезается "ножницами":

>>> a = np.arange(12).reshape((2, 6))>>> aarray([[ 0, 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10, 11]])>>> np.hsplit(a, 3) # Разбить на 3 части[array([[0, 1], [6, 7]]), array([[2, 3], [8, 9]]), array([[ 4, 5], [10, 11]])]>>> np.hsplit(a, (3, 4)) # Разрезать a после третьего и четвёртого столбца[array([[0, 1, 2], [6, 7, 8]]), array([[3], [9]]), array([[ 4, 5], [10, 11]])]

Функция vsplit() разбивает массив вдоль вертикальной оси, а array_split() позволяет указать оси, вдоль которых произойдет разбиение.

Копии и представления

При работе с массивами, их данные иногда необходимо копировать в другой массив, а иногда нет. Это часто является источником путаницы. Возможно 3 случая:

Вообще никаких копий

Простое присваивание не создает ни копии массива, ни копии его данных:

>>> a = np.arange(12)>>> b = a # Нового объекта создано не было>>> b is a # a и b это два имени для одного и того же объекта ndarrayTrue>>> b.shape = (3,4) # изменит форму a>>> a.shape(3, 4)

Python передает изменяемые объекты как ссылки, поэтому вызовы функций также не создают копий.