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

Результат выглядит следующим образом -

4

numpy.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 3

numpy.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 () принимают дополнительные необязательные параметры, такие как верхний колонтитул, нижний колонтитул и разделитель.