Руководство для начинающих по Numpy: Массивы

Почему вы все еще используете списки python, когда массивы numpy могут выполнить эту работу быстрее? 😮

В этом руководстве мы рассмотрим:

• Разница между списками Python и массивами Numpy
• Создание массивов
• Типы данных Numpy
• Типизация
  • Реальные и мнимые части
• Различные способы создания массивов в Numpy
  • Создание массивов из списков и объектов Iterable в Python
  • Автоматическое создание и заполнение массивов постоянными значениями
  • Заполнение массивов инкрементальной последовательностью
  • Заполнение массивов логарифмическими последовательностями
  • Матричные массивы

Разница между списками Python и массивами Numpy

Массив, в отличие от списков Python, — это структура данных, которая хранит коллекцию объектов одного типа данных. Для векторных вычислений массивы являются лучшим вариантом.

Почти все в Python хранится в виде объекта. В результате обычный объект int включает в себя ряд механизмов, которые позволяют ему функционировать. Numpy, с другой стороны, хранит данные, используя примитивные числовые типы языка C, что делает его быстрым для числовых вычислений и управления памятью.

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

Основной структурой данных в NumPy является ndarray (N-мерный массив). Данные, хранящиеся в ndarray, называются просто массивом.

Чтобы использовать numpy, вам нужно сначала установить библиотеку numpy, выполнив эту команду на вашей ячейке ввода Ipython:

или на терминале с помощью команды ниже:

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

Простым способом создания массива является использование функции numpy array().

code-block-0

# Creating an array with numpy

# import the numpy library
import numpy as np

# create an array of intergers
a = np.array([1, 2, 3]) 

Массив Numpy является однородным (все элементы в массиве имеют одинаковый тип данных). Структура данных ядра numpy для выражения массивов, класс ndarray, включает некоторые важные метаданные или характеристики о массиве. Среди них форма массива, его размер, тип данных, размерность и другие характеристики. Чтобы получить весь список атрибутов, доступных в доктрине ndarray, используйте функцию помощи help(numpy.ndarray) в вашем интерпретаторе.

Вот пример того, как эти атрибуты доступны и используются.

code-block-1

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

print(type(x))  # <class 'numpy.ndarray'>

print(x.shape)  # (2, 3) : 2 rows and 3 columns

print(x.ndim)   # 2 : 2D array

print(x.dtype)  # int32 or int64

print(x.size)   # 6  : array contains 6 elements

print(x.nbytes) # 24 : total size of the array 

Перейти к началу

---

Типы данных Numpy

Атрибут dtype уже был описан в предыдущем разделе. Все элементы массива имеют один и тот же тип данных (однородность). Ниже перечислены основные числовые типы данных, поддерживаемые numpy.

Рассмотрим несколько примеров создания массивов целых чисел, плавающих чисел и массивов с комплексными значениями.

code-block-2

import numpy as np

# create an interger-type array
a = np.array([10, 11, 12], dtype = np.int8)
print(a)
# Output: [10 11 12]

# create a float-type array
b = np.array([10, 11, 12], dtype = np.float16)
print(b)
# Output: [10. 11. 12.]

# create a cpmplex-type array
c = np.array([10, 11, 12], dtype = np.complex64)
print(c)
# Output: [10.+0.j 11.+0.j 12.+0.j]

Перейти к началу

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

Типизация

Преобразование одного типа данных в другой известно как приведение типов. В языке программирования C это также известно как преобразование данных или преобразование типов.

Единственный способ изменить dtype массива NumPy после его создания — это создать новую копию с содержимым массива, соответствующим типу. Для приведения массива к типу можно использовать функцию np.array или воспользоваться функцией astype(), что сделать очень просто:

code-block-3

In [1]: import numpy as np
In [2]: arr = np.array([2, 4, 6, 8], dtype= np.float16)

In [3]: arr
Out[3]: array([2., 4., 6., 8.], dtype=float16)

In [4]: arr.dtype
Out[4]: dtype('float16')

In [5]: # convert arr to integer-type
In [6]: arr = np.array(arr, dtype= np.int32)

In [7]: arr
Out[7]: array([2, 4, 6, 8])

In [8]: arr.dtype
Out[8]: dtype('int32')

In [9]: arr.astype(np.complex64)
Out[9]: array([2.+0.j, 4.+0.j, 6.+0.j, 8.+0.j], dtype=complex64) 

Тип данных массива arr был изменен с ‘float’ на ‘int’ в кодовом блоке-3.

Реальная и мнимая части

Атрибуты real и imag в экземплярах массивов NumPy используются для извлечения вещественных и мнимых компонентов массива соответственно:

code-block-4

In [1]: import numpy as np

In [2]: arr = np.array([1, 2, 3], dtype= np.complex64)

In [3]: arr
Out[3]: array([1.+0.j, 2.+0.j, 3.+0.j], dtype=complex64)

In [4]: arr.real
Out[4]: array([1., 2., 3.], dtype=float32)

In [5]: arr.imag
Out[5]: array([0., 0., 0.], dtype=float32)

Перейти к началу

---

Различные способы создания массивов в Numpy

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

Массивы могут быть созданы различными способами, в зависимости от приложения или случая использования. Одним из недостатков использования функции numpy.array() является то, что она может быть использована только для создания небольших массивов. Во многих случаях требуется построить массивы с членами, которые придерживаются ряда правил, например, заполненные постоянными значениями, растущими целыми числами, регулярно расположенными числами, случайными числами и так далее. В других ситуациях нам может понадобиться создавать массивы из данных, содержащихся в файле. Потребности многочисленны и разнообразны, и библиотека NumPy предлагает обширную коллекцию функций для создания массивов различного рода.
Перейти к началу

Создание массивов из списков и объектов Iterable в Python

Функция numpy.array() может быть использована для создания массива путем предоставления в качестве аргумента списков и итерируемых выражений.

code-block-5

In [1]: import numpy as np

In [2]: # Create a 1D array
In [3]: arr1 = [1, 2, 3, 4]
In [4]: arr1 = np.array(arr1)
In [5]: arr1.ndim  # returns dimension of arr1
Out[5]: 1
In [6]: arr1.shape
Out[6]: (4,)

In [7]: # Create a 2D array
In [8]: arr2 = [[1, 2, 3],[4, 5, 6]]
In [9]: arr2 = np.array(arr2)
In [10]: arr2.ndim
Out[10]: 2
In [11]: arr2.shape
Out[11]: (2, 3)

Перейти к началу

Автоматическое создание и заполнение массивов постоянными значениями

Функции np.zeros и np.ones создают и возвращают массивы нулей и единиц, соответственно. В качестве первого аргумента они принимают целое число или кортеж, который описывает количество записей в каждом измерении массива. Например, мы можем использовать для создания массива 4 x 3, заполненного нулями, и массива длиной 5, заполненного единицами.

code-block-6

In [1]: import numpy as np

In [2]: # Create a 4 x 3 array filled with zeros
In [3]: np.zeros((4, 3))
Out[3]: 
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

In [4]: One dimensional array filled with ones
In [4]: np.ones(5)
Out[4]: array([1., 1., 1., 1., 1.])

numpy.fill() и numpy.full() используются для создания и заполнения массива пользовательскими значениями.

code-block-7

In [5]: x1 = np.empty(5)
In [6]: x1.fill(3.0)
In [7]: x1
Out[7]: array([ 3., 3., 3., 3., 3.])

In [8]: x2 = np.full(5, 3.0)
In [9]: x2
Out[9]: array([ 3., 3., 3., 3., 3.])

Перейти к началу

Заполнение массивов с помощью инкрементной последовательности

Массивы с регулярно расположенными значениями между начальным и конечным значением часто требуются при численных расчетах. np.arange и np.linspace — две функции NumPy, которые можно использовать для создания таких массивов. Начальное и конечное значения являются первыми двумя аргументами в обеих функциях. Приращение является третьим аргументом в np.arange, а общее количество точек в массиве — третьим аргументом в np.linspace.

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

Вот пример:

code-block-8

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

In [2]: np.linspace(0, 10, 11)
Out[2]: array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])

Перейти к началу

Заполнение массивов логарифмическими последовательностями

Функция np.logspace аналогична np.linspace, за исключением того, что приращения между элементами массива распределяются логарифмически, а начальное и конечное значения являются значениями силы необязательного ключевого параметра base (который по умолчанию равен 10).

Вот как создать массив логарифмически разнесенных чисел от 1 до 100:

code-block-9

In [1]: # 5 data points between 10**0=1 to 10**2=100
In [2]: np.logspace(0, 2, 5) 
Out[3]: array([ 1. , 3.16227766, 10. , 31.6227766 , 100.])

Перейти к началу

Матричные массивы

Матрицы, часто известные как двумерные массивы, являются распространенным типом численных вычислений.
В NumPy есть несколько функций для создания обычных матриц. В частности, функция np.identity генерирует квадратную матрицу с единицами на диагонали и нулями везде.

code-block-10

In [1]: np.identity(4)
Out[1]: array([[ 1., 0., 0., 0.],
               [ 0., 1., 0., 0.],
               [ 0., 0., 1., 0.],
               [ 0., 0., 0., 1.]])

np.eye — аналогичная функция, которая строит матрицы с единицами на диагонали (по желанию со смещением). Это видно из примера ниже, который генерирует матрицы с ненулевыми диагоналями выше и ниже диагонали:

code-block-11

In [1]: np.eye(3, k=1)
Out[1]: array([[ 0., 1., 0.],
              [ 0., 0., 1.],
              [ 0., 0., 0.]])

In [2]: np.eye(3, k=-1)
Out[2]: array([[ 0., 0., 0.],
               [ 1., 0., 0.],
               [ 0., 1., 0.]])

Вы можете ознакомиться с другими функциями numpy в официальной документации numpy.

Теперь, когда мы поняли несколько вещей о массивах numpy, следите за моей следующей статьей об индексировании и нарезке массивов.

Счастливого Numpying!!! 😉