NumPy

NumPy (Numerical Python) - это библиотека для языка программирования Python, которая предоставляет поддержку для работы с многомерными массивами и математическими функциями. Она является фундаментом многих других библиотек для научных вычислений и анализа данных, таких как SciPy, Pandas и Matplotlib. 

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

Многомерные массивы: NumPy позволяет создавать массивы с любым числом измерений. Это удобно при работе с данными, которые имеют более одной размерности.

Быстрые операции: NumPy предоставляет высоко оптимизированные операции над массивами, что делает его значительно быстрее, чем обычные списки в Python.

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

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

Прежде чем начать использовать библиотеку NumPy, вам нужно убедиться, что она установлена на вашей системе. Если вы используете среду Python, установка NumPy довольно проста. Давайте разберемся, как это сделать:

Наиболее распространенным способом установки NumPy является использование установщика пакетов Python - pip. Если у вас еще нет NumPy, выполните следующую команду в командной строке:

pip install numpy

Эта команда автоматически загрузит и установит последнюю версию NumPy из Python Package Index (PyPI).

Если вы используете Anaconda для управления вашей средой Python, NumPy, как правило, уже установлена. Anaconda поставляется с множеством научных библиотек, включая NumPy.

Вы можете убедиться, что NumPy установлена, выполнив следующую команду:

conda list numpy

После установки NumPy, вы можете проверить версию, которая установлена на вашей системе, с помощью следующего кода в Python:

import numpy as np

print(np.__version__)

Это выведет версию NumPy, установленную на вашей системе.

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

NumPy предоставляет несколько основных структур данных, которые позволяют удобно и эффективно хранить и манипулировать многомерными массивами данных. Давайте рассмотрим две основные структуры данных в NumPy:

Одномерные массивы, иногда называемые векторами, представляют собой структуру данных, содержащую элементы одного измерения. Они могут быть созданы из обычных списков Python или других массивов NumPy. Вот пример создания одномерного массива:

import numpy as np

# Создание одномерного массива
arr = np.array([1, 2, 3, 4, 5])

Одномерные массивы в NumPy предоставляют ряд преимуществ, таких как быстрые математические операции, индексирование и срезы.

Многомерные массивы в NumPy - это одна из ключевых особенностей этой библиотеки. Они представляют собой структуры данных, способные хранить и оперировать данными с несколькими измерениями, такими как матрицы или тензоры. Многомерные массивы можно создавать с использованием вложенных списков или других массивов.

• Матрицы
  Матрица - это двумерный массив, то есть массив, имеющий два измерения: строки и столбцы. Она используется для представления данных, имеющих две логические оси. Например, таблица с данными о студентах, где одна ось представляет студентов, а другая - их оценки, может быть представлена в виде матрицы.
  Пример создания матрицы в NumPy:

import numpy as np

# Создание матрицы 2x3
matrix = np.array([[1, 2, 3], [4, 5, 6]])

• Тензоры
  Тензор - это более общий термин и означает многомерный массив с более чем двумя измерениями. Тензор может иметь три, четыре, пять и более измерений. Он используется для представления данных, которые имеют более двух логических осей. Примерами могут служить изображения (где у нас есть две пространственные оси и, возможно, канальная ось), видео (где к каждому изображению добавляется временная ось), и данные с дополнительными измерениями.
  Пример создания трехмерного тензора в NumPy:

import numpy as np

# Создание трехмерного тензора 2x3x4
tensor = np.array([[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]])

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

import numpy as np

# Создание структурированного массива
people = np.array([(b'Alice', 25, 160.0), (b'Bob', 30, 175.5)],
                  dtype=[('name', 'S10'), ('age', int), ('height', float)])

Маскированные массивы предоставляют способ обрабатывать отсутствующие данные. Каждый элемент массива снабжен маской, которая указывает, является ли элемент допустимым (True) или отсутствующим (False). Это полезно при анализе данных, где не все значения всегда присутствуют.

import numpy as np
import numpy.ma as ma

data = np.array([1, 2, -1, 4, -5])
mask = np.array([False, False, True, False, True])

# Создание маскированного массива
masked_data = ma.array(data, mask=mask)

NumPy предоставляет модуль numpy.random для создания массивов с случайными данными. Это полезно при моделировании, статистическом анализе и генерации случайных чисел.

import numpy as np

# Создание массива случайных чисел
random_data = np.random.rand(5, 5)  # Создать массив 5x5 с числами от 0 до 1

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

import numpy as np

# Создание многочленов
p1 = np.poly1d([1, 2, 3])  # 1*x^2 + 2*x + 3
p2 = np.poly1d([4, 5])     # 4*x + 5

# Умножение многочленов
result = np.polyadd(p1, p2)

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

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

NumPy позволяет выполнять стандартные арифметические операции над массивами. Эти операции выполняются поэлементно, то есть каждый элемент массива обрабатывается независимо. Вот несколько примеров:

import numpy as np

arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.array([6, 7, 8, 9, 10])

# Сложение
result_add = arr1 + arr2  # [7, 9, 11, 13, 15]

# Вычитание
result_sub = arr1 - arr2  # [-5, -5, -5, -5, -5]

# Умножение
result_mul = arr1 * arr2  # [6, 14, 24, 36, 50]

# Деление
result_div = arr1 / arr2  # [0.16666667, 0.28571429, 0.375, 0.44444444, 0.5]

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

import numpy as np

arr = np.array([0, np.pi/2, np.pi])

# Нахождение синуса
sin_result = np.sin(arr)  # [0. 1. 0.]

# Нахождение косинуса
cos_result = np.cos(arr)  # [1. 6.12323360e-17 -1.]

# Экспоненциация
exp_result = np.exp(arr)  # [1.         4.81047738 23.14069263]

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

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

# Сумма элементов
sum_result = np.sum(arr)  # 15

# Среднее значение
mean_result = np.mean(arr)  # 3.0

# Минимум и максимум
min_result = np.min(arr)  # 1
max_result = np.max(arr)  # 5

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

import numpy as np

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

# Изменение формы в двумерный массив
reshaped_arr = arr.reshape(2, 3)
# [[1 2 3]
#  [4 5 6]]

# Можно также использовать -1 для автоматического определения размера
reshaped_arr = arr.reshape(3, -1)
# [[1 2]
#  [3 4]
#  [5 6]]

# Изменение размерности
flattened_arr = reshaped_arr.flatten()  # Преобразование обратно в одномерный массив

Транспонирование позволяет поменять местами строки и столбцы в многомерных массивах. Это полезно, например, при работе с матрицами.

import numpy as np

matrix = np.array([[1, 2, 3], [4, 5, 6]])

# Транспонирование
transposed_matrix = matrix.T
# [[1 4]
#  [2 5]
#  [3 6]]

NumPy предоставляет функции для слияния нескольких массивов в один. Вы можете выполнять горизонтальное и вертикальное объединение массивов.

import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

# Горизонтальное объединение
horizontal_stack = np.hstack((arr1, arr2))
# [1 2 3 4 5 6]

# Вертикальное объединение
vertical_stack = np.vstack((arr1, arr2))
#[[1 2 3]
# [4 5 6]]

NumPy предоставляет функции для сортировки элементов массивов, как в возрастающем, так и в убывающем порядке.

import numpy as np

arr = np.array([3, 1, 2, 4, 5])

# Сортировка в возрастающем порядке
sorted_arr = np.sort(arr) # [1 2 3 4 5]

# Сортировка в убывающем порядке
reverse_sorted_arr = np.sort(arr)[::-1] # [5 4 3 2 1]

NumPy предоставляет функции для вычисления различных статистических характеристик данных в массивах, такие как среднее значение, дисперсия и медиана.

import numpy as np

data = np.array([1, 2, 2, 3, 3, 3, 4, 4, 5])

# Среднее значение
mean = np.mean(data) # 2.6666666666666665

# Дисперсия
variance = np.var(data) # 1.5555555555555556

# Медиана
median = np.median(data) # 3.0

# Нахождение уникальных значений
unique_values = np.unique(data) # [1, 2, 3, 4, 5]

# Подсчет частоты встречаемости
value_counts = np.bincount(data) # [0, 1, 2, 3, 2, 1]

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

import numpy as np

matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])

# Умножение матриц
matrix_product = np.dot(matrix1, matrix2)
# [[19 22]
#  [43 50]]

# Скалярное произведение
dot_product = np.vdot(matrix1, matrix2)
# 70

# Определитель матрицы
determinant = np.linalg.det(matrix1)

# -2.0000000000000004

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

import numpy as np

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

# Индексирование
element = arr[2]  # Получение элемента с индексом 2 (значение 3)

# Срез
sub_array = arr[1:4]  # Выбор элементов с индексами 1, 2, 3 (значения 2, 3, 4)

# Использование булевых массивов
condition = arr > 3
filtered_data = arr[condition]  # Выбор элементов, которые больше 3 (значения 4, 5, 6)

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

Основные правила Broadcasting:

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

Примеры использования Broadcasting:

import numpy as np

arr = np.array([1, 2, 3])
scalar = 10

# Broadcasting: умножение массива на скаляр
result = arr * scalar # [10, 20, 30]

или

import numpy as np

# Создание массивов
A = np.array([[1, 2, 3], [4, 5, 6]])  # Матрица 2x3
B = np.array([10, 20, 30])           # Одномерный массив

# Сложение массивов
result = A + B # [[11, 22, 33], [14, 25, 36]]

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

import numpy as np

data = np.array([1, 2, 3, 4, 5])

# Сохранение массива в текстовый файл
np.savetxt("data.txt", data)
# Загрузка массива из текстового файла
loaded_data = np.loadtxt("data.txt")

# Сохранение массива в бинарный файл
np.save('data.npy', data)
# Загрузка массива из бинарного файла
loaded_data = np.load('data.npy')

# Сохранение данных в CSV-файл
np.savetxt('output.csv', data, delimiter=',', header='column1,column2', comments='')
# Загрузка данных из CSV-файла
data = np.genfromtxt('data.csv', delimiter=',', dtype=None, names=True)

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

Рассмотрим пример создания маскированного массива и какие операции можно выполнять с ним:

import numpy as np
import numpy.ma as ma

data = np.array([1, 2, -1, 4, -5])
mask = np.array([False, False, True, False, True])

# Создание маскированного массива
masked_data = ma.array(data, mask=mask)

В этом примере у нас есть массив data, который содержит числа, и массив mask, который содержит булевы значения, указывающие, какие элементы считаются недопустимыми. Мы создаем маскированный массив masked_data, в котором недопустимые элементы помечены маской.

Выполним некоторые операции с маскированным массивом:

# Получение среднего значения без учета недопустимых элементов
mean = ma.mean(masked_data)

# Извлечение только допустимых значений
valid_values = masked_data.compressed()

Результаты выполнения:

• mean будет содержать среднее значение только для допустимых элементов, то есть (1 + 2 + 4) / 3 = 2.333.
• valid_values будет содержать массив [1, 2, 4], исключая недопустимые значения -1 и -5.

NumPy предоставляет мощные возможности для работы с многомерными массивами, что позволяет выполнять операции с дополнительными измерениями. Вы можете работать с одномерными, двумерными, трехмерными и даже более сложными массивами.

Давайте рассмотрим примеры операций с дополнительными измерениями:

import numpy as np

# Создание двумерного массива
matrix = np.array([[1, 2, 3], [4, 5, 6]])

# Выбор элементов по индексам
element = matrix[1, 2]
# Получение элемента во второй строке и третьем столбце (значение 6)

# Выполнение операций с дополнительными измерениями
sum_of_rows = np.sum(matrix, axis=1)
# Сумма элементов по строкам

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

Выбираем элемент по индексам [1, 2], что соответствует второй строке и третьему столбцу, и получаем значение 6.

С помощью np.sum мы вычисляем сумму элементов по строкам массива. Результатом будет одномерный массив [6, 15], где каждый элемент - это сумма элементов соответствующей строки.

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

import numpy as np
import matplotlib.pyplot as plt

# Создание массива данных
data = np.random.rand(100)

# Построение графика
plt.plot(data)
plt.show()

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

import numpy as np

arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.array([4, 3, 2, 1, 0])

# Сравнение элементов
comparison = arr1 > arr2  # [False, False, True, True, True]

# Логические операции
logical_and = np.logical_and(arr1 > 2, arr2 < 4)  # [False, False, True, False, False]

NumPy предоставляет функции для поиска элементов в массивах, их индексов и фильтрации данных в соответствии с условиями.

import numpy as np

data = np.array([1, 2, 2, 3, 3, 3, 4, 4, 5])

# Поиск индексов элементов, равных 3
indices = np.where(data == 3)  # [3, 4, 5]

# Фильтрация данных по условию
filtered_data = data[data > 2]  # [3, 3, 3, 4, 4, 5]

# Создание маски для выбора значений больше 3
mask = data > 3

# Использование маски для фильтрации данных
filtered_data = data[mask] # [4, 4, 5]

NumPy позволяет работать с данными, связанными с датами и временем. Вы можете выполнять операции с датами, создавать временные ряды и многое другое.

import numpy as np

# Создание массива дат
dates = np.array(['2022-01-01', '2022-01-02', '2022-01-03'], dtype='datetime64')

# Вычисление разницы во времени
time_difference = dates[1] - dates[0] # numpy.timedelta64(1,'D')

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

import numpy as np

matrix = np.array([[1, 2], [3, 4]])

# Нахождение обратной матрицы
inverse_matrix = np.linalg.inv(matrix)
#[[-2.   1. ] [ 1.5 -0.5]]

# Нахождение собственных значений и векторов
eigenvalues, eigenvectors = np.linalg.eig(matrix)
#[5. -0.], [[ 0.70710678 -0.4472136 ][ 0.70710678  0.89442719]]

NumPy предоставляет функции для обработки текстовых данных, включая операции конкатенации строк, поиска подстрок, разделения строк и другие.

import numpy as np

strings = np.array(['Hello', 'World', 'Python'])

# Конкатенация строк
concatenated_string = np.char.add(strings, ' is great')  # ['Hello is great' 'World is great' 'Python is great']

# Поиск подстрок
contains_python = np.char.find(strings, 'Python')  # [-1 -1 0]

# Разделение строк
split_strings = np.char.split(strings)  # [['Hello'] ['World'] ['Python']]

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

import numpy as np

x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 1, 4, 9, 16])

# Интерполяция значения для x = 2.5
interpolated_value = np.interp(2.5, x, y)  # 6.25

NumPy поддерживает комплексные числа и позволяет выполнять операции с ними, включая сложение, вычитание, умножение и деление.

import numpy as np

complex1 = 3 + 4j
complex2 = 1 + 2j

# Сложение комплексных чисел
sum_result = complex1 + complex2  # (4+6j)

# Умножение комплексных чисел
product_result = complex1 * complex2  # (-5+10j)

NumPy позволяет работать с данными разных типов, включая строки, объекты и даже пользовательские типы данных.

import numpy as np

# Создание массива объектов
objects = np.array([{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}])

# Доступ к данным по ключу
ages = objects['age']  # [25, 30]

# Создание пользовательских типов данных
custom_dtype = np.dtype([('name', 'S10'), ('age', int)])
custom_data = np.array([('Alice', 25), ('Bob', 30)], dtype=custom_dtype)

NumPy часто используется для обработки изображений. Вы можете загружать, изменять и анализировать изображения с помощью массивов NumPy.

import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

# Загрузка изображения
image = Image.open("image.jpg")
image_data = np.array(image)

# Изменение размера изображения
resized_image = np.array(Image.fromarray(image_data).resize((200, 200)))

# Отображение изображения
plt.imshow(resized_image)
plt.show()

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

import numpy as np

# Создание массива с заданным типом данных
int_array = np.array([1, 2, 3], dtype=int)
float_array = np.array([1.0, 2.0, 3.0], dtype=float)
bool_array = np.array([True, False, True], dtype=bool)

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

import numpy as np

# Создание массива данных с использованием генератора
generator = (i for i in range(10**6))
data = np.fromiter(generator, int)

# Загрузка данных по частям
chunked_data = np.array_split(data, 10)  # Разделение данных на 10 частей

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

import numpy as np

# Генерация случайных чисел
random_numbers = np.random.rand(5)  # Генерация 5 случайных чисел между 0 и 1

# Генерация случайных целых чисел
random_integers = np.random.randint(1, 10, size=5)  # Генерация 5 случайных целых чисел от 1 до 10

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

import numpy as np

# Создание диапазона чисел
range_array = np.arange(1, 11)  # Создание диапазона от 1 до 10

# Создание равномерно распределенных чисел
linspace_array = np.linspace(0, 1, 5)  # Создание 5 чисел равномерно распределенных между 0 и 1

NumPy обрабатывает значения NaN, что полезно при работе с данными, содержащими отсутствующие или недопустимые значения.

import numpy as np

data = np.array([1, 2, np.nan, 4, np.nan])

# Проверка наличия NaN
has_nan = np.isnan(data)  # [False False  True False  True]

# Фильтрация NaN
filtered_data = data[~has_nan]  # Удаление NaN из данных

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

import numpy as np

# Создание периодических данных
time = np.arange(0, 10, 0.1)
sin_wave = np.sin(time)

# Вычисление периодичности
periodicity = np.fft.fftfreq(len(time))
# array([ 0.  ,  0.01,  0.02,  0.03,  0.04,  0.05,  0.06,  0.07,  0.08,  0.09, -0.1 , -0.09, -0.08, -0.07, -0.06, -0.05, -0.04, -0.03, -0.02, -0.01])
# Этот результат представляет собой массив значений периодичности, вычисленных с помощью преобразования Фурье для последовательности sin_wave.

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

import numpy as np

data = np.array([3, 1, 2, 4, 5])

# Нахождение максимального и минимального значения
max_value = np.max(data) # 5
min_value = np.min(data) # 1

# Нахождение индексов максимального и минимального значения
argmax_index = np.argmax(data) # 4
argmin_index = np.argmin(data) # 1

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

import numpy as np

# Создание массива с координатами местоположений
locations = np.array([
    [40.7128, -74.0060],  # Нью-Йорк
    [34.0522, -118.2437]  # Лос-Анджелес
])

# Вычисление расстояния между местоположениями
distance = np.linalg.norm(locations[0] - locations[1]) # 41.45016414410026

NumPy поддерживает работу с геометрическими данными, такими как векторы и матрицы трансформаций.

import numpy as np

# Создание векторов
vector1 = np.array([1, 2, 3])
vector2 = np.array([4, 5, 6])

# Вычисление скалярного произведения
dot_product = np.dot(vector1, vector2) # 42

# Выполнение матричных операций
matrix = np.array([[1, 2], [3, 4]])
result = np.matmul(matrix, vector1) # [14 32]

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

import numpy as np
import scipy.io.wavfile as wav

# Загрузка аудиофайла
sample_rate, audio_data = wav.read('audio.wav')

# Фильтрация аудиоданных
filtered_data = np.convolve(audio_data, np.array([1, -1]), mode='same')

Результаты для операций с аудиофайлом:

Чтение аудиоданных (sample_rate и audio_data):

• sample_rate - частота дискретизации аудио.
• audio_data - массив с аудиоданными.

Фильтрация аудиоданных с использованием свертки (filtered_data):

• filtered_data - массив с отфильтрованными аудиоданными после применения свертки с ядром [1, -1] в режиме 'same'.

NumPy позволяет работать с дробями и выполнять арифметические операции с ними.

import numpy as np
from fractions import Fraction

# Создание массива с дробями
fractions = np.array([Fraction(1, 2), Fraction(3, 4), Fraction(2, 5)])

# Выполнение операций с дробями
sum_of_fractions = np.sum(fractions) # Fraction(13, 10) или `13/10`

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

import numpy as np

# Создание массива с данными
data = np.array([
    [1, 'A', 100],
    [2, 'B', 200],
    [3, 'A', 150],
    [4, 'C', 300]
])

# Создание сводной таблицы
agg_data = np.bincount(data[:, 1], weights=data[:, 2]) # [450. 200. 300.]

В данном случае, мы имеем массив data, представляющий собой таблицу с тремя столбцами: первый столбец содержит идентификаторы, второй столбец - категории (например, 'A', 'B', 'C'), а третий столбец - числовые значения.

С помощью функции np.bincount мы агрегируем данные на основе значений во втором столбце (категориях) и суммируем соответствующие значения из третьего столбца. Результатом является массив agg_data, где каждый элемент представляет сумму значений в столбце 'C' для каждой уникальной категории в столбце 'B'. Это означает, что сумма значений в столбце 'C' для категории 'A' равна 450, для 'B' - 200, и для 'C' - 300.

NumPy играет ключевую роль в множестве областей программирования:

• Научные вычисления: NumPy широко используется в научных и инженерных вычислениях, где быстрая обработка и анализ данных критически важны.
• Анализ данных: Многие библиотеки для анализа данных, такие как pandas, используют NumPy внутри себя для эффективной работы с данными.
• Машинное обучение и искусственный интеллект: Многие библиотеки машинного обучения, включая TensorFlow и PyTorch, используют NumPy для работы с данными и обработки тензоров.
• Обработка изображений и звука: NumPy позволяет работать с изображениями, аудиоданными и другими форматами медиа.
• Финансы и экономика: В финансовых расчетах и анализе рынка NumPy используется для обработки и анализа больших объемов данных.
• Геоинформационные системы: NumPy полезен для работы с геоданными, координатами и геометрическими данными.

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