Что такое numpy в python

NumPy в Python. Часть 1

Доброго времени суток, Хабр. Запускаю цикл статей, которые являются переводом небольшого мана по numpy, ссылочка. Приятного чтения.

Введение

NumPy это open-source модуль для python, который предоставляет общие математические и числовые операции в виде пре-скомпилированных, быстрых функций. Они объединяются в высокоуровневые пакеты. Они обеспечивают функционал, который можно сравнить с функционалом MatLab. NumPy (Numeric Python) предоставляет базовые методы для манипуляции с большими массивами и матрицами. SciPy (Scientific Python) расширяет функционал numpy огромной коллекцией полезных алгоритмов, таких как минимизация, преобразование Фурье, регрессия, и другие прикладные математические техники.

Установка

Если у вас есть Python(x, y) (Примечание переводчика: Python(x, y), это дистрибутив свободного научного и инженерного программного обеспечения для численных расчётов, анализа и визуализации данных на основе языка программирования Python и большого числа модулей (библиотек)) на платформе Windows, то вы готовы начинать. Если же нет, то после установки python, вам нужно установить пакеты самостоятельно, сначала NumPy потом SciPy. Установка доступна здесь. Следуйте установке на странице, там всё предельно понятно.

Немного дополнительной информации

Сообщество NumPy и SciPy поддерживает онлайн руководство, включающие гайды и туториалы, тут: docs.scipy.org/doc.

Импорт модуля numpy

Есть несколько путей импорта. Стандартный метод это — использовать простое выражение:

>>> import numpy

Тем не менее, для большого количества вызовов функций numpy, становится утомительно писать numpy.X снова и снова. Вместо этого намного легче сделать это так:

>>> import numpy as np

Это выражение позволяет нам получать доступ к numpy объектам используя np.X вместо numpy.X. Также можно импортировать numpy прямо в используемое пространство имен, чтобы вообще не использовать функции через точку, а вызывать их напрямую:

>>> from numpy import *

Однако, этот вариант не приветствуется в программировании на python, так как убирает некоторые полезные структуры, которые модуль предоставляет. До конца этого туториала мы будем использовать второй вариант импорта (import numpy as np).

Массивы

Главной особенностью numpy является объект array. Массивы схожи со списками в python, исключая тот факт, что элементы массива должны иметь одинаковый тип данных, как float и int. С массивами можно проводить числовые операции с большим объемом информации в разы быстрее и, главное, намного эффективнее чем со списками.

Создание массива из списка:

a = np.array([1, 4, 5, 8], float) >>> a array([ 1., 4., 5., 8.]) >>> type(a)

Здесь функция array принимает два аргумента: список для конвертации в массив и тип для каждого элемента. Ко всем элементам можно получить доступ и манипулировать ими так же, как вы бы это делали с обычными списками:

>>> a[:2] array([ 1., 4.]) >>> a[3] 8.0 >>> a[0] = 5. >>> a array([ 5., 4., 5., 8.])

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

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float) >>> a array([[ 1., 2., 3.], [ 4., 5., 6.]]) >>> a[0,0] 1.0 >>> a[0,1] 2.0

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

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float) >>> a[1,:] array([ 4., 5., 6.]) >>> a[:,2] array([ 3., 6.]) >>> a[-1:, -2:] array([[ 5., 6.]])

Метод shape возвращает количество строк и столбцов в матрице:

>>> a.shape (2, 3)

Метод dtype возвращает тип переменных, хранящихся в массиве:

>>> a.dtype dtype('float64')

Тут float64, это числовой тип данных в numpy, который используется для хранения вещественных чисел двойной точности. Так же как float в Python.

Метод len возвращает длину первого измерения (оси):

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

Метод in используется для проверки на наличие элемента в массиве:

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float) >>> 2 in a True >>> 0 in a False

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

>>> a = np.array(range(10), float) >>> a array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) >>> a = a.reshape((5, 2)) >>> a array([[ 0., 1.], [ 2., 3.], [ 4., 5.], [ 6., 7.], [ 8., 9.]]) >>> a.shape (5, 2)

Обратите внимание, метод reshape создает новый массив, а не модифицирует оригинальный.

Имейте ввиду, связывание имен в python работает и с массивами. Метод copy используется для создания копии существующего массива в памяти:

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

Списки можно тоже создавать с массивов:

>>> a = np.array([1, 2, 3], float) >>> a.tolist() [1.0, 2.0, 3.0] >>> list(a) [1.0, 2.0, 3.0]

Можно также переконвертировать массив в бинарную строку (то есть, не human-readable форму). Используйте метод tostring для этого. Метод fromstring работает в для обратного преобразования. Эти операции иногда полезны для сохранения большого количества данных в файлах, которые могут быть считаны в будущем.

>>> a = array([1, 2, 3], float) >>> s = a.tostring() >>> s '\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@' >>> np.fromstring(s) array([ 1., 2., 3.])

Заполнение массива одинаковым значением.

>>> a = array([1, 2, 3], float) >>> a array([ 1., 2., 3.]) >>> a.fill(0) >>> a array([ 0., 0., 0.])

Транспонирование массивов также возможно, при этом создается новый массив:

>>> a = np.array(range(6), float).reshape((2, 3)) >>> a array([[ 0., 1., 2.], [ 3., 4., 5.]]) >>> a.transpose() array([[ 0., 3.], [ 1., 4.], [ 2., 5.]])

Многомерный массив можно переконвертировать в одномерный при помощи метода flatten:

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

Два или больше массивов можно сконкатенировать при помощи метода concatenate:

>>> a = np.array([1,2], float) >>> b = np.array([3,4,5,6], float) >>> c = np.array([7,8,9], float) >>> np.concatenate((a, b, c)) array([1., 2., 3., 4., 5., 6., 7., 8., 9.])

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

>>> a = np.array([[1, 2], [3, 4]], float) >>> b = np.array([[5, 6], [7,8]], float) >>> np.concatenate((a,b)) array([[ 1., 2.], [ 3., 4.], [ 5., 6.], [ 7., 8.]]) >>> np.concatenate((a,b), axis=0) array([[ 1., 2.], [ 3., 4.], [ 5., 6.], [ 7., 8.]]) >>> np.concatenate((a,b), axis=1) array([[ 1., 2., 5., 6.], [ 3., 4., 7., 8.]])

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

>>> a = np.array([1, 2, 3], float) >>> a array([1., 2., 3.]) >>> a[:,np.newaxis] array([[ 1.], [ 2.], [ 3.]]) >>> a[:,np.newaxis].shape (3,1) >>> b[np.newaxis,:] array([[ 1., 2., 3.]]) >>> b[np.newaxis,:].shape (1,3)

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

На этом у нас конец первой части перевода. Спасибо за внимание.

NumPy

NumPy — это библиотека Python, которую применяют для математических вычислений: начиная с базовых функций и заканчивая линейной алгеброй. Полное название библиотеки — Numerical Python extensions, или «Числовые расширения Python».

Освойте профессию
«Python-разработчик»

У этой библиотеки есть несколько важных особенностей, которые сделали ее популярным инструментом. Во-первых, исходный ее код в свободном доступе хранится на GitHub, поэтому NumPy называют open-source модулем для Python.

Во-вторых, библиотека написана на языках C и Fortran. Это компилируемые языки (языки программирования, текст которых преобразуется в машинный код — набор инструкций для конкретного типа процессора. Преобразование происходит с помощью специальной программы-компилятора, благодаря нему вычисления на компилируемых языках происходят быстрее), на которых вычисления производятся гораздо быстрее и эффективнее, чем на интерпретируемых языках (языки программирования, которые не заточены под конкретный тип процессора и могут быть запущены на разных типах устройств). К этим языкам относится и сам Python.

Python-разработчик

Освойте Python, самый популярный язык программирования

Где используется NumPy

• Научные вычисления. NumPy пользуются ученые для решения многомерных задач в математике и физике, биоинформатике, вычислительной химии и даже когнитивной психологии.
• Создание новых массивных библиотек. На основе NumPy появляются новые типы массивов, возможности которых выходят за рамки того, что предлагает библиотека. Например, библиотеки Dask, CuPy или XND.
• Data Science. В основе экосистемы для анализа данных лежит NumPy. Библиотека используется на всех этапах работы с данными: извлечение и преобразование, анализ, моделирование и оценка, репрезентация.

• Machine Learning. Библиотеки для машинного обучения scikit-learn и SciPy тоже работают благодаря вычислительным мощностям NumPy.
• Визуализация данных. По сравнению непосредственно с Python возможности NumPy позволяют исследователям визуализировать наборы данных, которые гораздо больше по размеру. Например, библиотека лежит в основе системы PyViz, которая включает в себя десятки программ для визуализации.

Как работает NumPy

Для начала разберемся в устройстве массивов, которые обрабатывает NumPy. Рассмотрим однородный двумерный массив. Он выглядит как простая таблица — две оси значений и ячейки внутри (элементы массива). Если появится третья ось, то массив станет трехмерным. Важное условие — все элементы должны иметь единый тип данных, например только целые числа.

Конечно, кроме двумерных массивов, библиотека NumPy обрабатывает и другие, с различным количеством осей. Эту вариативность обозначают числом N, как любую переменную в математической задаче. Поэтому обычно говорят, что NumPy работает с N-мерными массивами данных.

Читайте также Кому и для чего нужен Python?

С этими данными NumPy производит вычисления, используя математические функции, генераторы случайных чисел, линейные уравнения или преобразования Фурье. Например, можно решить систему уравнений методом linalg.solve:

import numpy as np
left = np.array( [ [1, 3], [2, -4] ] )
right = np.array( [9, 8] )
np.linalg.solve(left, right)
Ответ: array([6., 1.])

Как и сам Python, библиотека NumPy отличается простотой в изучении и использовании. Для начала работы достаточно освоить концепцию массивов. Например, в базовых арифметических вычислениях есть способ обработки массивов, который называют ‎трансляцией‎ или broadcasting.

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

Подробной документации NumPy на русском языке до сих пор нет, а в рунете можно найти только краткие выжимки, в которых упущены многие моменты. Поэтому, чтобы стать специалистом высокого уровня в Data Science или Machine Learning, придется подтянуть английский. Начать можно с информации на официальном сайте.

Станьте разработчиком на Python и решайте самые разные задачи: от написания кода до автоматизации процессов

Как загрузить библиотеку?

Для загрузки NumPy просто введите в командной строке: import numpy as np. Не удивляйтесь, если библиотека окажется установленной, ведь модуль NumPy входит в состав множества пакетов и других библиотек.

Конечно, можно написать просто import numpy, ошибки в этом не будет. Но np — это общепринятое название, которое стало правилом и упростило процесс написания кода, поэтому, один раз прописав import numpy as np, в последующих строках можно использовать np вместо numpy.

Python-разработчик

Освойте Python с нуля. Подготовим к трудоустройству: дадим много практики, реальные проекты для портфолио, поможем с резюме. Лучшие студенты пройдут стажировки в проектах компаний-партнеров.

Статьи по теме:

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

Самоучитель по Python NumPy

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

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

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

Что такое NumPy?

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

Как установить NumPy Python?

Установка библиотеки NumPy — несложный процесс. Для этого можно использовать программу pip. Перейдите в командную строку и введите следующее:

pip install numpy If you are using Anaconda distribution, then you can use conda to install NumPy. conda install numpy Once the installation is complete, you can verify it by importing the NumPy library in the python interpreter. One can use the numpy library by importing it as shown below. import numpy If the import is successful, then you will see the following output. >>> import numpy >>> numpy.__version__ '1.17.2'

От редакции Pythonist: об установке пакетов в Python читайте в статьях «Установка пакетов Python при помощи PIP» и «Как вручную установить пакет в Python».

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

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

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

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

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

Давайте рассмотрим, как создавать, копировать и просматривать массивы NumPy, изменять их форму и выполнять итерации над ними.

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

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

import numpy as np arr = np.array([1, 2, 3, 4, 5]) print(arr) # Вывод: # [1 2 3 4 5]

Для создания массива в функцию array также можно передать кортеж:

import numpy as np arr = np.array((1, 2, 3, 4, 5)) print(arr) # Вывод: # [1 2 3 4 5]

Размерные массивы

0-мерные массивы

Следующий код создаст нульмерный массив со значением 36.

import numpy as np arr = np.array(36) print(arr) # Вывод: # 36

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

Массив, элементами которого являются нульмерные массивы, является одномерным или 1-D массивом.

Приведенный ниже код создает одномерный массив.

import numpy as np arr = np.array([1, 2, 3, 4, 5]) print(arr) # Вывод: # [1 2 3 4 5]

Двумерные массивы

Двумерные массивы — это массивы, элементами которых являются одномерные массивы. Следующий код создаст двумерный массив, значениями которого будут 1, 2, 3 и 4, 5, 6.

import numpy as np 3 arr1 = np.array([[1, 2, 3], [4, 5, 6]]) print(arr1) # Вывод: # [[1 2 3] # [4 5 6]]

Трехмерные массивы

Рассмотрим пример создания трехмерного массива из двух двумерных массивов:

import numpy as np arr1 = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]]) print(arr1) # Вывод: # [[[1 2 3] # [4 5 6]] # [[1 2 3] # [4 5 6]]]

Для определения размерности массива можно использовать ndim :

import numpy as np a = np.array(36) d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]]) print(a.ndim) print(d.ndim) # Вывод: # 0 # 3

Операции с использованием NumPy

Используя NumPy, разработчик может выполнять:

• Математические и логические операции над массивами
• Преобразования Фурье и процедуры для работы с формами
• Операции, связанные с линейной алгеброй. NumPy имеет встроенные функции для линейной алгебры и генерации случайных чисел.

NumPy — замена MatLab

NumPy часто используется вместе с такими пакетами, как SciPy (Scientific Python) и Matplotlib (библиотека для построения графиков). Эта комбинация широко применяется в качестве замены MatLab, популярной платформы для технических вычислений.

ndarray

Наиболее важным объектом, определенным в NumPy, является N-мерный тип массива, называемый ndarray . Он описывает коллекцию элементов одного типа. Доступ к элементам коллекции осуществляется с помощью индекса.

Каждый элемент массива ndarray занимает тот же размер, что и блок в памяти. Каждый элемент ndarray представляет собой объект типа data (называемый dtype ).

Экземпляр класса ndarray может быть создан с помощью различных методов создания массивов (их мы еще рассмотрим). Базовый ndarray создается с использованием функции array в NumPy следующим образом: numpy.array() .

Это создает ndarray из любого объекта с реализацией интерфейса массива или из любого метода, возвращающего массив.

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

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

В блоке памяти элементы располагаются в основном порядке строк (стиль C) или в основном порядке столбцов (стиль FORTRAN или MatLab).

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

Для лучшего понимания рассмотрим примеры.

Пример 1

import numpy as np a = np.array([1,2,3]) print a # Вывод: # [1, 2, 3]

Пример 2

# more than one dimensions import numpy as np a = np.array([[1, 2], [3, 4]]) print a # Вывод: # [[1, 2] # [3, 4]]

Пример 3

# minimum dimensions import numpy as np a = np.array([1, 2, 3,4,5], ndmin = 2) print a # Вывод: # [[1, 2, 3, 4, 5]]

Пример 4

# dtype parameter import numpy as np a = np.array([1, 2, 3], dtype = complex) print a # Вывод: # [ 1.+0.j, 2.+0.j, 3.+0.j]

Типы данных в NumPy

Здесь приведен список различных типов данных в NumPy:

1. bool_ — булев тип данных (True или False), значение, хранящееся в виде байта
2. int_ — целочисленный тип по умолчанию (такой же, как long в C; обычно либо int64, либо int32)
3. intc — идентичен C int (обычно int32 или int64)
4. intp — целое число, используемое для индексации (аналогично C ssize_t; обычно int32 или int64)
5. int8 — байт (от -128 до 127)
6. int16 — целое число (от -32768 до 32767)
7. float_ — сокращение для float64
8. float64 — плавающее число двойной точности: знаковый бит, экспонента 11 бит, мантисса 52 бита
9. complex_ — сокращение для complex128
10. complex64 — комплексное число, представленное двумя 32-битными числами с плавающей запятой (вещественная и мнимая компоненты)
11. complex128 — комплексное число, представленное двумя 64-битными числами с плавающей запятой (действительная и мнимая составляющие).

Числовые типы NumPy — это экземпляры объектов dtype (data-type), каждый из которых обладает уникальными характеристиками. Типы dtypes доступны в виде np.bool_ , np.float32 и т.д.

Объекты типа данных (dtype)

Объект типа данных описывает интерпретацию фиксированного блока памяти, соответствующего массиву, в зависимости от следующих аспектов:

• Тип данных (целое число, число с плавающей запятой или объект Python)
• Размер данных
• Порядок следования байтов (little-endian или big-endian).
• В случае структурированного типа — имена полей, тип данных каждого поля и часть блока памяти, занимаемая каждым полем
• Если тип данных является подмассивом, то его форма и тип данных.

Порядок следования байтов определяется префиксом ‘’ к типу данных. ‘’ означает, что кодировка big-endian (старший байт хранится по наименьшему адресу).

Объект dtype строится с использованием следующего синтаксиса:

numpy.dtype(object, align, copy)

Он принимает следующие параметры:

• object — преобразуемый в объект тип данных
• align — если значение равно True, то добавляется выравнивание (padding) для поля, чтобы сделать его аналогичным C-структуре.
• copy — создает новую копию объекта dtype. Если False, то результатом будет ссылка на встроенный объект типа данных

Пример 1

# using array-scalar type import numpy as np dt = np.dtype(np.int32) print dt # Вывод: # int32

Пример 2

#int8, int16, int32, int64 can be replaced by equivalent string 'i1', 'i2','i4', etc. import numpy as np dt = np.dtype('i4') print dt # Вывод: # int32

Пример 3

# using endian notation import numpy as np dt = np.dtype('>i4') print dt # Вывод: # >i4

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

Пример 4

# first create structured data type import numpy as np dt = np.dtype([('age',np.int8)]) print dt # Вывод: # [('age', 'i1')]

Пример 5

# now apply it to ndarray object import numpy as np dt = np.dtype([('age',np.int8)]) a = np.array([(10,),(20,),(30,)], dtype = dt) print a # Вывод: # [(10,) (20,) (30,)]

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

• ‘b’ — булевый (логический) тип данных
• ‘i’ — (знаковый) целочисленный тип данных
• ‘u’ — беззнаковый целочисленный тип данных
• ‘f’ — тип данных с плавающей запятой (вещественные числа)
• ‘c’ — комплексный тип данных с плавающей запятой
• ‘m’ — тип данных timedelta (разница между двумя моментами времени)
• ‘M’ — тип данных datetime (дата и время)
• ‘O’ — тип данных для объектов Python
• ‘S’, ‘a’ — тип данных для байтовой строки (ASCII-строки)
• ‘U’ — тип данных для строк Unicode
• ‘V’ — тип данных для необработанных данных (пустой тип)

Давайте также рассмотрим различные атрибуты массивов в NumPy.

ndarray.shape

Этот атрибут массива возвращает кортеж, состоящий из размеров массива. Он также может быть использован для изменения размеров массива.

Пример 1

import numpy as np a = np.array([[1,2,3],[4,5,6]]) print a.shape # Вывод: # (2, 3)

Пример 2

# this resizes the ndarray import numpy as np a = np.array([[1,2,3],[4,5,6]]) a.shape = (3,2) print a # Вывод: # [[1, 2][3, 4][5, 6]]

ndarray.ndim

Этот атрибут массива возвращает количество размерностей массива.

Пример 1

# an array of evenly spaced numbers import numpy as np a = np.arange(24) print a # Вывод: # [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]

Пример 2

# this is one dimensional array import numpy as np a = np.arange(24) a.ndim # now reshape it b = a.reshape(2,4,3) print b # b is having three dimensions

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

[[[ 0, 1, 2] [ 3, 4, 5] [ 6, 7, 8] [ 9, 10, 11]] [[12, 13, 14] [15, 16, 17] [18, 19, 20] [21, 22, 23]]]

numpy.itemsize

Этот атрибут массива возвращает длину каждого элемента массива в байтах.

Пример 1

# dtype of array is int8 (1 byte) import numpy as np x = np.array([1,2,3,4,5], dtype = np.int8) print x.itemsize # Вывод: # 1

Пример 2

# dtype of array is now float32 (4 bytes) import numpy as np x = np.array([1,2,3,4,5], dtype = np.float32) print x.itemsize # Вывод: # 4

numpy.flags

Объект ndarray имеет следующие атрибуты:

Текущие значения атрибутов возвращаются функцией flags . В следующем примере показаны текущие значения флагов.

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

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

C_CONTIGUOUS : True F_CONTIGUOUS : True OWNDATA : True WRITEABLE : True ALIGNED : True UPDATEIFCOPY : False

Методы создания массивов NumPy

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

numpy.empty()

Создает неинициализированный массив заданной формы и dtype. Вот пример с параметрами:

numpy.empty(shape, dtype = float, order = 'C').

Функция принимает следующие параметры:

• shape — форма пустого массива в виде целого числа или кортежа целых чисел
• dtype — желаемый тип данных для выходного массива. Необязательный параметр
• order — может иметь значение ‘C’ для массива в стиле C (по строкам) или ‘F’ для массива в стиле Fortran (по столбцам)

Пример

В следующем коде показан пример пустого массива.

import numpy as np x = np.empty([3,2], dtype = int) print x # Вывод: # [[22649312 1701344351] [1818321759 1885959276] [16779776 156368896]]

numpy.zeros

Возвращает новый массив заданного размера, заполненный нулями.

numpy.zeros(shape, dtype = float, order = 'C')

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

• shape — форма пустого массива в виде целого числа или последовуательности целых чисел
• dtype — желаемый тип данных для выходного массива. Необязательный параметр
• order — может иметь значение ‘C’ для массива в стиле C (по строкам) или ‘F’ для массива в стиле Fortran (по столбцам)

Пример

# array of five ones. Default dtype is float import numpy as np x = np.ones(5) print x # Вывод: # [ 1. 1. 1. 1. 1.]

Индексы и срезы в NumPy

К содержимому объекта ndarray можно обратиться, а также изменить его при помощи индексов и срезов, подобно встроенным в Python объектам-контейнерам.

Как упоминалось ранее, элементы в объекте ndarray используют индексацию с нуля. Доступны три типа индексации: доступ к полям, базовые срезы и расширенная индексация.

Базовые срезы являются расширением основного концепта срезов в Python для n-мерных массивов. Объект среза Python создается путем передачи параметров start , stop и step встроенной функции slice . Этот объект среза передается массиву для извлечения части массива.

Пример 1

import numpy as np a = np.arange(10) s = slice(2,7,2) print a[s] # Вывод: # [2 4 6]

В приведенном выше примере объект ndarray создается с помощью функции arange() . Затем определяется объект среза с значениями start, stop и step равными 2, 7 и 2 соответственно. Когда этот объект среза передается в ndarray , из него извлекается часть, начиная с индекса 2 до 7 с шагом 2.

Тот же результат можно получить, передав параметры среза, разделенные двоеточием (start:stop:step) , непосредственно в объект ndarray .

Пример 2

import numpy as np a = np.arange(10) b = a[2:7:2] print b # Вывод: # [2 4 6]

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

Пример 3

# slice single item import numpy as np a = np.arange(10) b = a[5] print b # Вывод: # 5

Пример 4

# slice items starting from index import NumPy as np a = np.arange(10) print a[2:] # Вывод: # [2 3 4 5 6 7 8 9]

Пример 5

# slice items between indexes import numpy as np a = np.arange(10) print a[2:5] # Вывод: # [2 3 4]

Приведенное выше описание применимо и к многомерному массиву ndarray.

Расширенное индексирование

Можно сделать выборку из ndarray, которая является некортежной последовательностью, объектом ndarray с типом данных integer или Boolean или кортежем, в котором хотя бы один элемент является последовательностью. Расширенная индексация всегда возвращает копию данных. В отличие от этого, срез представляет только вид (view) данных, а не создает копию.

Существует два типа расширенного индексирования: Integer и Boolean.

Целочисленное индексирование

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

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

Пример 1

import numpy as np x = np.array([[1, 2], [3, 4], [5, 6]]) y = x[[0,1,2], [0,1,0]] print y # Вывод: # [1 4 5]

В выборку попадают элементы по адресам (0,0), (1,1) и (2,0) из первого массива.

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

Булева индексация массива (Boolean Array Indexing)

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

Пример 1

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

import numpy as np x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]]) print 'Our array is:' print x print '\n' # Now we will print the items greater than 5 print 'The items greater than 5 are:' print x[x > 5]

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

Our array is: [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]] The items greater than 5 are: [ 6 7 8 9 10 11]

Broadcasting в NumPy

Термин «broadcasting» относится к возможности NumPy обрабатывать массивы разных форматов во время арифметических операций.

Арифметические операции над массивами обычно выполняются на соответствующих элементах. Если два массива имеют одинаковую форму, то эти операции выполняются без проблем.

Пример 1

import numpy as np a = np.array([1,2,3,4]) b = np.array([10,20,30,40]) c = a * b print c # Вывод: # [10 40 90 160]

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

Трансляция возможна, если выполняются следующие правила:

• Массив с меньшим ndim получает в своей форме значение ‘1’.
• Размер в каждом измерении выходной формы является максимальным из размеров входной формы в этом измерении.
• Входные данные могут быть использованы в вычислениях, если их размер в определенном измерении совпадает с размером вывода или если их значение точно равно 1.
• Если вход имеет размерность 1, то первая запись данных в этой размерности используется для всех вычислений по этой размерности.

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

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

Итерирование по массиву в NumPy

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

Создадим массив 3X4 с помощью функции arrange() и выполним итерацию по нему с помощью nditer .

import numpy as np # Создаем массив 3x4 с помощью функции arange() array = np.arange(12).reshape(3, 4) # Выполняем итерацию по массиву с помощью nditer for element in np.nditer(array): print(element, end=' ')

Итерация по массивам возможна с помощью цикла for.

Пример 1

import numpy as np arr1 = np.array([1, 2, 3]) for i in arr1: print(i) # Вывод: # 1 # 2 # 3

Пример 2

import numpy as np arr = np.array([[4, 5, 6], [1, 2, 3]]) for x in arr: print(x) # Вывод: # [4, 5, 6] # [1, 2, 3]

Пример 3

import numpy as np array1 = np.array([[1, 2, 3], [4, 5, 6]]) for x in array1: for y in x: print(y)

1 2 3 4 5 6

Манипуляции с массивами в NumPy

Для манипулирования элементами объекта ndarray в пакете NumPy имеется несколько процедур. Их можно разделить на следующие типы:

• Изменение формы
• Операции транспонирования
• Изменение размеров
• Объединение массивов
• Разбиение массивов
• Добавление/удаление элементов
• Побитовые операции

Давайте рассмотрим несколько примеров применения этих функций.

Переформирование массивов NumPy

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

Из одномерного в двумерный

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

import numpy as np array_1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) newarr1 = array_1.reshape(3, 4) print(newarr1) # Вывод: # [[ 1 2 3 4] # [ 5 6 7 8] # [ 9 10 11 12]]

Из одномерного в трехмерный

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

import numpy as np array_1= np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) newarr1 = array_1.reshape(2, 3, 2) print(newarr1)

[[[ 1 2] [ 3 4] [ 5 6]] [[ 7 8] [ 9 10] [11 12]]]

Сглаживание

Преобразование массивов большей размерности в одномерные называется сглаживанием массивов.

import numpy as np arr1= np.array([[4,5,6], [7, 8, 9]]) newarr1 = arr1.reshape(-1) print(newarr1) # Вывод: # [1 2 3 4 5 6]

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

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

Если параметр axis не указан, по умолчанию он принимает значение 0, что означает объединение массивов вдоль первой оси (строки).

import numpy as np arr1 = np.array([1, 2, 3]) arr2 = np.array([4, 5, 6]) finalarr = np.concatenate((arr1, arr2)) print(finalarr) # Вывод: # [1 2 3 4 5 6]

Следующий код объединяет указанные массивы вдоль строк:

import numpy as np arr1 = np.array([[1, 2], [3, 4]]) arr2 = np.array([[5, 6], [7, 8]]) finalarr = np.concatenate((arr1, arr2), axis=1) print(finalarr) # Вывод: # [[1 2 5 6] # [3 4 7 8]]

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

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

Для этой операции используется функция array_split() , которой необходимо передать количество разбиений вместе с массивом.

import numpy as np arr1 = np.array([7, 8, 3, 4, 1, 2]) finalarr = np.array_split(arr1, 3) print(finalarr) # Вывод: # [array([7, 8]), array([3, 4]), array([1, 2])]

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

import numpy as np array_1 = np.array([4, 5, 6,1,2,3]) finalarr = np.array_split(array_1, 4) print(finalarr) # Вывод: # [array([4, 5]), array([6, 1]), array([2]), array([3])]

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

Функция array_split() вернет массив, содержащий подмассивы.

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

import numpy as np array1 = np.array([4, 5, 6,7,8,9]) finalarr = np.array_split(array1, 3) print(finalarr[0]) print(finalarr[1]) # Вывод: # [4 5] # [6 7]

Разбиение двумерных массивов происходит аналогично. Попробуйте передать двумерный массив в array_split() .

import numpy as np arr1 = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]]) finalarr = np.array_split(arr1, 3) print(finalarr)

[array([[1, 2], [3, 4]]), array([[5, 6], [7, 8]]), array([[ 9, 10], [11, 12]])]

Поиск в массиве NumPy

Для поиска в массиве используется метод where() . Он возвращает индекс значения, переданного в метод.

Приведенный ниже код вернет кортеж, указывающий на то, что элемент 4 находится по адресам 3, 5 и 6

import numpy as np arr1 = np.array([1, 2, 3, 4, 5, 4, 4]) y = np.where(arr1 == 4) print(y) # Вывод: # (array([3, 5, 6]),)

Математические функции в NumPy

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

Тригонометрические функции

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

Пример

import numpy as np a = np.array([0,30,45,60,90]) print 'Sine of different angles:' # Convert to radians by multiplying with pi/180 print np.sin(a*np.pi/180) print '\n' print 'Cosine values for angles in array:' print np.cos(a*np.pi/180) print '\n' print 'Tangent values for given angles:' print np.tan(a*np.pi/180)

Sine of different angles: [ 0. 0.5 0.70710678 0.8660254 1. ] Cosine values for angles in array: [ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 6.12323400e-17] Tangent values for given angles: [ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00 1.63312394e+16]

Функции arcsin , arcos и arctan возвращают тригонометрические обратные значения sin, cos и tan заданного угла. Результаты этих функций можно проверить с помощью функции numpy.degrees() , которая преобразует радианы в градусы.

Функции для округления

Функция numpy.around(a,decimals) возвращает значение, округленное до нужной точности. Функция принимает следующие параметры:

• a — входные данные
• decimals — количество десятичных знаков для округления. По умолчанию равно 0. Если отрицательное, целое число округляется до позиции слева от десятичной точки.

Статистические функции в NumPy

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

Например, функции numpy.amin() и numpy.amax() возвращают минимальное и максимальное значение из элементов заданного массива вдоль указанной оси.

Пример

import numpy as np a = np.array([[3,7,5],[8,4,3],[2,4,9]]) print 'Our array is:' print a print '\n' print 'Applying amin() function:' print np.amin(a,1) print '\n' print 'Applying amin() function again:' print np.amin(a,0) print '\n' print 'Applying amax() function:' print np.amax(a) print '\n’ print 'Applying amax() function again:' print np.amax(a, axis = 0)

В результате будет получен следующий вывод:

Our array is: [[3 7 5] [8 4 3] [2 4 9]] Applying amin() function: [3 3 2] Applying amin() function again: [2 4 3] Applying amax() function: 9 Applying amax() function again: [8 7 9]

Функция numpy.ptp() возвращает диапазон (максимум-минимум) значений вдоль оси.

import numpy as np a = np.array([[3,7,5],[8,4,3],[2,4,9]]) print 'Our array is:' print a print '\n' print 'Applying ptp() function:' print np.ptp(a) print '\n' print 'Applying ptp() function along axis 1:' print np.ptp(a, axis = 1) print '\n' print 'Applying ptp() function along axis 0:' print np.ptp(a, axis = 0) numpy.percentile()

Процентиль (англ. Percentile) — это значение, которое заданная случайная величина не превышает с фиксированной вероятностью, заданной в процентах.

Функция numpy.percentile() принимает следующие аргументы:

• a — входной массив
• q — процентиль, который нужно вычислить. Должен быть в диапазоне от 0 до 100
• axis — ось, по которой будет вычисляться процентиль

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

В следующей таблице показано сравнение трех алгоритмов сортировки:

Функция numpy.sort(a, axis, kind, order) возвращает отсортированную копию входного массива. Она имеет следующие параметры:

• a — массив, который нужно отсортировать
• axis — ось, по которой нужно произвести сортировку. Если значение None, массив сплющивается и сортируется по последней оси
• kind — по умолчанию используется алгоритм quicksort
• order — если массив содержит поля (структурированный массив), указывает порядок полей для сортировки

Свайп байтов в NumPy

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

Функция numpy.ndarray.byteswap() переключается между двумя представлениями: big-endian и little-endian.

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

Разница между копией (copy) и представлением (view) массива в NumPy заключается в том, что представление является просто представлением исходного массива, в то время как копия является новым массивом.

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

Давайте разберемся в этом на примерах.

Создание копии:

import numpy as np arr1 = np.array([1, 2, 3, 4, 5]) y = arr1.copy() arr1[0] = 36 print(arr1) print(y) # Вывод: # [42 2 3 4 5] # [1 2 3 4 5]

Создание представления:

import numpy as np arr1 = np.array([1, 2, 3, 4, 5]) y= arr1.view() arr1[0] = 36 print(arr1) print(y) # Вывод: # [36 2 3 4 5] # [36 2 3 4 5]

Обратите внимание на вывод: изменения, внесенные в исходный массив, отражаются и в представлении.

Матричная библиотека

Пакет NumPy содержит матричную библиотеку numpy.matlib . В этом модуле есть функции, возвращающие матрицы вместо объектов ndarray .

matlib.empty()

Функция matlib.empty(shape, dtype, order) возвращает новую матрицу без инициализации записей. Функция принимает следующие параметры:

• shape — целое число или кортеж целых чисел, определяющий форму новой матрицы,
• dtype — тип данных выходной матрицы (необязательный параметр),
• order — порядок данных (row-major или column-major, ‘C’ или ‘F’).

Пример

import numpy.matlib import numpy as np print np.matlib.empty((2,2)) # filled with random data

В результате будет получен следующий результат:

[[ 2.12199579e-314, 4.24399158e-314] [ 4.24399158e-314, 2.12199579e-314]]

numpy.matlib.eye()

Функция numpy.matlib.eye(n, M,k, dtype) возвращает матрицу, в которой единицы расположены на главной диагонали, а в остальных местах нули. Функция принимает следующие параметры:

• n — количество строк в результирующей матрице,
• M — количество столбцов (по умолчанию равно n ),
• k — индекс диагонали,
• dtype — тип данных выходной матрицы.

Пример

import numpy.matlib import numpy as np print np.matlib.eye(n = 3, M = 4, k = 0, dtype = float)

В результате будет получен следующий результат:

[[ 1. 0. 0. 0.] [ 0. 1. 0. 0.] [ 0. 0. 1. 0.]]

NumPy и построение графиков

Matplotlib — это библиотека построения графиков для Python. Она используется вместе с NumPy для создания среды, которая является эффективной опенсорсной альтернативой MatLab. Она также может использоваться с такими графическими инструментами, как PyQt и wxPython.

Модуль Matplotlib был впервые написан Джоном Д. Хантером. С 2012 года основным разработчиком является Майкл Дроттбум. В настоящее время Matplotlib 1.5.1 является стабильной версией. Пакет доступен как в бинарном дистрибутиве, так и в виде исходного кода на сайте www.matplotlib.org.

Традиционно пакет импортируется в Python-скрипт следующим образом:

from matplotlib import pyplot as plt

Здесь pyplot() — важнейшая функция библиотеки matplotlib, которая используется для построения двумерных данных. Следующий скрипт строит график уравнения y = 2x + 5

Пример:

import numpy as np from matplotlib import pyplot as plt x = np.arange(1,11) y = 2 * x + 5 plt.title("Matplotlib demo") plt.xlabel("x axis caption") plt.ylabel("y axis caption") plt.plot(x,y) plt.show()

Объект ndarray x создается с помощью функции np.arange() для значений на оси x . Соответствующие значения на оси y хранятся в другом объекте ndarray y . Эти значения отображаются с использованием функции plot() из подмодуля pyplot пакета matplotlib.

Графическое представление выводится на экран с помощью функции show() .

Вместо линейного графика значения можно отображать дискретно, добавив в функцию plot() строку форматирования.

numpy.histogram()

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

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

Прим. переводчика: англ. «bin» применительно к гистограммам переводится как «столбец гистограммы».

import numpy as np a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) np.histogram(a,bins = [0,20,40,60,80,100]) hist,bins = np.histogram(a,bins = [0,20,40,60,80,100]) print hist print bins # Вывод: # [3 4 5 2 1] # [0 20 40 60 80 100]

plt()

Matplotlib может преобразовать это числовое представление гистограммы в график. Функция plt() подмодуля pyplot принимает в качестве параметров массив, содержащий данные, и массив bin и преобразует их в гистограмму.

from matplotlib import pyplot as plt import numpy as np a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) plt.hist(a, bins = [0,20,40,60,80,100]) plt.title("histogram") plt.show()

Ввод и вывод данных в NumPy

Объекты ndarray могут быть сохранены на диске или считаны с него. Доступны следующие функции ввода-вывода:

• функции load() и save() работают с бинарными файлами numPy (с расширением npy )
• функции loadtxt() и savetxt() работают с обычными текстовыми файлами.

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

Функция numpy.save() сохраняет входной массив на вашем устройстве с расширением .npy .

import numpy as np a = np.array([1,2,3,4,5]) np.save('outfile',a)

Для восстановления массива из файла outfile.npy используйте функцию load() .

import numpy as np b = np.load('outfile.npy') print b # Вывод: # array([1, 2, 3, 4, 5])

Функции save() и load() принимают дополнительный булевый параметр allow_pickles . Pickles в Python используются для сериализации и де-сериализации объектов перед сохранением на диске или чтением из него.

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

Пример

import numpy as np a = np.array([1,2,3,4,5]) np.savetxt('out.txt',a) b = np.loadtxt('out.txt') print b # Вывод: # [ 1. 2. 3. 4. 5.]

Часто задаваемые вопросы по NumPy в Python

1. Что такое NumPy и почему он используется в Python?

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

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

2. Как определить NumPy в Python?

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

3. Где используется NumPy?

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

4. Что лучше — NumPy или pandas?

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

• NumPy и pandas — наиболее используемые библиотеки в области Data Science, ML и AI.
• Обе библиотеки позволяют сэкономить n-е количество строк кода.
• Обе библиотеки имеют открытый исходный код.
• NumPy используется для быстрых научных вычислений, а pandas — для манипулирования данными, их анализа и очистки.

От редакции Pythonist: если вы не знакомы с pandas, вот полезная ознакомительная статья — «Полное руководство по Pandas для начинающих».

5. В чем разница между NumPy и pandas?

6. Что такое массив NumPy?

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

7. На каком языке написана NumPy?

NumPy — это библиотека Python, которая частично написана на Python, а большая часть написана на C или C++. Кроме того, она поддерживает расширения на других языках, в частности, на C++ и Fortran.