Статьи

Представляем NumPy

Декабрь 31, 2018

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

Фундаментальная идея NumPy — поддержка многомерных массивов. Таким образом, NumPy можно рассматривать как основу для численных вычислений в Python, и он был создан, чтобы позволить Python использоваться для решения математических и научных задач. Модуль NumPy предоставляет нам сотни полезных математических функций в дополнение к константам, таким как основание натуральных логарифмов ( e ) и pi ( π ).

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

Установка NumPy

Поскольку Python не поставляется в комплекте с NumPy, первым шагом к использованию этой библиотеки является ее установка. Это можно просто сделать, выполнив в командной строке следующую команду:

1
pip install numpy

Чтобы убедиться, что NumPy был успешно установлен, выполните следующие команды в IDLE Python:

Python-IDLE-Numpy

Если оператор import хотя бы успешно выполняется, то все готово!

Странный объект

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

Основными атрибутами ndarray являются тип данных ( dtype ), shape , size , size itemsize , data и ndim . Давайте узнаем, что означает каждый атрибут на примере.

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

create_array_numpy

Обратите внимание, что мы использовали функцию array для создания массива. Вывод вышеприведенного скрипта выглядит следующим образом:

array_numpy_output

Давайте теперь вернемся к нашим атрибутам.

DTYPE

dtype можно запустить, как показано в следующем операторе:

1
data_type = my_array.dtype

Вышеприведенный оператор вернет int32 в качестве типа данных. Это означает, что элементы массива имеют тип int32 . Я получаю 32 как я использую 32-битный Python. Если вы используете 64-битный Python, вы получите int64 , но в конце мы имеем дело с целыми числами.

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

Следующие примеры показывают, как мы можем конвертировать из одного типа в другой:

1
2
3
4
5
6
bool(35)
bool(0)
bool(-1)
float(True)
int(67.7)
float(87)

Вышеприведенные утверждения возвращают следующее:

1
2
3
4
5
6
True
False
True
1.0
67
87.0

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

форма

Атрибут shape возвращает кортеж размеров массива. Итак, следующее утверждение:

1
array_shape = my_array.shape

вернет (4,4) , что означает, что наш массив состоит из 4 строк и 4 столбцов.

размер

Атрибут size возвращает количество элементов в массиве. Таким образом, если мы введем:

1
array_size = my_array.size

в результате мы получим 16 , что означает, что в нашем массиве 16 элементов.

itemsize

itemsize возвращает размер одного элемента массива в байтах. Следующее утверждение:

1
array_item_size = my_array.itemsize

вернется 4 . Это означает, что каждый элемент массива имеет размер 4 байта.

данные

Атрибут data является буферным объектом Python, который указывает на начало данных массива. Если мы введем следующее:

1
array_location = my_array.data

мы получим следующее: <memory at 0x0000021E7E8D7EA0> .

ndim

Атрибут ndim возвращает количество измерений массива. Итак, набрав следующее утверждение:

1
array_dimension = my_array.ndim

вернет 2 , то есть массив состоит из двух измерений.

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

Пример 1

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

1
my_array = np.array( (1, 2, 3, 4, 5) )

Результат вышеупомянутого утверждения: [1 2 3 4 5] .

Пример 2

В этом примере я собираюсь переписать первый пример этого урока, но с использованием [ ] вместо ( ) , следующим образом:

numpy_array_square_brackets

Пример 3

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

1
2
3
import numpy as np
 
height_type = np.dtype([(‘height’, np.float)])

Если мы print(data_type) , мы получим следующее:

1
[(‘height’, ‘<f8’)]

Мы можем применить height_type к объекту ndarray следующим образом:

1
2
3
4
5
6
7
import numpy as np
 
height_type = np.dtype([(‘height’, np.float)])
my_array = np.array([(1.78,),(1.69,),(1.88,)], dtype = height_type)
 
# access content of height column
print(my_array[‘height’])

Выбор предметов

В этом разделе я собираюсь показать вам, как выбирать определенные элементы в массиве. Для нашего массива, показанного выше в разделе «ndarry Object», скажем, мы хотим выбрать элемент, расположенный в третьей строке и четвертом столбце. Мы сделаем это следующим образом:

1
my_array[2,3]

Помните, что индексирование здесь начинается с 0 , и поэтому мы написали [2,3] вместо [3,4] .

Подробнее о массивах NumPy

В этом разделе мы углубимся в изучение массивов NumPy.

Пустые (неинициализированные) массивы

Мы можем создать пустой массив, используя numpy.empty со следующим синтаксисом:

1
numpy.empty(shape, dtype, order)

Значения параметров в приведенном выше конструкторе следующие

  • Форма: форма (размеры) пустого массива.
  • dtype: желаемый тип вывода, который является необязательным.
  • Порядок: если вам нужен массив в стиле C (строка-мажор), вы должны набрать C ; если вам нужен массив в стиле FORTRAN (основной столбец), введите F

Итак, давайте создадим пустой [2,2] массив типа int . Мы можем сделать это следующим образом:

1
2
3
4
import numpy as np
 
empty_array = np.empty([2,2], dtype = int)
print(empty_array)

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

1
2
[[1852795252 111218]
[ 7500288 53018624]]

Массив, заполненный нулями

Чтобы создать массив, в котором все элементы являются нулями, мы используем numpy.zeros . Здесь конструктор имеет тот же синтаксис и параметры, что и в numpy.empty . Итак, если мы хотим создать массив [2,2] нулей типа int , мы можем сделать это следующим образом:

1
2
3
4
import numpy as np
 
zeros_array = np.zeros([2,2], dtype = int)
print(zeros_array)

Приведенный выше скрипт вернет следующее:

1
2
[[0 0]
[0 0]]

Массив со всеми элементами, имеющими значение 1 может быть просто создан так же, как и выше, но с numpy.ones .

Массивы с равномерно распределенными значениями в заданном диапазоне

Мы можем использовать numpy.arange для создания массива с равномерно распределенными значениями в указанном диапазоне. Конструктор имеет следующий формат:

1
numpy.arange(start, stop, step, dtype)

Ниже приведено значение каждого параметра:

  • Начало: это где начинается интервал. Значением по умолчанию является 0 .
  • Стоп: конец интервала, при условии, что это число не включено.
  • Шаг: интервал между значениями. Значением по умолчанию является 1 .
  • dtype: тип данных вывода. Если не указан, тип данных будет таким же, как и у ввода.

Давайте возьмем пример numpy.arange .

1
2
3
4
import numpy as np
 
my_array = np.arange(1,10)
print(my_array)

Результат приведенного выше сценария:

1
[1 2 3 4 5 6 7 8 9]

Изменение формы массива

Чтобы изменить форму массива, мы используем функцию numpy.reshape . Эта функция придает массиву новую форму без изменения его данных. Как показано в документации , функция имеет следующие атрибуты: numpy.reshape(a, newshape, order='C') , где a — это массив, который мы хотели бы изменить, newshape — это новая требуемая форма, при условии, что новая форма должен быть совместим с исходной формой, а order — это необязательный аргумент, который относится к порядку индекса, который мы хотели бы использовать как для чтения массива a и для того, как мы хотели бы поместить элементы в измененный массив.

C означает чтение / запись элементов с использованием C-подобного порядка индексов; F означает чтение / запись элементов с использованием Fortran-подобного порядка индексов, а A означает чтение / запись элементов в Fortran-подобном порядке индексов, если a является Fortran непрерывным в памяти, C-подобным порядком в противном случае.

Я знаю, что много рассказал в предыдущем абзаце, но концепция очень проста. Давайте возьмем наш оригинальный массив my_array и попробуем изменить его. Помните, что новый массив (измененный массив) должен быть совместим с исходным массивом. Например, my_array имеет форму (4,4) , то есть у нас есть 16 элементов в массиве, и новый массив должен иметь это количество элементов.

Мы можем изменить форму my_array , установив в ней восемь строк и два столбца следующим образом:

1
2
3
4
5
6
7
import numpy as np
my_array = np.array(((6, 12, 93, 2),
                     (5, 26, 78, 90),
                     (3, 12, 16, 22),
                     (5, 3, 1, 16)))
 
my_array_reshaped = np.reshape(my_array, (8,2))

В этом случае у нас будет следующий вывод, где у нас также есть 16 элементов.

1
2
3
4
5
6
7
8
[[ 6 12]
[93 2]
[ 5 26]
[78 90]
[ 3 12]
[16 22]
[ 5 3]
[ 1 16]]

Что, если мы напишем оператор перестановки следующим образом?

1
my_array_reshaped = np.reshape(my_array, (8,3))

В этом случае вы получите следующую ошибку:

1
ValueError: cannot reshape array of size 16 into shape (8,3)

Конкатенация массивов

Если мы хотим объединить два или более массивов одинаковой формы вдоль определенной оси, мы можем использовать функцию numpy.concatenate . Синтаксис этой функции: numnumpy.concatenate((a1, a2, ...), axis=0)y.concatenate . a1 и a2 — это массивы, имеющие одинаковую форму, а axis — это ось, вдоль которой будут объединяться массивы, при условии, что по умолчанию установлено значение 0 .

Опять же, давайте возьмем пример для упрощения концепции. В этом примере мы будем объединять (объединять) три массива.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
array_1 = np.array(((1, 2),
                   (3, 4)))
 
array_2 = np.array(((5, 6),
                   (7, 8)))
 
array_3 = np.array(((9, 10),
                   (11, 12)))
 
contacted_array = np.concatenate((array_1, array_2, array_3))
 
print(‘First Array: ‘)
print(array_1)
print(‘Second Array: ‘)
print(array_2)
print(‘Third Array: ‘)
print(array_3)
print(‘Concatenated Array: ‘)
print(contacted_array)

Вывод приведенного выше кода выглядит следующим образом:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
First Array:
[[1 2]
 [3 4]]
Second Array:
[[5 6]
 [7 8]]
Third Array:
[[ 9 10]
 [11 12]]
Concatenated Array:
[[ 1 2]
 [ 3 4]
 [ 5 6]
 [ 7 8]
 [ 9 10]
 [11 12]]

Расщепление массивов

В отличие от объединения массивов, как показано в предыдущем разделе, давайте посмотрим, как мы можем разбить (разделить) массив на несколько подмассивов. Это можно сделать с помощью следующей функции:

1
numpy.split(ary, indices_or_sections, axis=0)

ary — это массив, который нужно разделить на подмассивы. Что касается indices_or_sections , если это целое число N , массив будет разделен на N равных массивов вдоль оси . Если это одномерный массив отсортированных целых чисел, записи указывают, где вдоль оси разбит массив. axis — это ось, по которой следует делить

Следующий пример перевернет то, что мы сделали в предыдущем примере, то есть вернем составной массив в три составляющих:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
 
concatenated_array = np.array(((1, 2),
                       (3, 4),
                       (5, 6),
                       (7, 8),
                       (9, 10),
                       (11, 12)))
 
split_array = np.split(concatenated_array, 3)
 
print(‘Original Array:’)
print(concatenated_array)
print(‘Split Sub-arrays:’)
print(‘First Sub-array’)
print(split_array[0])
print(‘Second Sub-array’)
print(split_array[1])
print(‘Third Sub-array’)
print(split_array[2])

Вывод вышеприведенного скрипта:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
Original Array:
[[ 1 2]
 [ 3 4]
 [ 5 6]
 [ 7 8]
 [ 9 10]
 [11 12]]
Split Sub-arrays:
First Sub-array
[[1 2]
 [3 4]]
Second Sub-array
[[5 6]
 [7 8]]
Third Sub-array
[[ 9 10]
 [11 12]]

Вывод

Как мы видели в этом уроке, NumPy делает его очень гибким для работы с массивами. Учебное пособие было всего лишь царапиной на поверхности этой интересной библиотеки Python. NumPy по-прежнему имеет много других возможностей, чтобы извлечь максимальную пользу из этой библиотеки. Всесторонняя книга по этой теме от самого создателя NumPy — « Руководство по NumPy» .

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

40
Share: