Важный аспект NumPy, которому пока не уделялось внимание — процесс чтения данных из файла. Это очень важный момент, особенно когда нужно работать с большим количеством данных в массивах. Это базовая операция анализа данных, поскольку размер набора данных почти всегда огромен, и в большинстве случаев не рекомендуется работать с ним вручную.NumPy предлагает набор функций, позволяющих специалисту сохранять результаты вычислений в текстовый или бинарный файл. Таким же образом можно считывать и конвертировать текстовые данные из файла в массив.

Загрузка и сохранение данных в бинарных файлах

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

При наличии массива, который нужно сохранить, содержащего, например, результаты анализа данных, остается лишь вызвать функцию call() и определить аргументы: название файла и аргументы. Файл автоматически получит расширение .npy.

>>> data=([[ 0.86466285, 0.76943895, 0.22678279],
           [ 0.12452825, 0.54751384, 0.06499123],
           [ 0.06216566, 0.85045125, 0.92093862],
           [ 0.58401239, 0.93455057, 0.28972379]])
>>> np.save('saved_data',data)

Когда нужно восстановить данные из файла .npy, используется функция load(). Она требует определить имя файла в качестве аргумента с расширением .npy.

>>> loaded_data = np.load('saved_data.npy')
>>> loaded_data
array([[ 0.86466285, 0.76943895, 0.22678279],
       [ 0.12452825, 0.54751384, 0.06499123],
       [ 0.06216566, 0.85045125, 0.92093862],
       [ 0.58401239, 0.93455057, 0.28972379]])

Чтение файлов с табличными данными

Часто данные для чтения или сохранения представлены в текстовом формате (TXT или CSV). Их можно сохранить в такой формат вместо двоичного, потому что таким образом к ним можно будет получать доступ даже вне NumPy, с помощью других приложений. Возьмем в качестве примера набор данных в формате CSV (Comma-Separated Values — значения, разделенные запятыми). Данные здесь хранятся в табличной форме, а значения разделены запятыми.

id,value1,value2,value3 
1,123,1.4,23 
2,110,0.5,18 
3,164,2.1,19

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

>>> data = np.genfromtxt('ch3_data.csv', delimiter=',', names=True)
>>> data
array([(1.0, 123.0, 1.4, 23.0), (2.0, 110.0, 0.5, 18.0),
       (3.0, 164.0, 2.1, 19.0)],
      dtype=[('id', '<f8'), ('value1', '<f8'), ('value2', '<f8'), ('value3', '<f8')])

Как видно по результату, можно запросто получить структурированный массив, где заголовки колонок станут именами полей.

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

Возьмем в качестве примера предыдущий файл с удаленными элементами. Сохраним его как data2.csv.

id,value1,value2,value3 
1,123,1.4,23 
2,110,,18 
3,,2.1,19

Выполнение этих команд приведет к тому, что genfromtxt() заменит пустые области на значения nan.

>>> data2 = np.genfromtxt('ch3_data2.csv', delimiter=',', names=True) 
>>> data2 array([(1.0, 123.0, 1.4, 23.0), (2.0, 110.0, nan, 18.0), 
                 (3.0, nan, 2.1, 19.0)], 
                dtype=[('id', '<f8'), ('value1', '<f8'), ('value2', '<f8'),
                ('value3', '<f8')])

В нижней части массива указаны заголовки колонок из файла. Их можно использовать как ярлыки-индексы, используемые для получения данных по колонкам.

>>> data2['id'] 
array([ 1., 2., 3.])

А с помощью числовых значений можно получать данные из конкретных строк.

>>> data2[0] 
(1.0, 123.0, 1.4, 23.0)

В предыдущих примерах вы видели только одно- или двухмерные массивы. Но NumPy позволяет создавать массивы, которые будут более сложными не только в плане размера, но и по своей структуре. Они называются структурированными массивами. В них вместо отдельных элементов содержатся structs или записи.

Например, можно создать простой массив, состоящий из structs в качестве элементов. Благодаря параметру dtype можно определить условия, которые будут представлять элементы struct, а также тип данных и порядок.

Например, если необходимо определить struct, содержащий целое число, строку длиной 6 символов и булево значение, потребуется обозначить три типа данных в dtype в нужном порядке.

Примечание: результат dtype и другие атрибуты формата могут отличаться на разных операционных системах и дистрибутивах Python.

>>> structured = np.array([(1, 'First', 0.5, 1+2j),(2, 'Second', 1.3, 2-2j), (3, 'Third', 0.8, 1+3j)], dtype=('i2, a6, f4, c8'))
>>> structured
array([(1, b'First', 0.5, 1+2.j),
       (2, b'Second', 1.3, 2.-2.j),
       (3, b'Third', 0.8, 1.+3.j)],
      dtype=[('f0', '<i2'), ('f1', 'S6'), ('f2', '<f4'), ('f3', '<c8')])

Тип данных можно указать и явно с помощью int8, uint8, float16, complex16 и так далее.

>>> structured = np.array([(1, 'First', 0.5, 1+2j),(2, 'Second', 1.3,2-2j), (3, 'Third', 0.8, 1+3j)],dtype=('int16, a6, float32, complex64'))
>>> structured
array([(1, b'First', 0.5, 1.+2.j),
       (2, b'Second', 1.3, 2.-2.j),
       (3, b'Third', 0.8, 1.+3.j)],
      dtype=[('f0', '<i2'), ('f1', 'S6'), ('f2', '<f4'), ('f3', '<c8')])

В обоих случаях будет одинаковый результат. В массиве имеется последовательность dtype, содержащая название каждого элемента struct с соответствующим типом данных.

Указывая соответствующий индекс, вы получаете нужную строку, включающую struct.

>>> structured[1]
(2, 'bSecond', 1.3, 2.-2.j)

Имена, присваиваемые каждому элементу struct автоматически, по сути, представляют собой имена колонок массива. Используя их как структурированный указатель, можно ссылаться на все элементы одного типа или одной и той же колонки.

>>> structured['f1']
array([b'First', b'Second', b'Third'],
      dtype='|S6')

Имена присваиваются автоматически с символом f (он значит field (поле)) и увеличивающимся целым числом, обозначающим позицию в последовательности. Но было бы куда удобнее иметь более логичные имена. Это можно сделать в момент создания массива:

>>> structured = np.array([(1,'First',0.5,1+2j),
    (2,'Second',1.3,2-2j), (3,'Third',0.8,1+3j)],
    dtype=[('id','i2'),('position','a6'),('value','f4'),('complex','c8')])
>>> structured
array([(1, b'First', 0.5, 1.+2.j),
       (2, b'Second', 1.3, 2.-2.j),
       (3, b'Third', 0.8, 1.+3.j)],
      dtype=[('id', '<i2'), ('position', 'S6'), ('value', '<f4'), ('complex', '<c8')])

Или позже, переопределив кортежи имен, присвоенных атрибуту dtype структурированного массива:

>>> structured.dtype.names = ('id','order','value','complex')

Теперь можно использовать понятные имена для разных типов полей:

>>> structured['order'] 
array([b'First', b'Second', b'Third'], dtype='|S6')

В этом разделе описываются общие понятия, лежащие в основе библиотеки NumPy. Разница между копиями и представлениями при возвращении значений. Также рассмотрим механизм “broadcasting”, который неявно происходит во многих функциях NumPy.

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

Как вы могли заметить, при управлении массивом в NumPy можно возвращать его копию или представление. Но ни один из видов присваивания в NumPy не приводит к появлению копий самого массива или его элементов.

>>> a = np.array([1, 2, 3, 4])
>>> b = a
>>> b
array([1, 2, 3, 4])
>>> a[2] = 0
>>> b
array([1, 2, 0, 4])

Если присвоить один массив a переменной b, то это будет не операция копирования; массив b — это всего лишь еще один способ вызова a. Изменяя значение третьего элемента в a, вы изменяете его же и в b.

>>> c = a[0:2]
>>> c
array([1, 2])
>>> a[0] = 0
>>> c
array([0, 2])

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

>>> a = np.array([1, 2, 3, 4])
>>> c = a.copy()
>>> c
array([1, 2, 3, 4])
>>> a[0] = 0
>>> c
array([1, 2, 3, 4])

В этом случае даже при изменении объектов в массиве a, массив c будет оставаться неизменным.

Векторизация

Векторизация, как и транслирование, — это основа внутренней реализации NumPy. Векторизация — это отсутствие явного цикла при разработке кода. Самих циклов избежать не выйдет, но их внутренняя реализация заменяется на другие конструкции в коде. Приложение векторизации делает код более емким и читаемым. Можно сказать, что он становится более «Pythonic» внешне. Благодаря векторизации многие операции принимают более математический вид. Например, NumPy позволяет выражать умножение двух массивов вот так:

a * b

Или даже умножение двух матриц:

A * B  

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

for (i = 0; i < rows; i++){
  c[i] = a[i]*b[i];
}

А произведение матриц может быть выражено следующим образом:

for( i=0; i < rows; i++){
  for(j=0; j < columns; j++){
    c[i][j] = a[i][j]*b[i][j];
 }
}

Использование NumPy делает код более читаемым и математическим.

Транслирование (Broadcasting)

Транслирование позволяет оператору или функции применяться по отношению к двум или большему количеству массивов, даже если они не одной формы. Тем не менее не все размерности поддаются транслированию; они должны соответствовать определенным правилам.

С помощью NumPy многомерные массивы можно классифицировать через форму (shape) — кортеж, каждый элемент которого представляет длину каждой размерности.

Транслирование может работать для двух массивов в том случае, если их размерности совместимы: их длина равна, или длина одной из них — 1. Если эти условия не соблюдены, возникает исключение, сообщающее, что два массива не совместимы.

>>> A = np.arange(16).reshape(4, 4)
>>> b = np.arange(4)
>>> A
array([[ 0, 1, 2, 3],
       [ 4, 5, 6, 7],
       [ 8, 9, 10, 11],
       [12, 13, 14, 15]])
>>> b
array([0, 1, 2, 3])

В таком случае вы получаете два массива:

4 x 4 
4

Есть два правила транслирования. В первую очередь нужно добавить 1 к каждой недостающей размерности. Если правила совместимости соблюдены, можно использовать транслирование и переходить ко второму правилу. Например:

4 x 4 
4 x 1

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

Второе правило предполагает, что недостающие элементы заполняются копиями заданных значений.

Когда у двух массивов одинаковые размерности, их значения можно суммировать.

>>> A + b
array([[ 0, 2, 4, 6],
       [ 4, 6, 8, 10],
       [ 8, 10, 12, 14],
       [12, 14, 16, 18]])

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

>>> m = np.arange(6).reshape(3, 1, 2)
>>> n = np.arange(6).reshape(3, 2, 1)
>>> m
array([[[0, 1]],
      [[2, 3]],
      [[4, 5]]])
>>> n
array([[[0],
        [1]],
       [[2],
        [3]],
       [[4],
        [5]]])

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

3 x 1 x 2 
3 x 2 x 1

В этом случае размерности обоих массивов расширяются (транслирование).

m* = [[[0,1], 		n* = [[[0,0],
       [0,1]], 		       [1,1]],
      [[2,3], 		      [[2,2],
       [2,3]], 		       [3,3]],
      [[4,5], 		      [[4,4],
       [4,5]]] 		       [5,5]]]

Затем можно использовать, например, оператор сложения для двух массивов поэлементно.

>>> m + n
array([[[ 0, 1],
        [ 1, 2]],
       [[ 4, 5],
        [ 5, 6]],
       [[ 8, 9],
        [ 9, 10]]])

Часто требуется создать новый массив на основе уже существующих. В этом разделе речь пойдет о процессе создания массивов за счет объединения или разделения ранее определенных.

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

Можно осуществить слияние массивов для создания нового, который будет содержать все элементы объединенных. NumPy использует концепцию стекинга и предлагает для этого кое-какие функции. Например, можно осуществить вертикальный стекинг с помощью функции vstack(), которая добавит второй массив в первый с помощью новых рядов. А функция hstack() осуществляет горизонтальная стекинг, добавляя второй массив в виде колонок.

>>> A = np.ones((3, 3))
>>> B = np.zeros((3, 3))
>>> np.vstack((A, B))
array([[ 1., 1., 1.],
       [ 1., 1., 1.],
       [ 1., 1., 1.],
       [ 0., 0., 0.],
       [ 0., 0., 0.],
       [ 0., 0., 0.]])
>>> np.hstack((A,B))
array([[ 1., 1., 1., 0., 0., 0.],
       [ 1., 1., 1., 0., 0., 0.],
       [ 1., 1., 1., 0., 0., 0.]])

Еще две функции, которые выполняют стекинг для нескольких массивов — это column_stack() и row_stack(). Они работают независимо от первых двух. Их используют для одномерных массивов, для объединения значения в ряды или колонки и формирования двумерного массива.

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

Разделение массивов

Из прошлого раздела вы узнали, как собирать массивы с помощью стекинга. Теперь разберемся с разделением их на части. В NumPy для этого используется разделение. Также имеется набор функций, который работают в горизонтальной (hsplit()) и вертикальной (vsplit()) ориентациях.

>>> A = np.arange(16).reshape((4, 4))
>>> A
array([[ 0, 1, 2, 3],
       [ 4, 5, 6, 7],
       [ 8, 9, 10, 11],
       [12, 13, 14, 15]])

Так, если нужно разбить массив горизонтально, то есть, поделить ширину массива на две части, то матрица A размером 4×4 превратится в две матрицы 2×4.

>>> [B,C] = np.hsplit(A, 2)
>>> B
array([[ 0, 1],
       [ 4, 5],
       [ 8, 9],
       [12, 13]])
>>> C
array([[ 2, 3],
       [ 6, 7],
       [10, 11],
       [14, 15]])

Если же нужно разбить массив вертикально, то есть поделить высоту на две части, то матрица A размером 4×4 превратится в 2 размерами 4×2.

>>> [B,C] = np.vsplit(A, 2)
>>> B
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
>>> C
array([[ 8, 9, 10, 11],
       [12, 13, 14, 15]])

Более сложная команда — функция split(). Она позволяет разбить массив на несимметричные части. Массив передается в качестве аргумента, но вместе с ним необходимо указать и индексы частей, на которые его требуется разбить. Если указать параметр axis = 1, то индексами будут колонки, а если axis = 0 — ряды.

Например, необходимо разбить матрицу на три части. Первая из которых будет включать первую колонку, вторая — вторую и третью колонки, а третья — последнюю. Здесь нужно указать следующие индексы.

>>> [A1,A2,A3] = np.split(A,[1,3],axis=1)
>>> A1
array([[ 0],
       [ 4],
       [ 8],
       [12]])
>>> A2
array([[ 1, 2],
       [ 5, 6],
       [ 9, 10], 
       [13, 14]])
>>> A3
array([[ 3],
       [ 7],
       [11],
       [15]])

То же самое можно проделать и для рядов.

>>> [A1,A2,A3] = np.split(A,[1,3],axis=0)
>>> A1
array([[0, 1, 2, 3]])
>>> A2
array([[ 4, 5, 6, 7],
       [ 8, 9, 10, 11]])
>>> A3
array([[12, 13, 14, 15]])

Эта же особенность включает функции vsplit() и hsplit().

До этого момента индексы и срезы использовать для извлечения подмножеств. В этих методах используются числовые значения. Но есть альтернативный путь получения элементов — с помощью условий и булевых операторов.

Предположим, что нужно выбрать все значения меньше 0,5 в матрице размером 4х4, которая содержит случайные значения между 0 и 1.

>>> A = np.random.random((4, 4))
>>> A
array([[ 0.03536295, 0.0035115 , 0.54742404, 0.68960999],
       [ 0.21264709, 0.17121982, 0.81090212, 0.43408927],
       [ 0.77116263, 0.04523647, 0.84632378, 0.54450749],
       [ 0.86964585, 0.6470581 , 0.42582897, 0.22286282]])

Когда матрица из случайных значений определена, можно применить оператор условия. Результатом будет матрица из булевых значений: True, если элемент соответствовал условию и False — если нет. В этом примере можно видеть все элементы со значениями меньше 0,5.

>>> A < 0.5
array([[ True, True, False, False],
       [ True, True, False, True],
       [False, True, False, False],
       [False, False, True, True]], dtype=bool)

На самом деле, булевы массивы используются для неявного извлечения частей массивов. Добавив прошлое условие в квадратные скобки, можно получить новый массив, который будет включать все элементы меньше 0,5 из предыдущего.

>>> A[A < 0.5]
array([ 0.03536295, 0.0035115 , 0.21264709, 0.17121982, 0.43408927,
        0.04523647, 0.42582897, 0.22286282])

Управление размерностью

Вы уже видели, как можно превращать одномерный массив в матрицу с помощью функции reshape().

>>> a = np.random.random(12)
>>> a
array([ 0.77841574, 0.39654203, 0.38188665, 0.26704305, 0.27519705,
        0.78115866, 0.96019214, 0.59328414, 0.52008642, 0.10862692,
        0.41894881, 0.73581471])
>>> A = a.reshape(3, 4)
>>> A
array([[ 0.77841574, 0.39654203, 0.38188665, 0.26704305],
       [ 0.27519705, 0.78115866, 0.96019214, 0.59328414],
       [ 0.52008642, 0.10862692, 0.41894881, 0.73581471]])

Функция reshape() возвращает новый массив и таким образом может создавать новые объекты. Но если необходимо изменить объект, поменяв его форму, нужно присвоить кортеж с новыми размерностями атрибуту shape массива.

>>> a.shape = (3, 4)
>>> a
array([[ 0.77841574, 0.39654203, 0.38188665, 0.26704305],
       [ 0.27519705, 0.78115866, 0.96019214, 0.59328414],
       [ 0.52008642, 0.10862692, 0.41894881, 0.73581471]])

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

>>> a = a.ravel()
array([ 0.77841574, 0.39654203, 0.38188665, 0.26704305, 0.27519705,
        0.78115866, 0.96019214, 0.59328414, 0.52008642, 0.10862692,
        0.41894881, 0.73581471])

Или прямо повлиять на атрибут shape самого массива.

>>> a.shape = (12)
>>> a
array([ 0.77841574, 0.39654203, 0.38188665, 0.26704305, 0.27519705,
        0.78115866, 0.96019214, 0.59328414, 0.52008642, 0.10862692,
        0.41894881, 0.73581471])

Еще одна важная операция — транспонирование матрицы. Это инверсия колонок и рядов. NumPy предоставляет такую функциональность в функции transpose().

>>> A.transpose()
array([[ 0.77841574, 0.27519705, 0.52008642],
       [ 0.39654203, 0.78115866, 0.10862692],
       [ 0.38188665, 0.96019214, 0.41894881],
       [ 0.26704305, 0.59328414, 0.73581471]])

В прошлых разделах вы узнали, как создавать массив и выполнять операции с ним. В этом — речь пойдет о манипуляции массивами: о выборе элементов по индексам и срезам, а также о присваивании для изменения отдельных значений. Наконец, узнаете, как перебирать их.

Индексы

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

При создании нового массива шкала с индексами создается автоматически.

Для получения доступа к одному элементу на него нужно сослаться через его индекс.

>>> a = np.arange(10, 16)
>>> a
array([10, 11, 12, 13, 14, 15])
>>> a[4]
14

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

>>> a[–1]
15
>>> a[–6]
10

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

>>> a[[1, 3, 4]] 
array([11, 13, 14])

Двухмерные массивы, матрицы, представлены в виде прямоугольного массива, состоящего из строк и колонок, определенных двумя осями, где ось 0 представлена строками, а ось 1 — колонками. Таким образом индексация происходит через пару значений; первое — это значение ряда, а второе — колонки. И если нужно получить доступ к определенному элементу матрицы, необходимо все еще использовать квадратные скобки, но уже с двумя значениями.

>>> A = np.arange(10, 19).reshape((3, 3))
>>> A
array([[10, 11, 12],
 [13, 14, 15],
 [16, 17, 18]])

Если нужно удалить элемент третьей колонки во второй строке, необходимо ввести пару [1, 2].

>>> A[1, 2]
15

Срезы

Срезы позволяют извлекать части массива для создания новых массивов. Когда вы используете срезы для списков Python, результирующие массивы — это копии, но в NumPy они являются представлениями одного и того же лежащего в основе буфера.

В зависимости от части массива, которую необходимо извлечь, нужно использовать синтаксис среза; это последовательность числовых значений, разделенная двоеточием (:) в квадратных скобках.

Чтобы получить, например, часть массива от второго до шестого элемента, необходимо ввести индекс первого элемента — 1 и индекса последнего — 5, разделив их :.

>>> a = np.arange(10, 16)
>>> a
array([10, 11, 12, 13, 14, 15])
>>> a[1:5]
array([11, 12, 13, 14])

Если нужно извлечь элемент из предыдущего отрезка и пропустить один или несколько элементов, можно использовать третье число, которое представляет собой интервал последовательности. Например, со значением 2 результат будет такой.

>>> a[1:5:2] 
array([11, 13])

Чтобы лучше понять синтаксис среза, необходимо рассматривать и случаи, когда явные числовые значения не используются. Если не ввести первое число, NumPy неявно интерпретирует его как 0 (то есть, первый элемент массива). Если пропустить второй — он будет заменен на максимальный индекс, а если последний — представлен как 1. То есть, все элементы будут перебираться без интервалов.

>>> a[::2]
array([10, 12, 14])
>>> a[:5:2]
array([10, 12, 14])
>>> a[:5:]
array([10, 11, 12, 13, 14]

В случае с двухмерными массивами срезы тоже работают, но их нужно определять отдельно для рядов и колонок. Например, если нужно получить только первую строку:

>>> A = np.arange(10, 19).reshape((3, 3))
>>> A
array([[10, 11, 12],
       [13, 14, 15],
       [16, 17, 18]])
>>> A[0,:]
array([10, 11, 12])

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

>>> A[:,0] 
array([10, 13, 16])

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

>>> A[0:2, 0:2]
array([[10, 11],
       [13, 14]])

Если индексы рядов или колонок не последовательны, нужно указывать массив индексов.

>>> A[[0,2], 0:2] 
array([[10, 11], 
       [16, 17]])

Итерация по массиву

В Python для перебора по элементам массива достаточно использовать такую конструкцию.

>>> for i in a:
...     print(i)
...
10
11
12
13
14
15

Но даже здесь в случае с двухмерным массивом можно использовать вложенные циклы внутри for. Первый цикл будет сканировать ряды массива, а второй — колонки. Если применить цикл for к матрице, она всегда будет перебирать в первую очередь по строкам.

>>> for row in A:
...     print(row)
...
[10 11 12]
[13 14 15]
[16 17 18]

Если необходимо перебирать элемент за элементом можно использовать следующую конструкцию, применив цикл for для A.flat:

>>> for item in A.flat:
...     print(item)
...
10
11
12
13
14
15
68
16
17
18

Но NumPy предлагает и альтернативный, более элегантный способ. Как правило, требуется использовать перебор для применения функции для конкретных рядов, колонок или отдельных элементов. Можно запустить функцию агрегации, которая вернет значение для каждой колонки или даже каждой строки, но есть оптимальный способ, когда NumPy перебирает процесс итерации на себя: функция apply_along_axis().

Она принимает три аргумента: функцию, ось, для которой нужно применить перебор и сам массив. Если ось равна 0, тогда функция будет применена к элементам по колонкам, а если 1 — то по рядам. Например, можно посчитать среднее значение сперва по колонкам, а потом и по рядам.

>>> np.apply_along_axis(np.mean, axis=0, arr=A)
array([ 13., 14., 15.])
>>> np.apply_along_axis(np.mean, axis=1, arr=A)
array([ 11., 14., 17.])

В прошлом примере использовались функции из библиотеки NumPy, но ничто не мешает определять собственные. Можно использовать и ufunc. В таком случае перебор по колонкам и по рядам выдает один и тот же результат. На самом деле, ufunc выполняет перебор элемент за элементом.

>>> def foo(x):
...     return x/2
...
>>> np.apply_along_axis(foo, axis=1, arr=A)
array([[5., 5.5, 6. ],
       [6.5, 7., 7.5],
       [8., 8.5, 9. ]])
>>> np.apply_along_axis(foo, axis=0, arr=A)
array([[5., 5.5, 6.],
       [6.5, 7., 7.5],
       [8., 8.5, 9.]])

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

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

Арифметические операторы

Арифметические операторы — первые, которые предстоит использовать. К числу наиболее очевидных относятся прибавление и умножение на скаляр.

>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> a+4
array([4, 5, 6, 7])
>>> a*2
array([0, 2, 4, 6])

Их можно использовать для двух массивов. В NumPy эти операции поэлементные, то есть, они применяются только к соответствующим друг другу элементам. Это должны быть объекты, которые занимают одно и то же положение, так что результатом станет новый массив, содержащий итоговые величины в тех же местах, что и операнды.

>>> b = np.arange(4,8)
>>> b
array([4, 5, 6, 7])
>>> a + b
array([ 4, 6, 8, 10])
>>> a – b
array([–4, –4, –4, –4])
>>> a * b
array([ 0, 5, 12, 21])

Более того, эти операторы доступны и для функций, если те возвращают массив NumPy. Например, можно перемножить массив на синус или квадратный корень элементов массива b.

>>> a * np.sin(b)
array([–0. , –0.95892427, –0.558831 , 1.9709598 ])
>>> a * np.sqrt(b)
array([ 0. , 2.23606798, 4.89897949, 7.93725393]) 

И даже в случае с многомерными массивами можно применять арифметические операторы поэлементно.

>>> A = np.arange(0, 9).reshape(3, 3)
>>> A
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> B = np.ones((3, 3))
>>> B
array([[ 1., 1., 1.],
       [ 1., 1., 1.],
       [ 1., 1., 1.]])
>>> A * B
array([[ 0., 1., 2.],
       [ 3., 4., 5.],
       [ 6., 7., 8.]])

Произведение матриц

Выбор оператора для поэлементного применения — это странный аспект работы с библиотекой NumPy. В большинстве инструментов для анализа данных оператор * обозначает произведение матриц. Он применяется к обоим массивам. В NumPy же подобное произведение обозначается функцией dot(). Эта операция не поэлементная.

>>> np.dot(A,B)
array([[ 3., 3., 3.],
       [ 12., 12., 12.],
       [ 21., 21., 21.]])

Каждый элемент результирующей матрицы — сумма произведений каждого элемента соответствующей строки в первой матрице с соответствующим элементом из колонки второй. Рисунок ниже показывает процесс произведения матриц (для двух элементов).

Еще один вариант записи произведения матриц — использование одной из двух матриц в качестве объекта функции dot().

>>> A.dot(B)
array([[ 3., 3., 3.],
       [ 12., 12., 12.],
       [ 21., 21., 21.]])

Но поскольку произведение матриц — это не коммутативная операция, порядок операндов имеет значение. В данном случае A*B не равняется B*A.

>>> np.dot(B,A)
array([[ 9., 12., 15.],
       [ 9., 12., 15.],
       [ 9., 12., 15.]])

Операторы инкремента и декремента

На самом деле, в Python таких операторов нет, поскольку нет операторов ++ или --. Для увеличения или уменьшения значения используются += и -=. Они не отличаются от предыдущих, но вместо создания нового массива с результатами присваивают новое значение тому же массиву.

>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> a += 1
>>> a
array([1, 2, 3, 4])
>>> a –= 1
>>> a
array([0, 1, 2, 3])

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

array([0, 1, 2, 3])
>>> a += 4
>>> a
array([4, 5, 6, 7])
>>> a *= 2
>>> a
array([ 8, 10, 12, 14])

Универсальные функции (ufunc)

Универсальная функция, известная также как ufunc, — это функция, которая применяется в массиве к каждому элементу. Это значит, что она воздействует на каждый элемент массива ввода, генерируя соответствующий результат в массив вывода. Финальный массив соответствует по размеру массиву ввода.

Под это определение подпадает множество математических и тригонометрических операций; например, вычисление квадратного корня с помощью sqrt(), логарифма с log() или синуса с sin().

>>> a = np.arange(1, 5)
>>> a
array([1, 2, 3, 4])
>>> np.sqrt(a)
array([ 1. , 1.41421356, 1.73205081, 2. ])
>>> np.log(a)
array([ 0. , 0.69314718, 1.09861229, 1.38629436])
>>> np.sin(a)
array([ 0.84147098, 0.90929743, 0.14112001, –0.7568025 ])

Многие функции уже реализованы в библиотеке NumPy.

Функции агрегации

Функции агрегации выполняют операцию на наборе значений, например, на массиве, и выдают один результат. Таким образом, сумма всех элементов массива — это результат работы функции агрегации. Многие из таких функций реализованы в классе ndarray.

>>> a = np.array([3.3, 4.5, 1.2, 5.7, 0.3])
>>> a.sum()
15.0
>>> a.min()
0.29999999999999999
>>> a.max()
5.7000000000000002
>>> a.mean()
3.0
>>> a.std()
2.0079840636817816

Основной элемент библиотеки NumPy — объект ndarray (что значит N-размерный массив). Этот объект является многомерным однородным массивом с заранее заданным количеством элементов. Однородный — потому что практически все объекты в нем одного размера или типа. На самом деле, тип данных определен другим объектом NumPy, который называется dtype (тип-данных). Каждый ndarray ассоциирован только с одним типом dtype.

Количество размерностей и объектов массива определяются его размерностью (shape), кортежем N-положительных целых чисел. Они указывают размер каждой размерности. Размерности определяются как оси, а количество осей — как ранг.

Еще одна странность массивов NumPy в том, что их размер фиксирован, а это значит, что после создания объекта его уже нельзя поменять. Это поведение отличается от такового у списков Python, которые могут увеличиваться и уменьшаться в размерах.

Простейший способ определить новый объект ndarray — использовать функцию array(), передав в качестве аргумента Python-список элементов.

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

Можно легко проверить, что новый объект — это ndarray, передав его функции type().

>>> type(a)
<type 'numpy.ndarray'>

Чтобы узнать ассоциированный тип dtype, необходимо использовать атрибут dtype.

Примечание: результат dtype, shape и других может быть разным для разных операционных систем и дистрибутивов Python.

>>> a.dtype 
dtype('int64')

Только что созданный массив имеет одну ось, а его ранг равняется 1, то есть его форма — (3,1). Для получения этих значений из массива необходимо использовать следующие атрибуты: ndim — для осей, size — для длины массива, shape — для его формы.

>>> a.ndim
1
>>> a.size
3
>>> a.shape
(3,)

Это был пример простейшего одномерного массива. Но функциональность массивов может быть расширена и до нескольких размерностей. Например, при определении двумерного массива 2×2:

>>> b = np.array([[1.3, 2.4],[0.3, 4.1]])
>>> b.dtype
dtype('float64')
>>> b.ndim
2
>>> b.size
4
>>> b.shape
(2, 2)

Ранг этого массива — 2, поскольку у него 2 оси, длина каждой из которых также равняется 2.

Еще один важный атрибут — itemsize. Он может быть использован с объектами ndarray. Он определяет размер каждого элемента массива в байтах, а data — это буфер, содержащий все элементы массива. Второй атрибут пока не используется, потому что для получения данных из массива применяется механизм индексов, речь о котором подробно пойдет в следующих разделах.

>>> b.itemsize
8
>>> b.data
<read-write buffer for 0x0000000002D34DF0, size 32, offset 0 at
0x0000000002D5FEA0>

Создание массива

Есть несколько вариантов создания массива. Самый распространенный — список из списков, выступающий аргументом функции array().

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

Функция array() также может принимать кортежи и последовательности кортежей.

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

Она также может принимать последовательности кортежей и взаимосвязанных списков.

>>> e = np.array([(1, 2, 3), [4, 5, 6], (7, 8, 9)])
>>> e
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

Типы данных

Пока что рассматривались только значения простого целого числа и числа с плавающей запятой, но массивы NumPy сделаны так, чтобы включать самые разные типы данных. Например, можно включать строки:

Типы данных, поддерживаемые NumPy

Параметр dtype

Функция array() не принимает один аргумент. На примерах видно, что каждый объект ndarray ассоциирован с объектом dtype, определяющим тип данных, которые будут в массиве. По умолчанию функция array() можно ассоциировать самый подходящий тип в соответствии со значениями в последовательностях списков или кортежей. Их можно определить явно с помощью параметра dtype в качестве аргумента.

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

>>> f = np.array([[1, 2, 3],[4, 5, 6]], dtype=complex)
>>> f
array([[ 1.+0.j, 2.+0.j, 3.+0.j],
       [ 4.+0.j, 5.+0.j, 6.+0.j]])

Функции генерации массива

Библиотека NumPy предоставляет набор функций, которые генерируют ndarray с начальным содержимым. Они создаются с разным значениями в зависимости от функции. Это очень полезная особенность. С помощью всего одной строки кода можно сгенерировать большой объем данных.

Функция zeros(), например, создает полный массив нулей с размерностями, определенными аргументом shape. Например, для создания двумерного массива 3×3, можно использовать:

>>> np.zeros((3, 3))
array([[ 0., 0., 0.],
       [ 0., 0., 0.],
       [ 0., 0., 0.]])

А функция ones() создает массив, состоящий из единиц.

>>> np.ones((3, 3))
array([[ 1., 1., 1.],
       [ 1., 1., 1.],
       [ 1., 1., 1.]])

По умолчанию две функции создают массивы с типом данных float64. Полезная фишка — arrange(). Она генерирует массивы NumPy с числовыми последовательностями, которые соответствуют конкретным требованиям в зависимости от переданных аргументов. Например, для генерации последовательности значений между 0 и 10, нужно передать всего один аргумент — значение, которое закончит последовательность.

>>> np.arange(0, 10) 
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Если в начале нужен не ноль, то необходимо обозначить уже два аргумента: первый и последний.

>>> np.arange(4, 10) 
array([4, 5, 6, 7, 8, 9])

Также можно сгенерировать последовательность значений с точным интервалом между ними. Если определено и третье значение в arrange(), оно будет представлять собой промежуток между каждым элементом.

>>> np.arange(0, 12, 3) 
array([0, 3, 6, 9])

Оно может быть и числом с плавающей точкой.

>>> np.arange(0, 6, 0.6)
array([ 0. , 0.6, 1.2, 1.8, 2.4, 3. , 3.6, 4.2, 4.8, 5.4])

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

>>> np.arange(0, 12).reshape(3, 4)
array([[ 0, 1, 2, 3],
       [ 4, 5, 6, 7],
       [ 8, 9, 10, 11]])

Похожая на arrange() функция — linspace(). Она также принимает в качестве первых двух аргументов первое и последнее значения последовательности, но третьим аргументом является не интервал, а количество элементов, на которое нужно разбить последовательность.

>>> np.linspace(0,10,5)
array([ 0. , 2.5, 5. , 7.5, 10. ])

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

>>> np.random.random(3)
array([ 0.78610272, 0.90630642, 0.80007102])

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

>>> np.random.random((3,3))
array([[ 0.07878569, 0.7176506 , 0.05662501],
       [ 0.82919021, 0.80349121, 0.30254079],
       [ 0.93347404, 0.65868278, 0.37379618]]) 

Немного истории

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

Первой попыткой упростить задачу был модуль Numeric. Его разработал программист по имени Джим Хагунин в 1995 году. Следом за ней появился пакет Numarray. Оба решения специализировались на вычислениях массивов. У каждого свои преимущества в зависимости от сценария. Поэтому и использовались они по обстоятельствам. Такая неопределенность привела к тому, что приняли решение объединить два пакета. Для этих целей Трэвис Олифант начал разработку библиотеки NumPy, первая версия которой вышла в 2006 году.

С тех пор NumPy стала библиотекой №1 в Python для научных вычислений и по сегодняшний день она является самым популярным пакетом для вычислений многомерных и просто крупных массивов. Он также включает множество функций, которые позволяют эффективно проводить операции и выполнять высокоуровневые математические расчеты.

Сейчас NumPy — это проект с открытым исходным кодом, который распространяется по лицензии BSD. В его развитии внесли свою лепту множество разработчиков.

Установка NumPy

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

В Linux (Ubuntu и Debian):

sudo apt-get install python-numpy

Для Linux (Fedora):

sudo yum install numpy scipy

В Windows с Anaconda или pip:

conda install numpy
pip install numpy  

Когда NumPy установлен, импортируйте модуль с помощью этой команды.

import numpy as np

Предок NumPy, Numeric, был разработан Джимом Хугунином. Также был создан пакет Numarray с дополнительной функциональностью. В 2005 году Трэвис Олифант выпустил пакет NumPy, добавив особенности Numarray в Numeric. Это проект с исходным кодом, и в его развитии поучаствовало уже много человек.

NumPy или Numerical Python — это библиотека Python, которая предлагает следующее:

• Мощный N-мерный массив
• Высокоуровневые функции
• Инструменты для интеграции кода C/C++ и Fortran
• Использование линейной алгебры, Преобразований Фурье и возможностей случайных чисел

Она также предлагает эффективный многомерный контейнер общих данных. С ее помощью можно определять произвольные типы данных. Официальный сайт библиотеки — www.numpy.org

Установка NumPy в Python

1. Ubuntu Linux

   sudo apt update -y
   sudo apt upgrade -y
   sudo apt install python3-tk python3-pip -y
   sudo pip install numpy -y
   

2. Anaconda

   conda install -c anaconda numpy
   

Массив NumPy

Это мощный многомерный массив в форме строк и колонок. С помощью библиотеки можно создавать массивы NumPy из вложенного списка Python и получать доступ к его элементам.

Массив NumPy — это не то же самое, что и класс array.array из Стандартной библиотеки Python, который работает только с одномерными массивами.

1. Одномерный массив NumPy.

   import numpy as np
   
   a = np.array([1,2,3])
   print(a)
   

   Результатом кода выше будет [1 2 3].

2. Многомерные массивы.

   import numpy as np
   
   a = np.array([[1,2,3],[4,5,6]])
   print(a)
   

   Результат — [[1 2 3] [4 5 6]].

Атрибуты массива NumPy

1. ndarray.ndim
   Возвращает количество измерений массива.

   import numpy as np
   a = np.array([[1,2,3],[4,5,6]])
   print(a.ndim)
   

   Вывод кода сверху будет 2, поскольку «a» — это 2-мерный массив.

2. ndarray.shape
   Возвращает кортеж размера массива, то есть (n,m), где n — это количество строк, а m — количество колонок.

   import numpy as np
   a = np.array([[1,2,3],[4,5,6]])
   print(a.shape)
   

   Вывод кода — (2,3), то есть 2 строки и 3 колонки.

3. ndarray.size
   Возвращает общее количество элементов в массиве.

   import numpy as np
   a = np.array([[1,2,3],[4,5,6]])
   print(a.size)
   

   Вывод — 6, потому что 2 х 3.

4. ndarray.dtype
   Возвращает объект, описывающий тип элементов в массиве.

   import numpy as np
   a = np.array([[1,2,3],[4,5,6]])
   print(a.dtype)
   

   Вывод — «int32», поскольку это 32-битное целое число.
   Можно явно определить тип данных массива NumPy.

   import numpy as np
   a = np.array([[1,2,3],[4,5,6]], dtype = float)
   print(a.dtype)
   

   Этот код вернет float64, потому что это 64-битное число с плавающей точкой.

5. ndarray.itemsize
   Возвращает размер каждого элемента в массиве в байтах.

   import numpy as np
   a = np.array([[1,2,3],[4,5,6]])
   print(a.itemsize)
   

   Вывод — 4, потому что 32/8.

6. ndarray.data
   Возвращает буфер с актуальными элементами массива. Это альтернативный способ получения доступа к элементам через их индексы.

   import numpy as np
   a = np.array([[1,2,3],[4,5,6]])
   print(a.data)
   

   Этот код вернет список элементов.

7. ndarray.sum()
   Функция вернет сумму все элементов ndarray.

   import numpy as np
   a = np.random.random((2,3))
   print(a)
   print(a.sum())
   

   Сгенерированная в этом примере матрица — [[0.46541517 0.66668157 0.36277909] [0.7115755 0.57306008 0.64267163]], следовательно код вернет 3.422183052180838. Поскольку используется генератор случайных чисел, ваш результат будет отличаться.

8. ndarray.min()
   Функция вернет элемент с минимальным значением из ndarray.

   import numpy as np
   a = np.random.random((2,3))
   print(a.min())
   

   Сгенерированная в этом примере матрица — [[0.46541517 0.66668157 0.36277909] [0.7115755 0.57306008 0.64267163]], следовательно код вернет 0.36277909. Поскольку используется генератор случайных чисел, ваш результат будет отличаться.

9. ndarray.max()
   Функция вернет элемент с максимальным значением из ndarray.

   import numpy as np
   a = np.random.random((2,3))
   print(a.min())
   

   Сгенерированная в этом примере матрица — [[0.46541517 0.66668157 0.36277909] [0.7115755 0.57306008 0.64267163]], следовательно код вернет 0.7115755. Поскольку используется генератор случайных чисел, ваш результат будет отличаться

Функции NumPy

1. type(numpy.ndarray)
   Это функция Python, используемая, чтобы вернуть тип переданного параметра. В случае с массивом numpy, она вернет numpy.ndarray.

   import numpy as np
   
   a = np.array([[1,2,3],[4,5,6]])
   print(type(a))
   

   Код выше вернет numpy.ndarray.

2. numpy.zeroes()
numpy.zeros((rows, columns), dtype)
   Эта функция создаст массив numpy с заданным количеством измерений, где каждый элемент будет равняться 0. Если dtype не указан, по умолчанию будет использоваться dtype.

   import numpy as np
   np.zeros((3,3))
   print(a)
   

   Код вернет массив numpy 3×3, где каждый элемент равен 0.

3. numpy.ones()
numpy.ones((rows,columns), dtype)
   Эта функция создаст массив numpy с заданным количеством измерений, где каждый элемент будет равняться 1. Если dtype не указан, по умолчанию будет использоваться dtype.

   import numpy as np
   np.ones((3,3))
   print(a)
   

   Код вернет массив numpy 3 x 3, где каждый элемент равен 1.

4. numpy.empty()
numpy.empty((rows,columns))
   Эта функция создаст массив, содержимое которого будет случайным — оно зависит от состояния памяти.

   import numpy as np
   np.empty((3,3))
   print(a)
   

   Код вернет массив numpy 3×3, где каждый элемент будет случайным.

5. numpy.arrange()
numpy.arrange(start, stop, step)
   Эта функция используется для создания массива numpy, элементы которого лежат в диапазоне значений от start до stop с разницей равной step.

   import numpy as np
   a=np.arange(5,25,4)
   print(a)
   

   Вывод этого кода — [5 9 13 17 21]

6. numpy.linspace()
numpy.linspace(start, stop, num_of_elements)
   Эта функция создаст массив numpy, элементы которого лежат в диапазоне значений между start до stop, а num_of_elements — это размер массива. Тип по умолчанию — float64.

   import numpy as np
   a=np.linspace(5,25,5)
   print(a)
   

   Вывод — [5 10 15 20 25].

7. numpy.logspace()
numpy.logspace(start, stop, num_of_elements)
   Эта функция используется для создания массива numpy, элементы которого лежат в диапазоне значений от start до stop, а num_of_elements — это размер массива. Тип по умолчанию — float64. Все элементы находятся в пределах логарифмической шкалы, то есть представляют собой логарифмы соответствующих элементов.

   import numpy as np
   a = np.logspace(5,25,5)
   print(a)
   

   Вывод — [1.e+05 1.e+10 1.e+15 1.e+20 1.e+25].

8. numpy.sin()
numpy.sin(numpy.ndarray)
   Этот код вернет синус параметра.

   import numpy as np
   a = np.logspace(5,25,2)
   print(np.sin(a))
   

   Вывод кода сверху равен [0.0357488 -0.3052578]. Также есть cos(), tan() и так далее.

9. numpy.reshape()
numpy.reshape(dimensions)
   Эта функция используется для изменения количества измерений массива numpy. От количества аргументов в reshape зависит, сколько измерений будет в массиве numpy.

   import numpy as np
   a = np.arange(9).reshape(3,3)
   print(a)
   

   Вывод этого года — 2-мерный массив 3×3.

10. numpy.random.random()
numpy.random.random((rows, column))
    Эта функция возвращает массив с заданным количеством измерений, где каждый элемент генерируется случайным образом.

    a = np.random.random((2,2))
    

    Этот код вернет ndarray 2×2.

11. numpy.exp()
numpy.exp(numpy.ndarray)
    Функция вернет ndarray с экспоненциальной величиной каждого элемента.

    b = np.exp([10])
    

    Значением кода выше будет 22025.4657948.

12. numpy.sqrt()
numpy.sqrt(numpy.ndarray)
    Эта функция вернет ndarray с квадратным корнем каждого элемента.

    b = np.sqrt([16])
    

    Этот код вернет значение 4.

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

a = np.array([5, 10, 15, 20, 25])
b = np.array([0, 1, 2, 3])

1. Этот код вернет разницу двух массивов c = a - b.

2. Этот код вернет массив, где каждое значение возведено в квадрат b**2.

3. Этот код вернет значение в соответствии с заданным выражением 10 * np.sin(a).

4. Этот код вернет True для каждого элемента, чье значение удовлетворяет условие a < 15.

Базовые операции с массивом NumPy

a = np.array([[1,1], [0,1]])
b = np.array([[2,0],[3,4]])

1. Этот код вернет произведение элементов обоих массивов a * b.

2. Этот код вернет матричное произведение обоих массивов a @ b
   или a.dot(b).

Выводы

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