NumPy - Краткое руководство
NumPy - это пакет Python. Это расшифровывается как «Числовой Python». Это библиотека, состоящая из объектов многомерного массива и набора процедур для обработки массива.
Numeric, предок NumPy, был разработан Джимом Хугуниным. Также был разработан другой пакет Numarray с некоторыми дополнительными функциями. В 2005 году Трэвис Олифант создал пакет NumPy, включив функции Numarray в пакет Numeric. Есть много участников этого проекта с открытым исходным кодом.
Операции с использованием NumPy
Используя NumPy, разработчик может выполнять следующие операции:
Математические и логические операции над массивами.
Преобразования Фурье и процедуры для манипулирования формами.
Операции, связанные с линейной алгеброй. NumPy имеет встроенные функции для линейной алгебры и генерации случайных чисел.
NumPy - замена MatLab
NumPy часто используется вместе с такими пакетами, как SciPy (Научный Python) и Mat−plotlib(графическая библиотека). Эта комбинация широко используется в качестве замены MatLab, популярной платформы для технических вычислений. Однако альтернатива Python MatLab теперь рассматривается как более современный и полный язык программирования.
Это открытый исходный код, что является дополнительным преимуществом NumPy.
Стандартный дистрибутив Python не поставляется в комплекте с модулем NumPy. Легкая альтернатива - установить NumPy с помощью популярного установщика пакетов Python,pip.
pip install numpyЛучший способ включить NumPy - использовать устанавливаемый двоичный пакет, специфичный для вашей операционной системы. Эти двоичные файлы содержат полный стек SciPy (включая NumPy, SciPy, matplotlib, IPython, SymPy и пакеты носа вместе с ядром Python).
Windows
Анаконда (из https://www.continuum.io) - это бесплатный дистрибутив Python для стека SciPy. Он также доступен для Linux и Mac.
Навес (https://www.enthought.com/products/canopy/) доступен как бесплатный, так и коммерческий дистрибутив с полным стеком SciPy для Windows, Linux и Mac.
Python (x, y): это бесплатный дистрибутив Python со стеком SciPy и Spyder IDE для ОС Windows. (Можно загрузить сhttps://www.python-xy.github.io/)
Linux
Менеджеры пакетов соответствующих дистрибутивов Linux используются для установки одного или нескольких пакетов в стек SciPy.
Для Ubuntu
sudo apt-get install python-numpy
python-scipy python-matplotlibipythonipythonnotebook python-pandas
python-sympy python-noseДля Fedora
sudo yum install numpyscipy python-matplotlibipython
python-pandas sympy python-nose atlas-develСборка из исходного кода
Core Python (2.6.x, 2.7.x и 3.2.x и более поздних версий) должен быть установлен с distutils, и модуль zlib должен быть включен.
Должен быть доступен компилятор C. GNU gcc (4.2 и выше).
Чтобы установить NumPy, выполните следующую команду.
Python setup.py installЧтобы проверить, правильно ли установлен модуль NumPy, попробуйте импортировать его из командной строки Python.
import numpyЕсли он не установлен, отобразится следующее сообщение об ошибке.
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
import numpy
ImportError: No module named 'numpy'В качестве альтернативы пакет NumPy импортируется с использованием следующего синтаксиса -
import numpy as npСамый важный объект, определенный в NumPy, - это тип N-мерного массива, называемый ndarray. В нем описывается набор однотипных предметов. Доступ к элементам коллекции можно получить с помощью индекса с отсчетом от нуля.
Каждый элемент в ndarray занимает в памяти блок одного размера. Каждый элемент в ndarray - это объект типа данных (называемыйdtype).
Любой элемент, извлеченный из объекта ndarray (путем нарезки), представлен объектом Python одного из скалярных типов массива. На следующей диаграмме показана связь между ndarray, объектом типа данных (dtype) и скалярным типом массива.
Экземпляр класса ndarray может быть создан с помощью различных процедур создания массива, описанных далее в руководстве. Базовый ndarray создается с использованием функции массива в NumPy следующим образом:
numpy.arrayОн создает ndarray из любого объекта, предоставляющего интерфейс массива, или из любого метода, возвращающего массив.
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)Вышеупомянутый конструктор принимает следующие параметры -
| Sr.No. | Параметр и описание |
|---|---|
| 1 | object Любой объект, предоставляющий метод интерфейса массива, возвращает массив или любую (вложенную) последовательность. |
| 2 | dtype Желаемый тип данных массива, необязательно |
| 3 | copy Необязательный. По умолчанию (true) объект копируется |
| 4 | order C (основная строка) или F (основная колонка) или A (любая) (по умолчанию) |
| 5 | subok По умолчанию возвращаемый массив должен быть массивом базового класса. Если это правда, подклассы прошли через |
| 6 | ndmin Задает минимальные размеры результирующего массива |
Взгляните на следующие примеры, чтобы лучше понять.
Пример 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]В ndarrayОбъект состоит из непрерывного одномерного сегмента компьютерной памяти, объединенного со схемой индексации, которая отображает каждый элемент на место в блоке памяти. Блок памяти содержит элементы в порядке строк (стиль C) или порядке столбцов (стиль FORTRAN или MatLab).
NumPy поддерживает гораздо большее разнообразие числовых типов, чем Python. В следующей таблице показаны различные типы скалярных данных, определенные в NumPy.
| Sr.No. | Типы данных и описание |
|---|---|
| 1 | bool_ Логическое значение (Истина или Ложь) хранится как байт |
| 2 | int_ Целочисленный тип по умолчанию (такой же, как C long; обычно int64 или int32) |
| 3 | intc Идентичен C int (обычно int32 или int64) |
| 4 | intp Целое число, используемое для индексации (то же, что и C ssize_t; обычно либо int32, либо int64) |
| 5 | int8 Байт (от -128 до 127) |
| 6 | int16 Целое число (от -32768 до 32767) |
| 7 | int32 Целое число (от -2147483648 до 2147483647) |
| 8 | int64 Целое число (от -9223372036854775808 до 9223372036854775807) |
| 9 | uint8 Целое число без знака (от 0 до 255) |
| 10 | uint16 Целое число без знака (от 0 до 65535) |
| 11 | uint32 Целое число без знака (от 0 до 4294967295) |
| 12 | uint64 Целое число без знака (от 0 до 18446744073709551615) |
| 13 | float_ Сокращение для float64 |
| 14 | float16 Поплавок половинной точности: знаковый бит, 5-битная экспонента, 10-битная мантисса |
| 15 | float32 Число с плавающей запятой одинарной точности: знаковый бит, экспонента 8 бит, мантисса 23 бита |
| 16 | float64 Число с плавающей запятой двойной точности: знаковый бит, 11-битная экспонента, 52-битная мантисса |
| 17 | complex_ Сокращение для complex128 |
| 18 | complex64 Комплексное число, представленное двумя 32-битными числами с плавающей запятой (действительная и мнимая составляющие) |
| 19 | complex128 Комплексное число, представленное двумя 64-битными числами с плавающей запятой (действительная и мнимая составляющие) |
Числовые типы NumPy - это экземпляры объектов dtype (типа данных), каждый из которых имеет уникальные характеристики. Типы dtypes доступны как np.bool_, np.float32 и т. Д.
Объекты типа данных (dtype)
Объект типа данных описывает интерпретацию фиксированного блока памяти, соответствующего массиву, в зависимости от следующих аспектов:
Тип данных (целое число, число с плавающей запятой или объект Python)
Размер данных
Порядок байтов (прямой или прямой порядок байтов)
В случае структурированного типа - имена полей, тип данных каждого поля и часть блока памяти, занимаемая каждым полем.
Если тип данных - подмассив, его форма и тип данных
Порядок байтов определяется добавлением к типу данных префикса «<» или «>». '<' означает, что кодирование является прямым порядком байтов (наименьшее значение хранится в наименьшем адресе). '>' означает, что кодировка с прямым порядком байтов (старший байт хранится по наименьшему адресу).
Объект dtype создается с использованием следующего синтаксиса -
numpy.dtype(object, align, copy)Параметры -
Object - Для преобразования в объект типа данных
Align - Если true, добавляет к полю отступ, чтобы оно было похоже на 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,)]Пример 6
# file name can be used to access content of age column
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print a['age']Результат выглядит следующим образом -
[10 20 30]Пример 7
В следующих примерах определяется структурированный тип данных, называемый student со строковым полем "имя", integer field "возраст" и float field'Метки'. Этот dtype применяется к объекту ndarray.
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
print studentРезультат выглядит следующим образом -
[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])Пример 8
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
print aРезультат выглядит следующим образом -
[('abc', 21, 50.0), ('xyz', 18, 75.0)]Каждый встроенный тип данных имеет код символа, который однозначно его идентифицирует.
'b' - логическое
'i' - (знаковое) целое число
'u' - целое без знака
'f' - с плавающей точкой
'c' - комплексное число с плавающей запятой
'm' - timedelta
'M' - дата и время
'O' - (Python) объекты
'S', 'a' - (байтовая) строка
'U' - Юникод
'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]]Пример 3
NumPy также предоставляет функцию изменения формы для изменения размера массива.
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print bРезультат выглядит следующим образом -
[[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Результат выглядит следующим образом -
4numpy.flags
Объект ndarray имеет следующие атрибуты. Его текущие значения возвращаются этой функцией.
| Sr.No. | Атрибут и описание |
|---|---|
| 1 | C_CONTIGUOUS (C) Данные находятся в одном непрерывном сегменте в стиле C. |
| 2 | F_CONTIGUOUS (F) Данные находятся в одном непрерывном сегменте в стиле Fortran. |
| 3 | OWNDATA (O) Массив владеет памятью, которую он использует, или заимствует ее у другого объекта. |
| 4 | WRITEABLE (W) В область данных можно записывать. Установка этого значения в False блокирует данные, делая их доступными только для чтения. |
| 5 | ALIGNED (A) Данные и все элементы согласованы в соответствии с аппаратным обеспечением |
| 6 | UPDATEIFCOPY (U) Этот массив является копией другого массива. Когда этот массив освобождается, базовый массив будет обновлен содержимым этого массива. |
пример
В следующем примере показаны текущие значения флагов.
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Новый ndarray Объект может быть создан с помощью любой из следующих процедур создания массива или с помощью низкоуровневого конструктора ndarray.
numpy.empty
Он создает неинициализированный массив указанной формы и dtype. Он использует следующий конструктор -
numpy.empty(shape, dtype = float, order = 'C')Конструктор принимает следующие параметры.
| Sr.No. | Параметр и описание |
|---|---|
| 1 | Shape Форма пустого массива в int или кортежа int |
| 2 | Dtype Желаемый тип выходных данных. Необязательный |
| 3 | Order 'C' для массива основных строк в стиле C, 'F' для массива основных столбцов в стиле FORTRAN |
пример
В следующем коде показан пример пустого массива.
import numpy as np
x = np.empty([3,2], dtype = int)
print xРезультат выглядит следующим образом -
[[22649312 1701344351]
[1818321759 1885959276]
[16779776 156368896]]Note - Элементы в массиве показывают случайные значения, поскольку они не инициализированы.
numpy.zeros
Возвращает новый массив указанного размера, заполненный нулями.
numpy.zeros(shape, dtype = float, order = 'C')Конструктор принимает следующие параметры.
| Sr.No. | Параметр и описание |
|---|---|
| 1 | Shape Форма пустого массива в int или последовательность int |
| 2 | Dtype Желаемый тип выходных данных. Необязательный |
| 3 | Order 'C' для массива основных строк в стиле C, 'F' для массива основных столбцов в стиле FORTRAN |
Пример 1
# array of five zeros. Default dtype is float
import numpy as np
x = np.zeros(5)
print xРезультат выглядит следующим образом -
[ 0. 0. 0. 0. 0.]Пример 2
import numpy as np
x = np.zeros((5,), dtype = np.int)
print xТеперь вывод будет следующим -
[0 0 0 0 0]Пример 3
# custom type
import numpy as np
x = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
print xОн должен выдать следующий результат -
[[(0,0)(0,0)]
[(0,0)(0,0)]]numpy.ones
Возвращает новый массив указанного размера и типа, заполненный единицами.
numpy.ones(shape, dtype = None, order = 'C')Конструктор принимает следующие параметры.
| Sr.No. | Параметр и описание |
|---|---|
| 1 | Shape Форма пустого массива в int или кортежа int |
| 2 | Dtype Желаемый тип выходных данных. Необязательный |
| 3 | Order 'C' для массива основных строк в стиле C, 'F' для массива основных столбцов в стиле FORTRAN |
Пример 1
# array of five ones. Default dtype is float
import numpy as np
x = np.ones(5)
print xРезультат выглядит следующим образом -
[ 1. 1. 1. 1. 1.]Пример 2
import numpy as np
x = np.ones([2,2], dtype = int)
print xТеперь вывод будет следующим -
[[1 1]
[1 1]]В этой главе мы обсудим, как создать массив из существующих данных.
numpy.asarray
Эта функция похожа на numpy.array за исключением того, что у нее меньше параметров. Эта процедура полезна для преобразования последовательности Python в ndarray.
numpy.asarray(a, dtype = None, order = None)Конструктор принимает следующие параметры.
| Sr.No. | Параметр и описание |
|---|---|
| 1 | a Входные данные в любой форме, например, список, список кортежей, кортеж, кортеж кортежей или кортеж списков |
| 2 | dtype По умолчанию тип входных данных применяется к результирующему ndarray |
| 3 | order C (мажорная строка) или F (мажорная колонка). C по умолчанию |
Следующие примеры показывают, как можно использовать asarray функция.
Пример 1
# convert list to ndarray
import numpy as np
x = [1,2,3]
a = np.asarray(x)
print aЕго вывод будет следующим -
[1 2 3]Пример 2
# dtype is set
import numpy as np
x = [1,2,3]
a = np.asarray(x, dtype = float)
print aТеперь вывод будет следующим -
[ 1. 2. 3.]Пример 3
# ndarray from tuple
import numpy as np
x = (1,2,3)
a = np.asarray(x)
print aЕго вывод будет -
[1 2 3]Пример 4
# ndarray from list of tuples
import numpy as np
x = [(1,2,3),(4,5)]
a = np.asarray(x)
print aЗдесь вывод будет следующим -
[(1, 2, 3) (4, 5)]numpy.frombuffer
Эта функция интерпретирует буфер как одномерный массив. Любой объект, который предоставляет интерфейс буфера, используется как параметр для возвратаndarray.
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)Конструктор принимает следующие параметры.
| Sr.No. | Параметр и описание |
|---|---|
| 1 | buffer Любой объект, предоставляющий интерфейс буфера |
| 2 | dtype Тип данных возвращаемого ndarray. По умолчанию плавающий |
| 3 | count Количество элементов для чтения, по умолчанию -1 означает все данные |
| 4 | offset Начальная позиция для чтения. По умолчанию 0 |
пример
Следующие примеры демонстрируют использование frombuffer функция.
import numpy as np
s = 'Hello World'
a = np.frombuffer(s, dtype = 'S1')
print aВот его результат -
['H' 'e' 'l' 'l' 'o' ' ' 'W' 'o' 'r' 'l' 'd']numpy.fromiter
Эта функция создает ndarrayобъект из любого итеративного объекта. Эта функция возвращает новый одномерный массив.
numpy.fromiter(iterable, dtype, count = -1)Здесь конструктор принимает следующие параметры.
| Sr.No. | Параметр и описание |
|---|---|
| 1 | iterable Любой итерируемый объект |
| 2 | dtype Тип данных результирующего массива |
| 3 | count Количество элементов, считываемых из итератора. По умолчанию -1, что означает, что все данные будут прочитаны. |
В следующих примерах показано, как использовать встроенный range()функция для возврата объекта списка. Итератор этого списка используется для формированияndarray объект.
Пример 1
# create list object using range function
import numpy as np
list = range(5)
print listЕго вывод выглядит следующим образом -
[0, 1, 2, 3, 4]Пример 2
# obtain iterator object from list
import numpy as np
list = range(5)
it = iter(list)
# use iterator to create ndarray
x = np.fromiter(it, dtype = float)
print xТеперь вывод будет следующим -
[0. 1. 2. 3. 4.]В этой главе мы увидим, как создать массив из числовых диапазонов.
numpy.arange
Эта функция возвращает ndarrayобъект, содержащий равномерно распределенные значения в заданном диапазоне. Формат функции следующий -
numpy.arange(start, stop, step, dtype)Конструктор принимает следующие параметры.
| Sr.No. | Параметр и описание |
|---|---|
| 1 | start Начало интервала. Если опущено, по умолчанию 0 |
| 2 | stop Конец интервала (не включая это число) |
| 3 | step Интервал между значениями, по умолчанию 1 |
| 4 | dtype Тип данных результирующего ndarray. Если не указан, используется тип данных ввода. |
В следующих примерах показано, как можно использовать эту функцию.
Пример 1
import numpy as np
x = np.arange(5)
print xЕго вывод будет следующим -
[0 1 2 3 4]Пример 2
import numpy as np
# dtype set
x = np.arange(5, dtype = float)
print xЗдесь вывод будет -
[0. 1. 2. 3. 4.]Пример 3
# start and stop parameters set
import numpy as np
x = np.arange(10,20,2)
print xЕго вывод выглядит следующим образом -
[10 12 14 16 18]numpy.linspace
Эта функция похожа на arange()функция. В этой функции вместо размера шага указывается количество равномерно распределенных значений между интервалом. Использование этой функции следующее -
numpy.linspace(start, stop, num, endpoint, retstep, dtype)Конструктор принимает следующие параметры.
| Sr.No. | Параметр и описание |
|---|---|
| 1 | start Начальное значение последовательности |
| 2 | stop Конечное значение последовательности, включенное в последовательность, если для конечной точки установлено значение true. |
| 3 | num Количество генерируемых равномерно распределенных выборок. По умолчанию 50 |
| 4 | endpoint По умолчанию true, поэтому в последовательность включается стоп-значение. Если false, то не включается |
| 5 | retstep Если true, возвращает образцы и шаг между последовательными числами. |
| 6 | dtype Тип данных вывода ndarray |
Следующие примеры демонстрируют использование linspace функция.
Пример 1
import numpy as np
x = np.linspace(10,20,5)
print xЕго вывод будет -
[10. 12.5 15. 17.5 20.]Пример 2
# endpoint set to false
import numpy as np
x = np.linspace(10,20, 5, endpoint = False)
print xРезультат будет -
[10. 12. 14. 16. 18.]Пример 3
# find retstep value
import numpy as np
x = np.linspace(1,2,5, retstep = True)
print x
# retstep here is 0.25Теперь вывод будет -
(array([ 1. , 1.25, 1.5 , 1.75, 2. ]), 0.25)numpy.logspace
Эта функция возвращает ndarrayобъект, содержащий числа, равномерно распределенные по шкале журнала. Начальная и конечная конечные точки шкалы - это индексы базы, обычно 10.
numpy.logspace(start, stop, num, endpoint, base, dtype)Следующие параметры определяют выход logspace функция.
| Sr.No. | Параметр и описание |
|---|---|
| 1 | start Начальная точка последовательности - базовый старт. |
| 2 | stop Конечное значение последовательности - базовая остановка. |
| 3 | num Количество значений в диапазоне. По умолчанию 50 |
| 4 | endpoint Если true, стоп - последнее значение в диапазоне. |
| 5 | base База места для журнала, по умолчанию 10 |
| 6 | dtype Тип данных выходного массива. Если не указан, это зависит от других входных аргументов |
Следующие примеры помогут вам понять logspace функция.
Пример 1
import numpy as np
# default base is 10
a = np.logspace(1.0, 2.0, num = 10)
print aЕго вывод будет следующим -
[ 10. 12.91549665 16.68100537 21.5443469 27.82559402
35.93813664 46.41588834 59.94842503 77.42636827 100. ]Пример 2
# set base of log space to 2
import numpy as np
a = np.logspace(1,10,num = 10, base = 2)
print aТеперь вывод будет -
[ 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.]Доступ к содержимому объекта ndarray и его изменение можно получить путем индексации или нарезки, как и для встроенных объектов контейнера Python.
Как упоминалось ранее, элементы в объекте ndarray следует за индексом, начинающимся с нуля. Доступны три типа методов индексации -field access, basic slicing и advanced indexing.
Базовая нарезка - это расширение базовой концепции 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 тоже.
Пример 6
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print a
# slice items starting from index
print 'Now we will slice the array from the index a[1:]'
print a[1:]Результат выглядит следующим образом -
[[1 2 3]
[3 4 5]
[4 5 6]]
Now we will slice the array from the index a[1:]
[[3 4 5]
[4 5 6]]Нарезка также может включать многоточие (…) для создания кортежа выбора той же длины, что и размер массива. Если в позиции строки используется многоточие, он вернет ndarray, состоящий из элементов в строках.
Пример 7
# array to begin with
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print 'Our array is:'
print a
print '\n'
# this returns array of items in the second column
print 'The items in the second column are:'
print a[...,1]
print '\n'
# Now we will slice all items from the second row
print 'The items in the second row are:'
print a[1,...]
print '\n'
# Now we will slice all items from column 1 onwards
print 'The items column 1 onwards are:'
print a[...,1:]Результат этой программы следующий -
Our array is:
[[1 2 3]
[3 4 5]
[4 5 6]]
The items in the second column are:
[2 4 5]
The items in the second row are:
[3 4 5]
The items column 1 onwards are:
[[2 3]
[4 5]
[5 6]]Можно сделать выбор из ndarray, который является последовательностью, отличной от кортежа, объектом ndarray с целочисленным или логическим типом данных или кортежем, в котором хотя бы один элемент является объектом последовательности. Расширенная индексация всегда возвращает копию данных. В отличие от этого, нарезка представляет собой только представление.
Существует два типа расширенного индексирования: 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) из первого массива.
В следующем примере выбираются элементы, расположенные по углам массива 4x3. Индексы выбора строки - [0, 0] и [3,3], тогда как индексы столбца - [0,2] и [0,2].
Пример 2
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'
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print 'The corner elements of this array are:'
print yРезультат этой программы следующий -
Our array is:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
The corner elements of this array are:
[[ 0 2]
[ 9 11]]Результирующий выбор - это объект ndarray, содержащий угловые элементы.
Расширенное и базовое индексирование можно комбинировать с помощью одного фрагмента (:) или многоточия (…) с массивом индексов. В следующем примере используется фрагмент для строки и расширенный индекс для столбца. Результат будет таким же, когда slice используется для обоих. Но расширенный индекс приводит к копированию и может иметь другую структуру памяти.
Пример 3
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'
# slicing
z = x[1:4,1:3]
print 'After slicing, our array becomes:'
print z
print '\n'
# using advanced index for column
y = x[1:4,[1,2]]
print 'Slicing using advanced index for column:'
print yРезультат этой программы будет следующим:
Our array is:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
After slicing, our array becomes:
[[ 4 5]
[ 7 8]
[10 11]]
Slicing using advanced index for column:
[[ 4 5]
[ 7 8]
[10 11]]Индексирование логического массива
Этот тип расширенного индексирования используется, когда результирующий объект должен быть результатом логических операций, таких как операторы сравнения.
Пример 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]Пример 2
В этом примере элементы NaN (не число) опускаются с помощью ~ (оператор дополнения).
import numpy as np
a = np.array([np.nan, 1,2,np.nan,3,4,5])
print a[~np.isnan(a)]Его вывод будет -
[ 1. 2. 3. 4. 5.]Пример 3
В следующем примере показано, как отфильтровать несложные элементы из массива.
import numpy as np
a = np.array([1, 2+6j, 5, 3.5+5j])
print a[np.iscomplex(a)]Здесь вывод выглядит следующим образом -
[2.0+6.j 3.5+5.j]Срок 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 из-за возможности широковещания. Меньший массивbroadcast к размеру большего массива, чтобы они имели совместимые формы.
Вещание возможно при соблюдении следующих правил:
Массив с меньшим ndim чем другой, предваряется "1" в его форме.
Размер в каждом измерении выходной формы является максимальным из входных размеров в этом измерении.
Входные данные могут использоваться в вычислениях, если их размер в определенном измерении соответствует размеру выходных данных или его значение равно 1.
Если размер входных данных равен 1, первая запись данных в этом измерении используется для всех вычислений по этому измерению.
Набор массивов называется broadcastable если приведенные выше правила дают допустимый результат и верно одно из следующих:
Массивы имеют точно такую же форму.
Массивы имеют одинаковое количество измерений, а длина каждого измерения равна либо общей длине, либо 1.
Массив, имеющий слишком мало размеров, может иметь перед формой размер длины 1, так что указанное выше свойство будет истинным.
Следующая программа показывает пример трансляции.
Пример 2
import numpy as np
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]])
b = np.array([1.0,2.0,3.0])
print 'First array:'
print a
print '\n'
print 'Second array:'
print b
print '\n'
print 'First Array + Second Array'
print a + bРезультат этой программы будет следующим:
First array:
[[ 0. 0. 0.]
[ 10. 10. 10.]
[ 20. 20. 20.]
[ 30. 30. 30.]]
Second array:
[ 1. 2. 3.]
First Array + Second Array
[[ 1. 2. 3.]
[ 11. 12. 13.]
[ 21. 22. 23.]
[ 31. 32. 33.]]На следующем рисунке показано, как массив b транслируется, чтобы стать совместимым с a.
Пакет NumPy содержит объект-итератор numpy.nditer. Это эффективный многомерный объект-итератор, с помощью которого можно выполнять итерацию по массиву. Каждый элемент массива просматривается с помощью стандартного интерфейса Python Iterator.
Давайте создадим массив 3X4 с помощью функции arange () и переберем его, используя nditer.
Пример 1
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Modified array is:'
for x in np.nditer(a):
print x,Результат этой программы следующий -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Modified array is:
0 5 10 15 20 25 30 35 40 45 50 55Пример 2
Порядок итерации выбирается в соответствии с разметкой памяти массива без учета конкретного порядка. Это можно увидеть, перебирая транспонированный массив выше.
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Transpose of the original array is:'
b = a.T
print b
print '\n'
print 'Modified array is:'
for x in np.nditer(b):
print x,Результат вышеупомянутой программы выглядит следующим образом -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Transpose of the original array is:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
Modified array is:
0 5 10 15 20 25 30 35 40 45 50 55Порядок итерации
Если одни и те же элементы хранятся с использованием F-стиля, итератор выбирает более эффективный способ итерации по массиву.
Пример 1
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Transpose of the original array is:'
b = a.T
print b
print '\n'
print 'Sorted in C-style order:'
c = b.copy(order='C')
print c
for x in np.nditer(c):
print x,
print '\n'
print 'Sorted in F-style order:'
c = b.copy(order='F')
print c
for x in np.nditer(c):
print x,Его вывод будет следующим -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Transpose of the original array is:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
Sorted in C-style order:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55
Sorted in F-style order:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 5 10 15 20 25 30 35 40 45 50 55Пример 2
Можно заставить nditer объект использовать определенный порядок, явно указав его.
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Sorted in C-style order:'
for x in np.nditer(a, order = 'C'):
print x,
print '\n'
print 'Sorted in F-style order:'
for x in np.nditer(a, order = 'F'):
print x,Его вывод будет -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Sorted in C-style order:
0 5 10 15 20 25 30 35 40 45 50 55
Sorted in F-style order:
0 20 40 5 25 45 10 30 50 15 35 55Изменение значений массива
В nditer объект имеет еще один необязательный параметр, называемый op_flags. Его значение по умолчанию доступно только для чтения, но может быть установлено в режим чтения-записи или только для записи. Это позволит изменять элементы массива с помощью этого итератора.
пример
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
for x in np.nditer(a, op_flags = ['readwrite']):
x[...] = 2*x
print 'Modified array is:'
print aЕго вывод выглядит следующим образом -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Modified array is:
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]Внешний контур
Конструктор класса nditer имеет ‘flags’ параметр, который может принимать следующие значения -
| Sr.No. | Параметр и описание |
|---|---|
| 1 | c_index Индекс C_order можно отслеживать |
| 2 | f_index Индекс Fortran_order отслеживается |
| 3 | multi-index Тип индексов с одним на итерацию можно отслеживать |
| 4 | external_loop Делает значения одномерными массивами с несколькими значениями вместо нулевого массива |
пример
В следующем примере итератор просматривает одномерные массивы, соответствующие каждому столбцу.
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Modified array is:'
for x in np.nditer(a, flags = ['external_loop'], order = 'F'):
print x,Результат выглядит следующим образом -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Modified array is:
[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]Трансляция итераций
Если два массива broadcastable, комбинированный nditerобъект может выполнять итерацию по ним одновременно. Предполагая, что массивa имеет размерность 3X4, а есть еще один массив b размерности 1X4 используется итератор следующего типа (массив b транслируется размером a).
пример
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'First array is:'
print a
print '\n'
print 'Second array is:'
b = np.array([1, 2, 3, 4], dtype = int)
print b
print '\n'
print 'Modified array is:'
for x,y in np.nditer([a,b]):
print "%d:%d" % (x,y),Его вывод будет следующим -
First array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Second array is:
[1 2 3 4]
Modified array is:
0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4В пакете NumPy доступно несколько подпрограмм для управления элементами в объекте ndarray. Их можно разделить на следующие типы -
Изменение формы
| Sr.No. | Форма и описание |
|---|---|
| 1 | изменить форму Придает новую форму массиву без изменения его данных |
| 2 | плоский Одномерный итератор по массиву |
| 3 | сплющивать Возвращает копию массива, свернутого в одно измерение |
| 4 | бродить Возвращает непрерывный плоский массив |
Операции транспонирования
| Sr.No. | Работа и описание |
|---|---|
| 1 | транспонировать Переставляет размеры массива |
| 2 | ndarray.T То же, что и self.transpose () |
| 3 | ось вращения Катит указанную ось назад |
| 4 | обменные операции Меняет местами две оси массива |
Изменение размеров
| Sr.No. | Размер и описание |
|---|---|
| 1 | трансляция Создает объект, имитирующий трансляцию |
| 2 | broadcast_to Трансформирует массив в новую форму |
| 3 | expand_dims Расширяет форму массива |
| 4 | сжимать Удаляет одномерные записи из формы массива |
Объединение массивов
| Sr.No. | Массив и описание |
|---|---|
| 1 | соединять Присоединяет последовательность массивов вдоль существующей оси |
| 2 | стек Присоединяет последовательность массивов вдоль новой оси |
| 3 | стек Укладывает массивы последовательно по горизонтали (по столбцам) |
| 4 | vstack Укладывает массивы последовательно по вертикали (по строкам) |
Разделение массивов
| Sr.No. | Массив и описание |
|---|---|
| 1 | Трещина Разбивает массив на несколько подмассивов |
| 2 | hsplit Разбивает массив на несколько подмассивов по горизонтали (по столбцам) |
| 3 | всплит Разбивает массив на несколько подмассивов по вертикали (по строкам) |
Добавление / удаление элементов
| Sr.No. | Элемент и описание |
|---|---|
| 1 | изменить размер Возвращает новый массив с указанной формой |
| 2 | добавить Добавляет значения в конец массива |
| 3 | вставить Вставляет значения по заданной оси перед заданными индексами |
| 4 | удалять Возвращает новый массив с удаленными подмассивами вдоль оси. |
| 5 | уникальный Находит уникальные элементы массива |
Ниже приведены функции для побитовых операций, доступные в пакете NumPy.
| Sr.No. | Работа и описание |
|---|---|
| 1 | побитовое_и Вычисляет побитовое И для элементов массива |
| 2 | bitwise_or Вычисляет побитовую операцию ИЛИ для элементов массива |
| 3 | инвертировать Вычисляет побитовое НЕ |
| 4 | левый "шифт Сдвигает биты двоичного представления влево |
| 5 | right_shift Сдвигает биты двоичного представления вправо |
Следующие функции используются для выполнения векторизованных строковых операций для массивов dtype numpy.string_ или numpy.unicode_. Они основаны на стандартных строковых функциях встроенной библиотеки Python.
| Sr.No. | Описание функции |
|---|---|
| 1 | Добавить() Возвращает поэлементную конкатенацию строк для двух массивов str или Unicode |
| 2 | умножить () Поэлементно возвращает строку с множественной конкатенацией. |
| 3 | центр() Возвращает копию данной строки с элементами, центрированными в строке указанной длины. |
| 4 | капитализировать () Возвращает копию строки только с заглавной буквы. |
| 5 | заглавие() Возвращает поэлементную версию строки или Unicode в заголовке. |
| 6 | нижний () Возвращает массив с элементами, преобразованными в нижний регистр |
| 7 | верхний () Возвращает массив с элементами, преобразованными в верхний регистр |
| 8 | Трещина() Возвращает список слов в строке с использованием separatordelimiter |
| 9 | splitlines () Возвращает список строк в элементе с разрывом на границах строк |
| 10 | полоса () Возвращает копию с удаленными начальными и конечными символами |
| 11 | присоединиться() Возвращает строку, которая представляет собой объединение строк в последовательности. |
| 12 | заменить () Возвращает копию строки, в которой все вхождения подстроки заменены новой строкой. |
| 13 | декодировать () Вызывает str.decode поэлементно |
| 14 | кодировать () Вызов str.encode поэлементно |
Эти функции определены в классе символьных массивов (numpy.char). Старый пакет Numarray содержал класс chararray. Вышеупомянутые функции в классе numpy.char полезны при выполнении векторизованных строковых операций.
Вполне понятно, что NumPy содержит большое количество различных математических операций. NumPy предоставляет стандартные тригонометрические функции, функции для арифметических операций, обработки комплексных чисел и т. Д.
Тригонометрические функции
NumPy имеет стандартные тригонометрические функции, которые возвращают тригонометрические отношения для заданного угла в радианах.
Example
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() function преобразовав радианы в градусы.
Example
import numpy as np
a = np.array([0,30,45,60,90])
print 'Array containing sine values:'
sin = np.sin(a*np.pi/180)
print sin
print '\n'
print 'Compute sine inverse of angles. Returned values are in radians.'
inv = np.arcsin(sin)
print inv
print '\n'
print 'Check result by converting to degrees:'
print np.degrees(inv)
print '\n'
print 'arccos and arctan functions behave similarly:'
cos = np.cos(a*np.pi/180)
print cos
print '\n'
print 'Inverse of cos:'
inv = np.arccos(cos)
print inv
print '\n'
print 'In degrees:'
print np.degrees(inv)
print '\n'
print 'Tan function:'
tan = np.tan(a*np.pi/180)
print tan
print '\n'
print 'Inverse of tan:'
inv = np.arctan(tan)
print inv
print '\n'
print 'In degrees:'
print np.degrees(inv)Его вывод выглядит следующим образом -
Array containing sine values:
[ 0. 0.5 0.70710678 0.8660254 1. ]
Compute sine inverse of angles. Returned values are in radians.
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
Check result by converting to degrees:
[ 0. 30. 45. 60. 90.]
arccos and arctan functions behave similarly:
[ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
Inverse of cos:
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
In degrees:
[ 0. 30. 45. 60. 90.]
Tan function:
[ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
Inverse of tan:
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
In degrees:
[ 0. 30. 45. 60. 90.]Функции для округления
numpy.around ()
Это функция, которая возвращает значение, округленное до желаемой точности. Функция принимает следующие параметры.
numpy.around(a,decimals)Где,
| Sr.No. | Параметр и описание |
|---|---|
| 1 | a Входные данные |
| 2 | decimals Число десятичных знаков, до которых нужно округлить. По умолчанию 0. Если отрицательное число, целое число округляется до позиции слева от десятичной точки. |
Example
import numpy as np
a = np.array([1.0,5.55, 123, 0.567, 25.532])
print 'Original array:'
print a
print '\n'
print 'After rounding:'
print np.around(a)
print np.around(a, decimals = 1)
print np.around(a, decimals = -1)Он производит следующий вывод -
Original array:
[ 1. 5.55 123. 0.567 25.532]
After rounding:
[ 1. 6. 123. 1. 26. ]
[ 1. 5.6 123. 0.6 25.5]
[ 0. 10. 120. 0. 30. ]numpy.floor ()
Эта функция возвращает наибольшее целое число, не превышающее входной параметр. Полscalar x самый большой integer i, так что i <= x. Обратите внимание, что в Python пол всегда округляется от 0.
Example
import numpy as np
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print 'The given array:'
print a
print '\n'
print 'The modified array:'
print np.floor(a)Он производит следующий вывод -
The given array:
[ -1.7 1.5 -0.2 0.6 10. ]
The modified array:
[ -2. 1. -1. 0. 10.]numpy.ceil ()
Функция ceil () возвращает потолок входного значения, т. Е. Верхний предел scalar x самый маленький integer i, так что i >= x.
Example
import numpy as np
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print 'The given array:'
print a
print '\n'
print 'The modified array:'
print np.ceil(a)Он выдаст следующий результат -
The given array:
[ -1.7 1.5 -0.2 0.6 10. ]
The modified array:
[ -1. 2. -0. 1. 10.]Входные массивы для выполнения арифметических операций, таких как сложение (), вычитание (), умножение () и деление (), должны быть либо одной формы, либо соответствовать правилам широковещательной рассылки массивов.
пример
import numpy as np
a = np.arange(9, dtype = np.float_).reshape(3,3)
print 'First array:'
print a
print '\n'
print 'Second array:'
b = np.array([10,10,10])
print b
print '\n'
print 'Add the two arrays:'
print np.add(a,b)
print '\n'
print 'Subtract the two arrays:'
print np.subtract(a,b)
print '\n'
print 'Multiply the two arrays:'
print np.multiply(a,b)
print '\n'
print 'Divide the two arrays:'
print np.divide(a,b)Он выдаст следующий результат -
First array:
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
Second array:
[10 10 10]
Add the two arrays:
[[ 10. 11. 12.]
[ 13. 14. 15.]
[ 16. 17. 18.]]
Subtract the two arrays:
[[-10. -9. -8.]
[ -7. -6. -5.]
[ -4. -3. -2.]]
Multiply the two arrays:
[[ 0. 10. 20.]
[ 30. 40. 50.]
[ 60. 70. 80.]]
Divide the two arrays:
[[ 0. 0.1 0.2]
[ 0.3 0.4 0.5]
[ 0.6 0.7 0.8]]Давайте теперь обсудим некоторые другие важные арифметические функции, доступные в NumPy.
numpy.reciprocal ()
Эта функция поэлементно возвращает обратный аргумент. Для элементов с абсолютными значениями больше 1 результат всегда равен 0 из-за способа, которым Python обрабатывает целочисленное деление. Для целого числа 0 выдается предупреждение о переполнении.
пример
import numpy as np
a = np.array([0.25, 1.33, 1, 0, 100])
print 'Our array is:'
print a
print '\n'
print 'After applying reciprocal function:'
print np.reciprocal(a)
print '\n'
b = np.array([100], dtype = int)
print 'The second array is:'
print b
print '\n'
print 'After applying reciprocal function:'
print np.reciprocal(b)Он выдаст следующий результат -
Our array is:
[ 0.25 1.33 1. 0. 100. ]
After applying reciprocal function:
main.py:9: RuntimeWarning: divide by zero encountered in reciprocal
print np.reciprocal(a)
[ 4. 0.7518797 1. inf 0.01 ]
The second array is:
[100]
After applying reciprocal function:
[0]numpy.power ()
Эта функция обрабатывает элементы в первом входном массиве как базовые и возвращает их в степени, равной степени соответствующего элемента во втором входном массиве.
import numpy as np
a = np.array([10,100,1000])
print 'Our array is:'
print a
print '\n'
print 'Applying power function:'
print np.power(a,2)
print '\n'
print 'Second array:'
b = np.array([1,2,3])
print b
print '\n'
print 'Applying power function again:'
print np.power(a,b)Он выдаст следующий результат -
Our array is:
[ 10 100 1000]
Applying power function:
[ 100 10000 1000000]
Second array:
[1 2 3]
Applying power function again:
[ 10 10000 1000000000]numpy.mod ()
Эта функция возвращает остаток от деления соответствующих элементов входного массива. Функцияnumpy.remainder() также дает тот же результат.
import numpy as np
a = np.array([10,20,30])
b = np.array([3,5,7])
print 'First array:'
print a
print '\n'
print 'Second array:'
print b
print '\n'
print 'Applying mod() function:'
print np.mod(a,b)
print '\n'
print 'Applying remainder() function:'
print np.remainder(a,b)Он выдаст следующий результат -
First array:
[10 20 30]
Second array:
[3 5 7]
Applying mod() function:
[1 0 2]
Applying remainder() function:
[1 0 2]Следующие функции используются для выполнения операций с массивом с комплексными числами.
numpy.real() - возвращает действительную часть аргумента сложного типа данных.
numpy.imag() - возвращает мнимую часть аргумента сложного типа данных.
numpy.conj() - возвращает комплексное сопряжение, которое получается путем изменения знака мнимой части.
numpy.angle()- возвращает угол сложного аргумента. Функция имеет параметр степени. Если true, возвращается угол в градусах, в противном случае угол в радианах.
import numpy as np
a = np.array([-5.6j, 0.2j, 11. , 1+1j])
print 'Our array is:'
print a
print '\n'
print 'Applying real() function:'
print np.real(a)
print '\n'
print 'Applying imag() function:'
print np.imag(a)
print '\n'
print 'Applying conj() function:'
print np.conj(a)
print '\n'
print 'Applying angle() function:'
print np.angle(a)
print '\n'
print 'Applying angle() function again (result in degrees)'
print np.angle(a, deg = True)Он выдаст следующий результат -
Our array is:
[ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]
Applying real() function:
[ 0. 0. 11. 1.]
Applying imag() function:
[-5.6 0.2 0. 1. ]
Applying conj() function:
[ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]
Applying angle() function:
[-1.57079633 1.57079633 0. 0.78539816]
Applying angle() function again (result in degrees)
[-90. 90. 0. 45.]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 ()
В 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)Он выдаст следующий результат -
Our array is:
[[3 7 5]
[8 4 3]
[2 4 9]]
Applying ptp() function:
7
Applying ptp() function along axis 1:
[4 5 7]
Applying ptp() function along axis 0:
[6 3 6]numpy.percentile ()
Процентиль (или центиль) - это мера, используемая в статистике, указывающая значение, ниже которого попадает определенный процент наблюдений в группе наблюдений. Функцияnumpy.percentile() принимает следующие аргументы.
numpy.percentile(a, q, axis)Где,
| Sr.No. | Аргумент и описание |
|---|---|
| 1 | a Входной массив |
| 2 | q Вычисляемый процентиль должен находиться в диапазоне от 0 до 100. |
| 3 | axis Ось, по которой рассчитывается процентиль. |
пример
import numpy as np
a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying percentile() function:'
print np.percentile(a,50)
print '\n'
print 'Applying percentile() function along axis 1:'
print np.percentile(a,50, axis = 1)
print '\n'
print 'Applying percentile() function along axis 0:'
print np.percentile(a,50, axis = 0)Он выдаст следующий результат -
Our array is:
[[30 40 70]
[80 20 10]
[50 90 60]]
Applying percentile() function:
50.0
Applying percentile() function along axis 1:
[ 40. 20. 60.]
Applying percentile() function along axis 0:
[ 50. 40. 60.]numpy.median ()
Medianопределяется как значение, отделяющее верхнюю половину выборки данных от нижней половины. Вnumpy.median() функция используется, как показано в следующей программе.
пример
import numpy as np
a = np.array([[30,65,70],[80,95,10],[50,90,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying median() function:'
print np.median(a)
print '\n'
print 'Applying median() function along axis 0:'
print np.median(a, axis = 0)
print '\n'
print 'Applying median() function along axis 1:'
print np.median(a, axis = 1)Он выдаст следующий результат -
Our array is:
[[30 65 70]
[80 95 10]
[50 90 60]]
Applying median() function:
65.0
Applying median() function along axis 0:
[ 50. 90. 60.]
Applying median() function along axis 1:
[ 65. 80. 60.]numpy.mean ()
Среднее арифметическое - это сумма элементов по оси, деленная на количество элементов. Вnumpy.mean()функция возвращает среднее арифметическое элементов в массиве. Если указана ось, она рассчитывается по ней.
пример
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print 'Our array is:'
print a
print '\n'
print 'Applying mean() function:'
print np.mean(a)
print '\n'
print 'Applying mean() function along axis 0:'
print np.mean(a, axis = 0)
print '\n'
print 'Applying mean() function along axis 1:'
print np.mean(a, axis = 1)Он выдаст следующий результат -
Our array is:
[[1 2 3]
[3 4 5]
[4 5 6]]
Applying mean() function:
3.66666666667
Applying mean() function along axis 0:
[ 2.66666667 3.66666667 4.66666667]
Applying mean() function along axis 1:
[ 2. 4. 5.]numpy.average ()
Средневзвешенное значение - это среднее значение, полученное в результате умножения каждого компонента на коэффициент, отражающий его важность. Вnumpy.average()Функция вычисляет средневзвешенное значение элементов в массиве в соответствии с их соответствующим весом, указанным в другом массиве. Функция может иметь параметр оси. Если ось не указана, массив выравнивается.
Учитывая массив [1,2,3,4] и соответствующие веса [4,3,2,1], средневзвешенное значение рассчитывается путем сложения произведения соответствующих элементов и деления суммы на сумму весов.
Средневзвешенное значение = (1 * 4 + 2 * 3 + 3 * 2 + 4 * 1) / (4 + 3 + 2 + 1)
пример
import numpy as np
a = np.array([1,2,3,4])
print 'Our array is:'
print a
print '\n'
print 'Applying average() function:'
print np.average(a)
print '\n'
# this is same as mean when weight is not specified
wts = np.array([4,3,2,1])
print 'Applying average() function again:'
print np.average(a,weights = wts)
print '\n'
# Returns the sum of weights, if the returned parameter is set to True.
print 'Sum of weights'
print np.average([1,2,3, 4],weights = [4,3,2,1], returned = True)Он выдаст следующий результат -
Our array is:
[1 2 3 4]
Applying average() function:
2.5
Applying average() function again:
2.0
Sum of weights
(2.0, 10.0)В многомерном массиве можно указать ось для вычисления.
пример
import numpy as np
a = np.arange(6).reshape(3,2)
print 'Our array is:'
print a
print '\n'
print 'Modified array:'
wt = np.array([3,5])
print np.average(a, axis = 1, weights = wt)
print '\n'
print 'Modified array:'
print np.average(a, axis = 1, weights = wt, returned = True)Он выдаст следующий результат -
Our array is:
[[0 1]
[2 3]
[4 5]]
Modified array:
[ 0.625 2.625 4.625]
Modified array:
(array([ 0.625, 2.625, 4.625]), array([ 8., 8., 8.]))Среднеквадратичное отклонение
Стандартное отклонение - это квадратный корень из среднего квадрата отклонений от среднего. Формула для стандартного отклонения выглядит следующим образом -
std = sqrt(mean(abs(x - x.mean())**2))Если массив равен [1, 2, 3, 4], то его среднее значение равно 2,5. Следовательно, квадраты отклонений равны [2,25, 0,25, 0,25, 2,25], а квадратный корень из среднего, деленного на 4, то есть sqrt (5/4) равен 1,1180339887498949.
пример
import numpy as np
print np.std([1,2,3,4])Он выдаст следующий результат -
1.1180339887498949Дисперсия
Дисперсия - это средний квадрат отклонений, т. Е. mean(abs(x - x.mean())**2). Другими словами, стандартное отклонение - это квадратный корень из дисперсии.
пример
import numpy as np
print np.var([1,2,3,4])Он выдаст следующий результат -
1.25В NumPy доступны различные функции, связанные с сортировкой. Эти функции сортировки реализуют различные алгоритмы сортировки, каждый из которых характеризуется скоростью выполнения, производительностью наихудшего случая, требуемым рабочим пространством и стабильностью алгоритмов. В следующей таблице показано сравнение трех алгоритмов сортировки.
| своего рода | скорость | худший случай | рабочая среда | стабильный |
|---|---|---|---|---|
| 'quicksort' | 1 | О (п ^ 2) | 0 | нет |
| 'Сортировка слиянием' | 2 | O (п * журнал (п)) | ~ n / 2 | да |
| 'heapsort' | 3 | O (п * журнал (п)) | 0 | нет |
numpy.sort ()
Функция sort () возвращает отсортированную копию входного массива. Он имеет следующие параметры -
numpy.sort(a, axis, kind, order)Где,
| Sr.No. | Параметр и описание |
|---|---|
| 1 | a Массив для сортировки |
| 2 | axis Ось, по которой нужно отсортировать массив. Если нет, массив выравнивается с сортировкой по последней оси. |
| 3 | kind По умолчанию - быстрая сортировка |
| 4 | order Если массив содержит поля, порядок сортировки полей |
пример
import numpy as np
a = np.array([[3,7],[9,1]])
print 'Our array is:'
print a
print '\n'
print 'Applying sort() function:'
print np.sort(a)
print '\n'
print 'Sort along axis 0:'
print np.sort(a, axis = 0)
print '\n'
# Order parameter in sort function
dt = np.dtype([('name', 'S10'),('age', int)])
a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt)
print 'Our array is:'
print a
print '\n'
print 'Order by name:'
print np.sort(a, order = 'name')Он выдаст следующий результат -
Our array is:
[[3 7]
[9 1]]
Applying sort() function:
[[3 7]
[1 9]]
Sort along axis 0:
[[3 1]
[9 7]]
Our array is:
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]
Order by name:
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]numpy.argsort ()
В numpy.argsort()Функция выполняет косвенную сортировку входного массива по заданной оси и использует указанный вид сортировки для возврата массива индексов данных. Этот массив индексов используется для построения отсортированного массива.
пример
import numpy as np
x = np.array([3, 1, 2])
print 'Our array is:'
print x
print '\n'
print 'Applying argsort() to x:'
y = np.argsort(x)
print y
print '\n'
print 'Reconstruct original array in sorted order:'
print x[y]
print '\n'
print 'Reconstruct the original array using loop:'
for i in y:
print x[i],Он выдаст следующий результат -
Our array is:
[3 1 2]
Applying argsort() to x:
[1 2 0]
Reconstruct original array in sorted order:
[1 2 3]
Reconstruct the original array using loop:
1 2 3numpy.lexsort ()
функция выполняет косвенную сортировку с использованием последовательности ключей. Ключи можно увидеть в виде столбца в электронной таблице. Функция возвращает массив индексов, по которому можно получить отсортированные данные. Обратите внимание, что последний ключ является первичным ключом сортировки.
пример
import numpy as np
nm = ('raju','anil','ravi','amar')
dv = ('f.y.', 's.y.', 's.y.', 'f.y.')
ind = np.lexsort((dv,nm))
print 'Applying lexsort() function:'
print ind
print '\n'
print 'Use this index to get sorted data:'
print [nm[i] + ", " + dv[i] for i in ind]Он выдаст следующий результат -
Applying lexsort() function:
[3 1 0 2]
Use this index to get sorted data:
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']Модуль NumPy имеет ряд функций для поиска внутри массива. Доступны функции для поиска максимума, минимума, а также элементов, удовлетворяющих заданному условию.
numpy.argmax () и numpy.argmin ()
Эти две функции возвращают индексы максимального и минимального элементов соответственно по заданной оси.
пример
import numpy as np
a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying argmax() function:'
print np.argmax(a)
print '\n'
print 'Index of maximum number in flattened array'
print a.flatten()
print '\n'
print 'Array containing indices of maximum along axis 0:'
maxindex = np.argmax(a, axis = 0)
print maxindex
print '\n'
print 'Array containing indices of maximum along axis 1:'
maxindex = np.argmax(a, axis = 1)
print maxindex
print '\n'
print 'Applying argmin() function:'
minindex = np.argmin(a)
print minindex
print '\n'
print 'Flattened array:'
print a.flatten()[minindex]
print '\n'
print 'Flattened array along axis 0:'
minindex = np.argmin(a, axis = 0)
print minindex
print '\n'
print 'Flattened array along axis 1:'
minindex = np.argmin(a, axis = 1)
print minindexОн выдаст следующий результат -
Our array is:
[[30 40 70]
[80 20 10]
[50 90 60]]
Applying argmax() function:
7
Index of maximum number in flattened array
[30 40 70 80 20 10 50 90 60]
Array containing indices of maximum along axis 0:
[1 2 0]
Array containing indices of maximum along axis 1:
[2 0 1]
Applying argmin() function:
5
Flattened array:
10
Flattened array along axis 0:
[0 1 1]
Flattened array along axis 1:
[0 2 0]numpy.nonzero ()
В numpy.nonzero() функция возвращает индексы ненулевых элементов во входном массиве.
пример
import numpy as np
a = np.array([[30,40,0],[0,20,10],[50,0,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying nonzero() function:'
print np.nonzero (a)Он выдаст следующий результат -
Our array is:
[[30 40 0]
[ 0 20 10]
[50 0 60]]
Applying nonzero() function:
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))numpy.where ()
Функция where () возвращает индексы элементов во входном массиве, где выполняется данное условие.
пример
import numpy as np
x = np.arange(9.).reshape(3, 3)
print 'Our array is:'
print x
print 'Indices of elements > 3'
y = np.where(x > 3)
print y
print 'Use these indices to get elements satisfying the condition'
print x[y]Он выдаст следующий результат -
Our array is:
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
Indices of elements > 3
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
Use these indices to get elements satisfying the condition
[ 4. 5. 6. 7. 8.]numpy.extract ()
В extract() функция возвращает элементы, удовлетворяющие любому условию.
import numpy as np
x = np.arange(9.).reshape(3, 3)
print 'Our array is:'
print x
# define a condition
condition = np.mod(x,2) == 0
print 'Element-wise value of condition'
print condition
print 'Extract elements using condition'
print np.extract(condition, x)Он выдаст следующий результат -
Our array is:
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
Element-wise value of condition
[[ True False True]
[False True False]
[ True False True]]
Extract elements using condition
[ 0. 2. 4. 6. 8.]Мы видели, что данные, хранящиеся в памяти компьютера, зависят от архитектуры процессора. Это может быть прямой порядок байтов (наименее значимый хранится в наименьшем адресе) или обратный порядок байтов (старший байт наименьшего адреса).
numpy.ndarray.byteswap ()
В numpy.ndarray.byteswap() функция переключает между двумя представлениями: bigendian и little-endian.
import numpy as np
a = np.array([1, 256, 8755], dtype = np.int16)
print 'Our array is:'
print a
print 'Representation of data in memory in hexadecimal form:'
print map(hex,a)
# byteswap() function swaps in place by passing True parameter
print 'Applying byteswap() function:'
print a.byteswap(True)
print 'In hexadecimal form:'
print map(hex,a)
# We can see the bytes being swappedОн выдаст следующий результат -
Our array is:
[1 256 8755]
Representation of data in memory in hexadecimal form:
['0x1', '0x100', '0x2233']
Applying byteswap() function:
[256 1 13090]
In hexadecimal form:
['0x100', '0x1', '0x3322']При выполнении функций некоторые из них возвращают копию входного массива, а некоторые возвращают представление. Когда содержимое физически хранится в другом месте, оно называетсяCopy. Если, с другой стороны, предоставляется другое представление того же содержимого памяти, мы называем этоView.
Нет копии
Простые назначения не делают копию объекта массива. Вместо этого для доступа к нему он использует тот же идентификатор (), что и исходный массив. Вid() возвращает универсальный идентификатор объекта Python, аналогичный указателю в C.
Более того, любые изменения в одном отражаются в другом. Например, изменение формы одного из них также изменит форму другого.
пример
import numpy as np
a = np.arange(6)
print 'Our array is:'
print a
print 'Applying id() function:'
print id(a)
print 'a is assigned to b:'
b = a
print b
print 'b has same id():'
print id(b)
print 'Change shape of b:'
b.shape = 3,2
print b
print 'Shape of a also gets changed:'
print aОн выдаст следующий результат -
Our array is:
[0 1 2 3 4 5]
Applying id() function:
139747815479536
a is assigned to b:
[0 1 2 3 4 5]
b has same id():
139747815479536
Change shape of b:
[[0 1]
[2 3]
[4 5]]
Shape of a also gets changed:
[[0 1]
[2 3]
[4 5]]Просмотр или неглубокая копия
NumPy имеет ndarray.view()Метод, который представляет собой новый объект массива, который просматривает те же данные исходного массива. В отличие от предыдущего случая, изменение размеров нового массива не меняет размеров оригинала.
пример
import numpy as np
# To begin with, a is 3X2 array
a = np.arange(6).reshape(3,2)
print 'Array a:'
print a
print 'Create view of a:'
b = a.view()
print b
print 'id() for both the arrays are different:'
print 'id() of a:'
print id(a)
print 'id() of b:'
print id(b)
# Change the shape of b. It does not change the shape of a
b.shape = 2,3
print 'Shape of b:'
print b
print 'Shape of a:'
print aОн выдаст следующий результат -
Array a:
[[0 1]
[2 3]
[4 5]]
Create view of a:
[[0 1]
[2 3]
[4 5]]
id() for both the arrays are different:
id() of a:
140424307227264
id() of b:
140424151696288
Shape of b:
[[0 1 2]
[3 4 5]]
Shape of a:
[[0 1]
[2 3]
[4 5]]Срез массива создает представление.
пример
import numpy as np
a = np.array([[10,10], [2,3], [4,5]])
print 'Our array is:'
print a
print 'Create a slice:'
s = a[:, :2]
print sОн выдаст следующий результат -
Our array is:
[[10 10]
[ 2 3]
[ 4 5]]
Create a slice:
[[10 10]
[ 2 3]
[ 4 5]]Глубокая копия
В ndarray.copy()функция создает глубокую копию. Это полная копия массива и его данных, не имеющая общего с исходным массивом.
пример
import numpy as np
a = np.array([[10,10], [2,3], [4,5]])
print 'Array a is:'
print a
print 'Create a deep copy of a:'
b = a.copy()
print 'Array b is:'
print b
#b does not share any memory of a
print 'Can we write b is a'
print b is a
print 'Change the contents of b:'
b[0,0] = 100
print 'Modified array b:'
print b
print 'a remains unchanged:'
print aОн выдаст следующий результат -
Array a is:
[[10 10]
[ 2 3]
[ 4 5]]
Create a deep copy of a:
Array b is:
[[10 10]
[ 2 3]
[ 4 5]]
Can we write b is a
False
Change the contents of b:
Modified array b:
[[100 10]
[ 2 3]
[ 4 5]]
a remains unchanged:
[[10 10]
[ 2 3]
[ 4 5]]Пакет NumPy содержит библиотеку Matrix numpy.matlib. В этом модуле есть функции, которые возвращают матрицы вместо объектов ndarray.
matlib.empty ()
В matlib.empty()функция возвращает новую матрицу без инициализации записей. Функция принимает следующие параметры.
numpy.matlib.empty(shape, dtype, order)Где,
| Sr.No. | Параметр и описание |
|---|---|
| 1 | shape int или кортеж из int определение формы новой матрицы |
| 2 | Dtype Необязательный. Тип данных вывода |
| 3 | order 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.zeros ()
Эта функция возвращает матрицу, заполненную нулями.
import numpy.matlib
import numpy as np
print np.matlib.zeros((2,2))Он выдаст следующий результат -
[[ 0. 0.]
[ 0. 0.]]numpy.matlib.ones ()
Эта функция возвращает матрицу, заполненную единицами.
import numpy.matlib
import numpy as np
print np.matlib.ones((2,2))Он выдаст следующий результат -
[[ 1. 1.]
[ 1. 1.]]numpy.matlib.eye ()
Эта функция возвращает матрицу с 1 вдоль диагональных элементов и нулями в других местах. Функция принимает следующие параметры.
numpy.matlib.eye(n, M,k, dtype)Где,
| Sr.No. | Параметр и описание |
|---|---|
| 1 | n Количество строк в итоговой матрице |
| 2 | M Количество столбцов, по умолчанию n |
| 3 | k Индекс диагонали |
| 4 | 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.matlib.identity ()
В numpy.matlib.identity()Функция возвращает матрицу идентичности заданного размера. Единичная матрица - это квадратная матрица, в которой все диагональные элементы равны 1.
import numpy.matlib
import numpy as np
print np.matlib.identity(5, dtype = float)Он выдаст следующий результат -
[[ 1. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 1.]]numpy.matlib.rand ()
В numpy.matlib.rand() функция возвращает матрицу заданного размера, заполненную случайными значениями.
пример
import numpy.matlib
import numpy as np
print np.matlib.rand(3,3)Он выдаст следующий результат -
[[ 0.82674464 0.57206837 0.15497519]
[ 0.33857374 0.35742401 0.90895076]
[ 0.03968467 0.13962089 0.39665201]]Noteчто матрица всегда двумерна, тогда как ndarray - это n-мерный массив. Оба объекта взаимно конвертируемы.
пример
import numpy.matlib
import numpy as np
i = np.matrix('1,2;3,4')
print iОн выдаст следующий результат -
[[1 2]
[3 4]]пример
import numpy.matlib
import numpy as np
j = np.asarray(i)
print jОн выдаст следующий результат -
[[1 2]
[3 4]]пример
import numpy.matlib
import numpy as np
k = np.asmatrix (j)
print kОн выдаст следующий результат -
[[1 2]
[3 4]]Пакет NumPy содержит numpy.linalgмодуль, который предоставляет все функции, необходимые для линейной алгебры. Некоторые важные функции этого модуля описаны в следующей таблице.
| Sr.No. | Описание функции |
|---|---|
| 1 | точка Точечное произведение двух массивов |
| 2 | вдот Точечное произведение двух векторов |
| 3 | внутренний Внутреннее произведение двух массивов |
| 4 | Матмуль Матричное произведение двух массивов |
| 5 | детерминант Вычисляет определитель массива |
| 6 | решить Решает линейное матричное уравнение |
| 7 | inv Находит мультипликативную обратную матрицу |
Matplotlib - это библиотека построения графиков для Python. Он используется вместе с NumPy, чтобы предоставить среду, которая является эффективной альтернативой с открытым исходным кодом для MatLab. Его также можно использовать с наборами графических инструментов, такими как PyQt и wxPython.
Модуль Matplotlib был впервые написан Джоном Д. Хантером. С 2012 года главным разработчиком является Майкл Дроетбум. В настоящее время Matplotlib ver. 1.5.1 - это доступная стабильная версия. Пакет доступен в двоичном виде, а также в виде исходного кода на сайте www.matplotlib.org .
Обычно пакет импортируется в скрипт Python путем добавления следующего оператора:
from matplotlib import pyplot as pltВот pyplot()- самая важная функция библиотеки matplotlib, которая используется для построения 2D-данных. Следующий сценарий строит уравнение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() function как значения на x axis. Соответствующие значения наy axis хранятся в другом ndarray object y. Эти значения отображаются с использованиемplot() функция подмодуля pyplot пакета matplotlib.
Графическое представление отображается show() функция.
Приведенный выше код должен дать следующий результат -
Вместо линейного графика значения можно отобразить дискретно, добавив строку формата к plot()функция. Могут использоваться следующие символы форматирования.
| Sr.No. | Характер и описание |
|---|---|
| 1 | '-' Стиль сплошной линии |
| 2 | '--' Стиль пунктирной линии |
| 3 | '-.' Штрих-пунктирная линия |
| 4 | ':' Пунктирная линия |
| 5 | '.' Маркер точки |
| 6 | ',' Маркер пикселей |
| 7 | 'o' Маркер круга |
| 8 | 'v' Маркер Triangle_down |
| 9 | '^' Маркер Triangle_up |
| 10 | '<' Маркер Triangle_left |
| 11 | '>' Треугольник_правый маркер |
| 12 | '1' Маркер Tri_down |
| 13 | '2' Маркер Tri_up |
| 14 | '3' Тройной левый маркер |
| 15 | '4' Tri_right маркер |
| 16 | 's' Квадратный маркер |
| 17 | 'p' Пентагон маркер |
| 18 | '*' Звездный маркер |
| 19 | 'h' Маркер Hexagon1 |
| 20 | 'H' Маркер Hexagon2 |
| 21 год | '+' Маркер плюс |
| 22 | 'x' Маркер X |
| 23 | 'D' Алмазный маркер |
| 24 | 'd' Маркер Thin_diamond |
| 25 | '|' Маркер Vline |
| 26 | '_' Маркер Hline |
Также определены следующие сокращения цветов.
| символ | цвет |
|---|---|
| 'b' | Синий |
| 'г' | Зеленый |
| 'р' | Красный |
| 'c' | Голубой |
| 'м' | Пурпурный |
| 'y' | Желтый |
| 'k' | Черный |
| 'w' | Белый |
Чтобы отобразить круги, представляющие точки, вместо линии в приведенном выше примере используйте “ob” как строка формата в функции plot ().
пример
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,"ob")
plt.show()Приведенный выше код должен дать следующий результат -
График синусоидальной волны
Следующий скрипт производит sine wave plot используя matplotlib.
пример
import numpy as np
import matplotlib.pyplot as plt
# Compute the x and y coordinates for points on a sine curve
x = np.arange(0, 3 * np.pi, 0.1)
y = np.sin(x)
plt.title("sine wave form")
# Plot the points using matplotlib
plt.plot(x, y)
plt.show()
подзаговор ()
Функция subplot () позволяет рисовать разные объекты на одном рисунке. В следующем сценарииsine и cosine values нанесены.
пример
import numpy as np
import matplotlib.pyplot as plt
# Compute the x and y coordinates for points on sine and cosine curves
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
# Set up a subplot grid that has height 2 and width 1,
# and set the first such subplot as active.
plt.subplot(2, 1, 1)
# Make the first plot
plt.plot(x, y_sin)
plt.title('Sine')
# Set the second subplot as active, and make the second plot.
plt.subplot(2, 1, 2)
plt.plot(x, y_cos)
plt.title('Cosine')
# Show the figure.
plt.show()Приведенный выше код должен дать следующий результат -
бар()
В pyplot submodule обеспечивает bar()функция для создания гистограмм. В следующем примере создается гистограмма двух наборовx и y массивы.
пример
from matplotlib import pyplot as plt
x = [5,8,10]
y = [12,16,6]
x2 = [6,9,11]
y2 = [6,15,7]
plt.bar(x, y, align = 'center')
plt.bar(x2, y2, color = 'g', align = 'center')
plt.title('Bar graph')
plt.ylabel('Y axis')
plt.xlabel('X axis')
plt.show()Этот код должен выдать следующий результат -
NumPy имеет numpy.histogram()функция, которая представляет собой графическое представление частотного распределения данных. Прямоугольники равного размера по горизонтали, соответствующие интервалу классов, называютсяbin и variable height соответствует частоте.
numpy.histogram ()
Функция numpy.histogram () принимает входной массив и ячейки как два параметра. Последовательные элементы в массиве ячеек действуют как граница каждого ящика.
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() function подмодуля 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()Он должен выдать следующий результат -
Объекты ndarray можно сохранять и загружать из файлов на диске. Доступные функции ввода-вывода:
load() и save() функции handle / numPy двоичные файлы (с npy расширение)
loadtxt() и savetxt() функции обрабатывают обычные текстовые файлы
NumPy представляет простой формат файла для объектов ndarray. Этот.npy file хранит данные, форму, dtype и другую информацию, необходимую для восстановления ndarray в файле на диске, чтобы массив был правильно извлечен, даже если файл находится на другом компьютере с другой архитектурой.
numpy.save ()
В 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. Рассол в Python используется для сериализации и десериализации объектов перед сохранением или чтением из файла на диске.
savetxt ()
Хранение и извлечение данных массива в формате простого текстового файла осуществляется с помощью 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.]Функции savetxt () и loadtxt () принимают дополнительные необязательные параметры, такие как верхний колонтитул, нижний колонтитул и разделитель.