Введение

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

простая функция

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

arr = np.arange(10)

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Вычислить квадратный корень элемента массива:

np.sqrt(arr)

array([0.    , 1.    , 1.4142, 1.7321, 2.    , 2.2361, 2.4495, 2.6458,
       2.8284, 3.    ])

Показательная функция с основанием e натуральной константы:

np.exp(arr)

array([   1.    ,    2.7183,    7.3891,   20.0855,   54.5982,  148.4132,
        403.4288, 1096.6332, 2980.958 , 8103.0839])

Возьмите максимальное значение двух массивов, чтобы сформировать новый массив:

x = np.random.randn(8)
y = np.random.randn(8)
x,y

(array([-2.3594, -0.1995, -1.542 , -0.9707, -1.307 ,  0.2863,  0.378 ,
        -0.7539]),
 array([ 0.3313,  1.3497,  0.0699,  0.2467, -0.0119,  1.0048,  1.3272,
        -0.9193]))

np.maximum(x, y)

array([ 0.3313,  1.3497,  0.0699,  0.2467, -0.0119,  1.0048,  1.3272,
       -0.7539])

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

arr = np.random.randn(7) * 5

array([-7.7455,  0.1109,  3.7918, -3.3026,  4.3129, -0.0502,  0.25  ])

remainder, whole_part = np.modf(arr)

(array([-0.7455,  0.1109,  0.7918, -0.3026,  0.3129, -0.0502,  0.25  ]),
 array([-7.,  0.,  3., -3.,  4., -0.,  0.]))

операции с векторизованными массивами

Если вы хотите выполнять операции между массивами, распространенный метод — обход цикла, но это будет менее эффективно. Итак, Numpy предоставляет методы для обработки данных между массивами.

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

Давайте сначала посмотрим на код координатной точки:

import numpy as np
import matplotlib.pyplot as plt

x = np.array([[0, 1, 2], [0, 1, 2]])
y = np.array([[0, 0, 0], [1, 1, 1]])


plt.plot(x, y,
         color='green',
         marker='.',
         linestyle='')
plt.grid(True)
plt.show()

Приведенный выше X представляет собой двумерный массив, который представляет положение оси X координатной точки.

Y также является двумерным массивом, который представляет положение координатной точки по оси Y.

Взгляните на нарисованное изображение:

То, что нарисовано выше, представляет собой 6 точек координат, которые объединены с использованием матрицы X, Y.

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

Итак, есть функция np.meshgrid. Эта функция принимает два одномерных массива и генерирует двумерную матрицу координат X, Y.

Приведенный выше пример можно переписать как:

x = np.array([0,1,2])
y = np.array([0,1])

xs, ys = np.meshgrid(x, y)
xs,ys
(array([[0, 1, 2],
        [0, 1, 2]]), 
 array([[0, 0, 0],
        [1, 1, 1]]))

Вы можете видеть, что сгенерированные xs и ys совпадают с введенными вручную.

С координатами сетки мы можем вычислить некоторые данные на основе значений сетки, например:$sqrt(x^2+y^2)$, нам не нужны все данные в переменной матрице, нам просто нужно использовать массив непосредственно для операций:

np.sqrt(xs ** 2 + ys ** 2)

результат:

array([[0.        , 1.        , 2.        ],
       [1.        , 1.41421356, 2.23606798]])

Поскольку xs и ys сами по себе являются матрицами 2 * 3, результатом также является матрица 2 * 3.

условное логическое выражение

Мы можем использовать условные логические выражения при построении массивов:

xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])

result = [(x if c else y)
          for x, y, c in zip(xarr, yarr, cond)]
result

[1.1, 2.2, 1.3, 1.4, 2.5]

Немного проще, мы можем использовать оператор where:

result = np.where(cond, xarr, yarr)
result

array([1.1, 2.2, 1.3, 1.4, 2.5])

Мы также можем изменить значение массива в соответствии с условием where:

arr = np.random.randn(4, 4)
arr
array([[ 0.7953,  0.1181, -0.7485,  0.585 ],
       [ 0.1527, -1.5657, -0.5625, -0.0327],
       [-0.929 , -0.4826, -0.0363,  1.0954],
       [ 0.9809, -0.5895,  1.5817, -0.5287]])

Выше мы построили массив 4*4.

Мы можем сравнить данные, где, если они больше 0, измените данные на 2, если они меньше 0, измените данные на -2:

np.where(arr > 0, 2, -2)
array([[ 2,  2, -2,  2],
       [ 2, -2, -2, -2],
       [-2, -2, -2,  2],
       [ 2, -2,  2, -2]])

Статистические методы

Numpy предоставляет статистические методы, такие как среднее значение и сумма:

arr = np.random.randn(5, 4)
arr
arr.mean()
np.mean(arr)
arr.sum()

Вы также можете считать по размеру:

arr.mean(axis=1)
arr.sum(axis=0)

cumsum для кумулятивного расчета:

arr = np.array([0, 1, 2, 3, 4, 5, 6, 7])
arr.cumsum()

array([ 0,  1,  3,  6, 10, 15, 21, 28])

cumprod выполняет вычисление кумулятивного умножения:

arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
arr
arr.cumsum(axis=0)

array([[ 0,  1,  2],
       [ 3,  5,  7],
       [ 9, 12, 15]])

arr.cumprod(axis=1)

array([[  0,   0,   0],
       [  3,  12,  60],
       [  6,  42, 336]])

логический массив

any используется для проверки наличия в массиве одного или нескольких значений True, а all проверяет, являются ли все значения в массиве True:

bools = np.array([False, False, True, False])
bools.any()
True

bools.all()
False

Сортировать

Массивы можно сортировать с помощью сортировки, помимо обычной сортировки можно также сортировать по определенной оси:

arr = np.random.randn(6)
arr.sort()

array([-2.5579, -1.2943, -0.2972, -0.1516,  0.0765,  0.1608])

arr = np.random.randn(5, 3)
arr
arr.sort(1)
arr

array([[-0.8852, -0.4936, -0.1875],
       [-0.3507, -0.1154,  0.0447],
       [-1.1512, -0.8978,  0.8909],
       [-2.6123, -0.8671,  1.1413],
       [-0.437 ,  0.3475,  0.3836]])

sort(1) относится к сортировке по второй оси.

документ

Массивы можно легко записывать и читать из файла:

arr = np.arange(10)
np.save('some_array', arr)

будет хранить массив в файле some_array.npy, мы можем прочитать его так:

np.load('some_array.npy')

Также возможно хранить несколько массивов в несжатом виде:

np.savez('array_archive.npz', a=arr, b=arr)

Читать:

arch = np.load('array_archive.npz')
arch['b']

Если вы хотите сжать, вы можете сделать это:

np.savez_compressed('arrays_compressed.npz', a=arr, b=arr)

Линейная алгебра

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

Матрица 2*3 усеивает матрицу 3*2 и, наконец, матрицу 2*2.

x = np.array([[1., 2., 3.], [4., 5., 6.]])
y = np.array([[6., 23.], [-1, 7], [8, 9]])
x
y
x.dot(y)

array([[ 28.,  64.],
       [ 67., 181.]])

Или можно написать так:

np.dot(x, y)

array([[ 28.,  64.],
       [ 67., 181.]])

Вы также можете использовать символ @:

x @ y

array([[ 28.,  64.],
       [ 67., 181.]])

Посмотрим, какие операции есть:

Работа продукта:

оператор	описывать
dot(a, b[, out])	матричное скалярное произведение
linalg.multi_dot(arrays, *[, out])	Множественное матричное скалярное произведение
vdot(a, b)	Векторный скалярный продукт
inner(a, b)	Внутреннее произведение двух массивов
outer(a, b[, out])	Внешний продукт двух векторов
matmul(x1, x2, /[ out, casting, order, …])	произведение соответствующих битов двух матриц
tensordot(a, b[, axes])	вычисляет скалярное произведение тензора вдоль указанной оси
einsum(индексы, *операнды[ out, dtype, …])	Эйнштейнсоглашение о суммировании
einsum_path(subscripts, *operands[, optimize])	Оцените порядок сокращения выражений einsum с наименьшими затратами, учитывая создание промежуточных массивов.
linalg.matrix_power(a, n)	возведение матрицы в степень
kron(a, b)	Кронекеровское произведение матриц

Операция разложения:

оператор	описывать
linalg.cholesky(a)	Choleskyавария
linalg.qr(a[, mode])	Вычислите факторизацию qr матрицы
linalg.svd(a[ full_matrices, calculate_uv, …])	сингулярное разложение

Собственные значения и собственные векторы:

действовать	описывать
linalg.eig(a)	Вычислите собственные значения и правые собственные векторы квадратной матрицы.
linalg.eigh(a[, UPLO])	Возвращает собственные значения и собственные векторы комплексной эрмитовой (сопряженной симметричной) или вещественной симметричной матрицы.
linalg.eigvals(a)	Вычислите собственные значения общей матрицы.
linalg.eigvalsh(a[, UPLO])	Вычисляет собственные значения комплексной эрмитовой (сопряженной симметричной) или вещественной симметричной матрицы.

Исходная величина:

действовать	описывать
linalg.norm(x[, ord, axis, keepdims])	матричная или векторная норма
linalg.cond(x[, p])	Compute the condition number of a matrix.
linalg.det(a)	определитель матрицы
linalg.matrix_rank(M[, tol, hermitian])	Вернуть матричный ранг массива с помощью метода SVD
linalg.slogdet(a)	Вычислить знак и (натуральный) логарифм определителя массива.
trace(a[, offset, axis1, axis2, dtype, out])	Возвращает сумму по диагонали массива.

Решить и инвертировать:

действовать	описывать
linalg.solve(a, b)	Решите линейные матричные уравнения или системы линейных скалярных уравнений.
linalg.tensorsolve(a, b[, axes])	Решите тензорное уравнение «a x = b» относительно x.
linalg.lstsq(a, b[, rcond])	Верните решение наименьших квадратов к линейному матричному уравнению
linalg.inv(a)	Вычисляет (мультипликативную) обратную матрицу.
linalg.pinv(a[, rcond, hermitian])	Вычисляет (Мура-Пенроуза) псевдообратную матрицу.
linalg.tensorinv(a[, ind])	Вычислите «инверсию» N-мерного массива.

случайный номер

Много раз нам нужно генерировать случайные числа Генерация случайных чисел в NumPy очень проста:

samples = np.random.normal(size=(4, 4))
samples

array([[-2.0016, -0.3718,  1.669 , -0.4386],
       [-0.5397,  0.477 ,  3.2489, -1.0212],
       [-0.5771,  0.1241,  0.3026,  0.5238],
       [ 0.0009,  1.3438, -0.7135, -0.8312]])

В приведенном выше примере используется normal для получения выборочного массива 4x4 со стандартным нормальным распределением.

Использование np.random намного быстрее, чем использование собственного генератора случайных чисел Python.

np.random может указать начальное число для генерации случайных чисел:

np.random.seed(1234)

Функция генерации данных numpy.random использует глобальное случайное начальное число. Чтобы избежать глобального состояния, вы можете использовать numpy.random.RandomState, который создает генератор случайных чисел, изолированный от других:

rng = np.random.RandomState(1234)
rng.randn(10)

Эта статья была включена вwoohoo.floydpress.com/10-python-вы…

Самая популярная интерпретация, самая глубокая галантерея, самые краткие уроки и множество трюков, о которых вы не знаете, ждут вас!

Добро пожаловать, чтобы обратить внимание на мой официальный аккаунт: «Программируйте эти вещи», разбирайтесь в технологиях, лучше поймите себя!