Основные функции для работы с массивами в NumPy

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

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

Создание из списков и кортежей

• np.array(object, dtype=None, copy=True, order='K'): Преобразует список или кортеж в массив NumPy.

  import numpy as np
  
  a = np.array([1, 2, 3, 4])
  b = np.array([[1, 2], [3, 4]])

Специальные функции для создания массивов

• np.zeros(shape, dtype=float, order='C'): Создает массив, заполненный нулями.

  zeros = np.zeros((3, 4))  # array([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]])

• np.ones(shape, dtype=float, order='C'): Создает массив, заполненный единицами.

  ones = np.ones((2, 5))  # array([[1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.]])

• np.full(shape, fill_value, dtype=None, order='C'): Создает массив, заполненный заданным значением.

  full = np.full((2, 2), 7)  # array([[7, 7], [7, 7]])

• np.eye(N, M=None, dtype=float, order='C'): Создает единичную матрицу размером ( N \times M ).

  eye = np.eye(3)  # array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]])

• np.arange(start, stop, step, dtype=None): Создает массив с диапазоном значений.

  arange = np.arange(10)  # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

• np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None): Создает массив с равномерным распределением значений.

  linspace = np.linspace(0, 1, 5)  # array([0. , 0.25, 0.5 , 0.75, 1. ])

• np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None): Создает массив с логарифмически распределенными значениями.

  logspace = np.logspace(1, 3, 3)  # array([ 10., 100., 1000.])

Операции с массивами

Арифметические операции

• +, -, *, /, **: Операции поэлементного сложения, вычитания, умножения, деления и возведения в степень.

  a = np.array([1, 2, 3])
  b = np.array([4, 5, 6])
  add = a + b  # array([5, 7, 9])
  sub = a - b  # array([-3, -3, -3])
  mul = a * b  # array([ 4, 10, 18])
  div = a / b  # array([0.25, 0.4 , 0.5 ])
  pow = a ** 2  # array([1, 4, 9])

Универсальные функции (ufunc)

• np.sin(x), np.cos(x), np.exp(x), np.log(x), np.sqrt(x): Применяются поэлементно к массиву.

  a = np.array([0, np.pi/2, np.pi])
  sin_a = np.sin(a)  # array([0. , 1. , 0.])
  cos_a = np.cos(a)  # array([ 1.,  0., -1.])
  exp_a = np.exp(a)  # array([ 1.        ,  4.81047738, 23.14069263])
  log_a = np.log(a + 1)  # array([0.        , 0.40546511, 1.09861229])
  sqrt_a = np.sqrt(a)  # array([0.        , 1.        , 1.77245385])

Индексация и срезы

• Индексация: Доступ к элементам массива.

  a = np.array([10, 20, 30, 40, 50])
  element = a[2]  # 30

• Срезы: Извлечение подмассивов.

  slice_a = a[1:4]  # array([20, 30, 40])

• Многомерные массивы:

  b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
  row = b[1, :]  # array([4, 5, 6])
  column = b[:, 2]  # array([3, 6, 9])

Изменение формы массива

• reshape(newshape): Изменяет форму массива без изменения данных.

  a = np.array([1, 2, 3, 4, 5, 6])
  reshaped_a = a.reshape((2, 3))  # array([[1, 2, 3], [4, 5, 6]])

• ravel(): Возвращает массив в одномерном виде.

  flattened = reshaped_a.ravel()  # array([1, 2, 3, 4, 5, 6])

• flatten(): Возвращает копию массива в одномерном виде.

  flattened_copy = reshaped_a.flatten()  # array([1, 2, 3, 4, 5, 6])

• transpose(): Транспонирует массив.

  transposed = reshaped_a.T  # array([[1, 4], [2, 5], [3, 6]])

Объединение и разделение массивов

• np.concatenate((a, b), axis=0): Объединяет массивы по заданной оси.

  a = np.array([1, 2])
  b = np.array([3, 4])
  concatenated = np.concatenate((a, b))  # array([1, 2, 3, 4])

• np.stack((a, b), axis=0): Стекует массивы по новой оси.

  stacked = np.stack((a, b), axis=0)  # array([[1, 2], [3, 4]])

• np.split(a, indices_or_sections): Разделяет массив на части.

  a = np.array([1, 2, 3, 4, 5, 6])
  split = np.split(a, 3)  # [array([1, 2]), array([3, 4]), array([5, 6])]

Математические операции

• np.mean(a, axis=None): Вычисляет среднее значение.

  mean_a = np.mean(a)  # Среднее значение массива

• np.median(a, axis=None): Вычисляет медиану.

  median_a = np.median(a)  # Медиана массива

• np.std(a, axis=None): Вычисляет стандартное отклонение.

  std_a = np.std(a)  # Стандартное отклонение массива

• np.sum(a, axis=None): Вычисляет сумму элементов.

  sum_a = np.sum(a)  # Сумма всех элементов массива

• np.prod(a, axis=None): Вычисляет произведение элементов.

  prod_a = np.prod(a)  # Произведение всех элементов массива

Условные операции и маскирование

• np.where(condition, [x, y]): Возвращает элементы из `x

илиy` в зависимости от условия.

condition = np.array([True, False, True])
x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
result = np.where(condition, x, y)  # array([1, 5, 3])

• np.where(condition): Возвращает индексы, где условие истинно.

  a = np.array([10, 20, 30, 40])
  indices = np.where(a > 25)  # (array([2, 3]),)

Бинарные операции и линейная алгебра

Векторные и матричные операции

• np.dot(a, b): Вычисляет скалярное произведение или произведение матриц.

  A = np.array([[1, 2], [3, 4]])
  B = np.array([[5, 6], [7, 8]])
  dot_product = np.dot(A, B)  # array([[19, 22], [43, 50]])

• np.matmul(a, b): Выполняет матричное умножение.

  matmul_product = np.matmul(A, B)  # array([[19, 22], [43, 50]])

• np.linalg.inv(a): Вычисляет обратную матрицу.

  inv_A = np.linalg.inv(A)  # array([[-2. ,  1. ], [ 1.5, -0.5]])

• np.linalg.eig(a): Вычисляет собственные значения и векторы.

  eigenvalues, eigenvectors = np.linalg.eig(A)

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