Модуль NumPy

определение
NumPy — это расширение языка Python, добавляющее поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами.
Создание массива
import numpy as np
a = np.array([1, 2, 3])
a
type(a)
Основные атрибуты объектa ndarray
Основным объектом NumPy является однородный многомерный массив (numpy.ndarray).

ndarray.ndim - число измерений (чаще их называют "оси") массива.

ndarray.shape - размеры массива, его форма. Это кортеж натуральных чисел, показывающий длину массива по каждой оси. Для матрицы из n строк и m столбов, shape будет (n,m). Число элементов кортежа shape равно ndim.

ndarray.size - количество элементов массива. Hавно произведению всех элементов атрибута shape.

ndarray.dtype - объект, описывающий тип элементов массива. Можно определить dtype, используя стандартные типы данных Python или встроенные: bool_, character, int8, int16, int32, int64, float8, float16, float32, float64, complex64, object_, так и возможно определить собственные типы данных.
Использование команд
import numpy as np

a = np.array([[1.5, 2, 3], [4, 5, 6]], dtype=np.int16)

print(a.ndim)

print(a.shape)

print(a.size)

print(a.dtype)
Создание массивов
array - создает массив указанных элементов
zeros - создает массив из нулей
ones - создает массив из единиц
eye - создаёт единичную матрицу (двумерный массив)
Создание массива
z = np.zeros((5, 5))
print(z)
'''array([[ 0.,  0.,  0.,  0.,  0.],
            [ 0.,  0.,  0.,  0.,  0.],
            [ 0.,  0.,  0.,  0.,  0.],
            [ 0.,  0.,  0.,  0.,  0.],
            [ 0.,  0.,  0.,  0.,  0.],])'''

o = np.ones((2, 2, 2))
print(o)
'''array([[[ 1.,  1.],
             [ 1.,  1.]],

             [[ 1.,  1.],
              [ 1.,  1.]]])'''

e = np.eye(5)
print(e)
'''array([[ 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.]])'''

Генерация числовых массивов
arange - функция генерации числового массива аналогичная встроенной range(). Указывается начало последовательности, конец последовательности и шаг.

linspace - функция, которая вместо шага в качестве одного из аргументов принимает число, равное количеству нужных элементов в указанном диапазоне.

fromfunction - применяет функцию ко всем комбинациям индексов
Генерация массива
a= np.arange(10, 30, 5)
print(a)   #array([10, 15, 20, 25])

l= np.linspace(0, 2, 9)
print (l) #array([  0. ,  0.25,  0.5 ,  0.75, 1. , 1.25, 1.5 , 1.75, 2. ])

def f1(i, j):
    return 3 * i + j

f = np.fromfunction(f1, (3, 4))
print(f)
'''array([[ 0.,  1.,  2.,  3.],
            [ 3.,  4.,  5.,  6.],
            [ 6.,  7.,  8.,  9.]])'''
Обращение к элементам массива
Для обращения к элементам массива используется запись с указанием индексов элемента.

* при обращении к элементам как к связанному списку (a[0][0]) - тратит много памяти - не рекомендуется
Обращение к элементам массива
a= np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]])
# первый элемен
print(a[0, 0])

# первая строка
print(a[0,:])

# первый столбец
print(a[:,0])

# выбор элементов с шагом 2
print(a[:,::2])

# выбор элементы первой строки четных столбцов
print(a[0,1::2])

# выбор элементы первой строки четных столбцов с обратной индексацией
print(a[0,1::2][::-1])

# выбор элементов первого и последнего столбца
print(a[:,[0,-1]])

# выбор элементов на пересечении строк и столбцов
print(a[[2, 4]][:,[0,1]])
Изменение размерности массива
reshape - команда изменяет размер массива.

Для автоматического вычисления размерности столбца или строки указывается -1
Обращение к элементам массива
a= np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])

print(a)
'''array[[ 1  2  3  4  5]
           [ 6  7  8  9 10]]'''

print(a.reshape(5,2))
'''array [[ 1  2]
          [ 3  4]
          [ 5  6]
          [ 7  8]
          [ 9 10]]'''


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

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

print(a.reshape(3, 2, 2))
'''array [[[ 1  2]
           [ 3  4]]

          [[ 5  6]
           [ 7  8]]

          [[ 9 10]
           [11 12]]]'''

print(a.reshape(2, 2, -1)) # автоматическое вычисление размерности
'''array [[[ 1  2  3]
           [ 4  5  6]]

          [[ 7  8  9]
           [10 11 12]]]'''
изменение представления массива
flaten - команда копирует массив и делает его одномерным
ravel - одномерное представление массива без его копирования

T - транспонирование матрицы без ее копирования
Изменение представления массива
a= np.array([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]])

print(a.ravel())
# [ 1  2  3  4  5  6  7  8  9 10 11 12]

print(a.T)
'''[[ 1  7]
    [ 2  8]
    [ 3  9]
    [ 4 10]
    [ 5 11]
    [ 6 12]]'''
Базовые операции над массивами
Математические операции над массивами выполняются поэлементно. Создается новый массив, который заполняется результатами действия оператора. Для этого массивы должны быть одинаковых размеров.

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

NumPy также предоставляет множество математических операций для обработки массивов
Базовые операции
a = np.array([1, 2, 3, 4, 5, 6])
b = np.array([1, 2, 3, 4, 5, 6])

print(a+b)

print(a-b)

print(a*b)

print(a/b)

print(a**b)

# Наименьшее число в каждом столбце
print(a.min(axis=0))

# Наименьшее число в каждой строке
print(a.min(axis=1)) 
Объединение массивов
Несколько массивов могут быть объединены вместе вдоль разных осей с помощью функций:

hstack() - объединяет массивы по первым осям,
vstack() — объединяет массивы по последним:
column_stack() - объединяет одномерные массивы в качестве столбцов двумерного массива
row_stack() - объединяет одномерные массивы в качестве строк двумерного массива
Базовые операции
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

np.vstack((a, b))
'''[[1, 2],
    [3, 4],
    [5, 6],
    [7, 8]]'''

np.hstack((a, b))
'''[[1, 2, 5, 6],
    [3, 4, 7, 8]]'''
Разбиение массива
hsplit() - разбивает массив вдоль горизонтальной оси, указав либо число возвращаемых массивов одинаковой формы, либо номера столбцов

vsplit() - разбивает массив вдоль вертикальной оси

array_split() - позволяет указать оси, вдоль которых произойдет разбиение.
Базовые операции
a = np.arange(12).reshape((2, 6))

 # Разбить на 3 части
print(np.hsplit(a, 3)) 

 # Разрезать a после третьего и четвёртого столбца
print(np.hsplit(a, (3, 4)))