Рубрики
Без рубрики

NumPy Tutorial: Простое Руководство На Основе Примеров

Автор оригинала: Usman Malik.

  • Вступление
  • Преимущества NumPy
  • Операции NumPy
  • Создание массива NumPy
    • Метод массива
    • Метод аранжировки
    • Метод нулей
    • Метод те
    • Метод linspace
    • Глазной метод
    • Случайный метод
  • Изменение формы массива NumPy
  • Поиск Максимальных/Минимальных Значений
  • Индексация массива в NumPy
    • Индексация с 1-D массивами
    • Индексация с помощью 2-D массивов
  • Арифметические операции с массивами NumPy
    • Функция журнала
    • Функция exp
    • Функция sqrt
    • Функция греха
  • Операции линейной алгебры с массивами NumPy
    • Нахождение векторного точечного произведения
    • Матричное умножение
    • Нахождение обратной матрицы
    • Нахождение определителя матрицы
    • Нахождение следа матрицы
  • Вывод

Вступление

Библиотека NumPy – это популярная библиотека Python, используемая для научных вычислительных приложений, и является аббревиатурой от “Numerical Python”. Операции Numpy делятся на три основные категории: Преобразование Фурье и Манипулирование формой, Математические и логические операции, а также Линейная алгебра и генерация случайных чисел. Чтобы сделать это как можно быстрее, NumPy написан на C и Python.

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

Преимущества NumPy

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

  1. NumPy чрезвычайно быстр по сравнению с core Python благодаря интенсивному использованию расширений C.
  2. Многие продвинутые библиотеки Python, такие как Scikit-Learn, Scipy и Keras, широко используют библиотеку NumPy. Поэтому, если вы планируете продолжить карьеру в области науки о данных или машинного обучения, NumPy-очень хороший инструмент для овладения.
  3. NumPy поставляется с множеством встроенных функций, которые в ядре Python потребовали бы изрядного количества пользовательского кода.

Что касается последнего пункта, взгляните на следующий сценарий:

x = [2, 3, 4, 5, 6]
y = [a + 2 for a in x]

Здесь, чтобы добавить 2 к каждому элементу в списке x , мы должны пройти весь список и добавить 2 к каждому элементу в отдельности. Теперь давайте посмотрим, как мы можем выполнить ту же задачу с помощью библиотеки NumPy:

import numpy as np
nums = np.array([2, 3, 4, 5, 6])
nums2 = nums + 2

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

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

Операции NumPy

Прежде чем мы сможем выполнить какие-либо операции NumPy, нам нужно установить пакет NumPy. Чтобы установить пакет NumPy, вы можете использовать установщик pip. Для установки выполните следующую команду:

$ pip install numpy

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

$ conda install numpy

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

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

Массивы NumPy являются строительными блоками большинства операций NumPy. Массивы NumPy можно разделить на два типа: одномерные массивы и двумерные массивы.

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

Метод массива

Чтобы создать одномерный массив NumPy, мы можем просто передать список Python в метод array . Проверьте следующий сценарий для примера:

import numpy as np
x = [2, 3, 4, 5, 6]
nums = np.array([2, 3, 4, 5, 6])
type(nums)

В приведенном выше скрипте мы сначала импортировали библиотеку NumPy как np и создали список x . Затем мы передали этот список функции array библиотеки NumPy. Наконец, мы напечатали тип массива, который привел к следующему выходу:

numpy.ndarray

Если бы вы напечатали массив nums на экране, вы бы увидели, что он отображается следующим образом:

array([2, 3, 4, 5, 6])

Чтобы создать двумерный массив, вы можете передать список списков в метод array , как показано ниже:

nums = np.array([[2,4,6], [8,10,12], [14,16,18]])

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

array([[ 2,  4,  6],
       [ 8, 10, 12],
       [14, 16, 18]])
Метод аранжировки

Другим часто используемым методом создания массива NumPy является метод arrange . Этот метод принимает начальный индекс массива, конечный индекс и размер шага (который является необязательным). Взгляните на следующий пример:

nums = np.arange(2, 7)

Достаточно просто, не так ли? Приведенный выше скрипт вернет массив NumPy размера 5 с элементами 2, 3, 4, 5 и 6. Помните, что метод arange возвращает массив, который начинается с начального индекса и заканчивается на один индекс меньше конечного индекса. Вывод этого кода выглядит следующим образом:

array([2, 3, 4, 5, 6])

Теперь давайте добавим шаг размером 2 к нашему массиву и посмотрим, что произойдет:

nums = np.arange(2, 7, 2)

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

array([2, 4, 6])

Вы можете видеть, что массив начинается с 2, за которым следует размер шага 2 и заканчивается на 6, что на единицу меньше конечного индекса.

Метод нулей

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

zeros = np.zeros(5)

Приведенный выше скрипт вернет одномерный массив из 5 нулей. Выведите массив zeros , и вы увидите следующее:

array([0., 0., 0., 0., 0.])

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

zeros = np.zeros((5, 4))

Приведенный выше скрипт вернет двумерный массив из 5 строк и 4 столбцов:

array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])
Метод те

Аналогично, вы можете создать одномерные и двумерные массивы всех единиц, используя метод ones следующим образом:

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

И снова, для двумерного массива, попробуйте следующий код:

ones = np.ones((5, 4))

Теперь, если вы напечатаете массив ones на экране, вы увидите следующий двумерный массив:

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
Метод linspace

Еще одним очень полезным методом создания массивов NumPy является метод linspace . Этот метод принимает три аргумента: начальный индекс, конечный индекс и количество линейных чисел, которые вы хотите разместить между указанным диапазоном. Например, если первый индекс равен 1, последний индекс равен 10 и вам нужно 10 равномерно расположенных элементов в этом диапазоне, вы можете использовать метод linspace следующим образом:

lin = np.linspace(1, 10, 10)

Выходные данные будут возвращать целые числа от 1 до 10:

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

Теперь давайте попробуем создать массив с 20 линейно расположенными элементами от 1 до 10. Выполните следующий сценарий:

lin = np.linspace(1, 10, 20)

Это приведет к следующему массиву:

array([ 1.        ,  1.47368421,  1.94736842,  2.42105263,  2.89473684,
        3.36842105,  3.84210526,  4.31578947,  4.78947368,  5.26315789,
        5.73684211,  6.21052632,  6.68421053,  7.15789474,  7.63157895,
        8.10526316,  8.57894737,  9.05263158,  9.52631579, 10.        ])

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

Глазной метод

Метод eye может быть использован для создания тождественной матрицы , которая может быть очень полезна для выполнения различных операций в линейной алгебре. Тождественная матрица-это матрица с нулями в строках и столбцах, кроме диагонали. Все диагональные значения равны единицам. Давайте создадим матрицу идентичности 4×4 с помощью метода eye :

idn = np.eye(4)

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

array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])
Случайный метод

Часто вам придется создавать массивы со случайными числами. Для этого можно использовать функцию rand модуля Numpy random . Вот простой пример функции rand :

random = np.random.rand(2, 3)

Приведенный выше скрипт возвращает матрицу из 2 строк и 3 столбцов. Матрица содержит равномерное распределение чисел от 0 до 1:

array([[0.26818562, 0.65506793, 0.50035001],
       [0.527117  , 0.445688  , 0.99661   ]])

Аналогично, чтобы создать матрицу случайных чисел с распределением Гаусса (или “нормальным” распределением), вы можете вместо этого использовать метод randn , как показано ниже:

random = np.random.randn(2, 3)

Наконец, для создания массива случайных целых чисел существует метод randint для такого случая. Метод randint принимает нижнюю границу, верхнюю границу и количество возвращаемых целых чисел. Например, если вы хотите создать массив из 5 случайных целых чисел в диапазоне от 50 до 100, вы можете использовать этот метод следующим образом:

random = np.random.randint(50, 100, 5)

В нашем случае выход выглядел так:

array([54, 59, 84, 62, 74])

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

Мы видели разные способы создания массивов Python. Давайте теперь рассмотрим некоторые другие функции массива.

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

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

Давайте сначала создадим массив из 16 элементов с помощью функции arrange . Выполните следующий код:

nums = np.arange(1, 17)

Массив nums представляет собой одномерный массив из 16 элементов в диапазоне от 1 до 16:

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])

Nos давайте преобразуем его в двумерный массив из 4 строк и 4 столбцов:

nums2 = nums.reshape(4, 4)

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

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])

Уместно отметить, что вы не можете изменить форму массива, если число элементов в одномерном массиве не равно произведению строк и столбцов измененного массива. Например, если у вас есть 45 элементов в 1-d массиве, вы не можете преобразовать его в матрицу из 5 строк и 10 столбцов, так как матрица 5×10 имеет 50 элементов, а исходная-только 45.

Поиск Максимальных/Минимальных Значений

Вы можете использовать функции min /| max , чтобы легко найти значение наименьшего и наибольшего числа в вашем массиве. Для нашего примера давайте сначала создадим массив из 5 случайных целых чисел:

random = np.random.randint(1, 100, 5)
print(random)

Наш массив случайных целых чисел выглядит следующим образом:

[51 40 84 38  1]

Помните, что эти числа генерируются случайным образом, поэтому у вас, скорее всего, будет другой набор чисел. Давайте используем функции min и max , чтобы найти минимальное и максимальное значения из массива, который мы только что создали. Для этого выполните следующий код, чтобы найти минимальное значение:

xmin = random.min()
print(xmin)

“1” будет напечатано на выходе.

Аналогично, для получения максимального значения выполните следующий код:

xmax = random.max()
print(xmax)

Приведенный выше скрипт вернет “84” в качестве выходного сигнала.

Вы также можете найти индекс максимального и минимального значений с помощью функций argmax() и argmin () . Взгляните на следующий сценарий:

print(random.argmax())

Приведенный выше скрипт выведет “2”, так как 84-это самое большое число в списке, и оно находится на второй позиции массива.

Аналогично, argmin() вернет “4”, потому что 1-это наименьшее число и находится на 4-й позиции.

Индексация массива в NumPy

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

Индексация с 1-D массивами

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

nums = np.arange(1, 16)

Вы можете получить любой элемент, передав номер индекса. Как и списки Python, массивы Numpy имеют нулевую индексацию. Например, чтобы найти элемент во втором индексе (3-я позиция) массива, можно использовать следующий синтаксис:

print(nums[2])

У нас есть цифра 3 во втором индексе, поэтому она будет напечатана на экране.

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

print(nums[1:8])

Приведенный выше скрипт выведет целые числа от 2 до 8:

[2 3 4 5 6 7 8]

Здесь, в массиве nums , у нас есть 2 в индексе 1 и 8 в индексе семь.

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

nums2 = nums[0:8]
print(nums2)

В приведенном выше скрипте мы разрезали массив nums , извлекая его первые 8 элементов. Результирующие элементы присваиваются массиву num2 . Затем мы выводим массив num2 на консоль. На выходе получается новый массив из первых 8 чисел:

[1 2 3 4 5 6 7 8]
Индексация с помощью 2-D массивов

Индексирование двумерного массива NumPy очень похоже на индексирование матрицы. Давайте сначала создадим двумерный массив NumPy размером 3×3. Для этого выполните следующий код:

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

А теперь давайте распечатаем:

print(nums2d)
[[1 2 3]
 [4 5 6]
 [7 8 9]]

Как и 1-D массивы, массивы NumPy с двумя измерениями также следуют нулевому индексу, то есть для доступа к элементам в первой строке необходимо указать 0 в качестве индекса строки. Точно так же, чтобы получить доступ к элементам в первом столбце, вам также нужно указать 0 для индекса столбца.

Давайте извлекем элемент из массива nums 2d , расположенного в первой строке и первом столбце:

print(nums2d[0, 0])

Вы увидите “1” в выходных данных. Аналогично, мы можем получить элемент в третьей строке и третьем столбце следующим образом:

print(nums2d[2, 2])

Вы увидите “9” на выходе.

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

print(nums2d[0])

На выходе просто одномерный массив:

[1 2 3]

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

print(nums2d[:,0])

Выход снова является массивом, но это комбинация первых элементов каждого массива двумерного массива:

[1 4 7]

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

print(nums2d[:2,:2])

Приведенный выше сценарий возвращает следующие выходные данные:

[[1 2]
 [4 5]]

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

Для примеров в этом разделе мы будем использовать массив nums , который мы создали в предыдущем разделе.

Давайте сначала сложим два массива вместе:

nums3 = nums + nums

Вы можете добавить два массива вместе с одинаковыми размерами. Например, массив nums содержал 15 элементов, поэтому мы можем добавить его к себе. Будут добавлены элементы с соответствующими индексами. Теперь, если вы напечатаете массив nums3 , вывод будет выглядеть следующим образом:

[ 2  4  6  8 10 12 14 16 18 20 22 24 26 28 30]

Как вы можете видеть, каждая позиция является суммой 2 элементов в этой позиции в исходных массивах.

Если вы добавите массив со скалярным значением, то это значение будет добавлено к каждому элементу в массиве. Давайте добавим 10 к массиву nums и выведем результирующий массив на консоль. Вот как вы это сделаете:

nums3 = nums + 10
print(nums3)

И результирующий массив nums 3 становится:

[11 12 13 14 15 16 17 18 19 20 21 22 23 24 25]

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

Помимо простой арифметики, вы можете выполнять более сложные функции над массивами Numpy, например log, square root, exponential и т. Д.

Функция журнала

Следующий код просто возвращает массив с журналом всех элементов входного массива:

nums3 = np.log(nums)
print(nums3)

Вывод выглядит следующим образом:

[0.         0.69314718 1.09861229 1.38629436 1.60943791 1.79175947
 1.94591015 2.07944154 2.19722458 2.30258509 2.39789527 2.48490665
 2.56494936 2.63905733 2.7080502 ]
Функция exp

Следующий скрипт возвращает массив с экспонентами всех элементов входного массива:

nums3 = np.exp(nums)
print(nums3)
[2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01
 1.48413159e+02 4.03428793e+02 1.09663316e+03 2.98095799e+03
 8.10308393e+03 2.20264658e+04 5.98741417e+04 1.62754791e+05
 4.42413392e+05 1.20260428e+06 3.26901737e+06]
Функция sqrt

Следующий скрипт возвращает массив с квадратными корнями всех элементов входного массива:

nums3 = np.sqrt(nums)
print(nums3)
[1.         1.41421356 1.73205081 2.         2.23606798 2.44948974
 2.64575131 2.82842712 3.         3.16227766 3.31662479 3.46410162
 3.60555128 3.74165739 3.87298335]
Функция греха

Следующий скрипт возвращает массив с синусом всех элементов входного массива:

nums3 = np.sin(nums)
print(nums3)
[ 0.84147098  0.90929743  0.14112001 -0.7568025  -0.95892427 -0.2794155
  0.6569866   0.98935825  0.41211849 -0.54402111 -0.99999021 -0.53657292
  0.42016704  0.99060736  0.65028784]

Операции линейной алгебры с массивами NumPy

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

Нахождение векторного точечного произведения

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

Давайте создадим два вектора и попробуем найти их точечное произведение вручную. Вектор в NumPy-это в основном просто 1-мерный массив. Выполните следующий скрипт для создания наших векторов:

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

Точечное произведение двух вышеприведенных векторов равно (2 x 1) + (4 x .

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

dot_product = 0
for a,b in zip(x,y):
    dot_product += a * b

print(dot_product)

В приведенном выше сценарии мы просто перебирали соответствующие элементы в векторах x и y , умножали их и добавляли к предыдущей сумме. Если вы запустите приведенный выше скрипт, то увидите, что на консоли выведено “14”.

Теперь давайте посмотрим, как мы можем найти точечный продукт с помощью библиотеки NumPy. Посмотрите на следующий сценарий:

a = x * y
print(a.sum())

Мы знаем, что если мы умножим два массива NumPy, то соответствующие элементы из обоих массивов будут умножены на основе их индекса. В приведенном выше сценарии мы просто умножили векторы x и y . Затем мы вызываем метод sum для результирующего массива, который суммирует все элементы массива. Приведенный выше скрипт также вернет “14” в выводе.

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

print(x.dot(y))

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

Матричное умножение

Как и точечное произведение двух векторов, вы также можете умножить две матрицы. В NumPy матрица-это не что иное, как двумерный массив. Чтобы умножить две матрицы, внутренние размеры матриц должны совпадать, а это значит, что число столбцов матрицы слева должно быть равно числу строк матрицы справа от произведения. Например, если матрица X имеет размеры [3,4], а другая матрица Y имеет размеры [4,2], то матрицы X и Y можно умножить вместе. Результирующая матрица будет иметь размеры [3,2], которые являются размерами внешних измерений.

Для умножения двух матриц можно использовать функцию dot , как показано ниже:

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

Y = np.array(([1,2], [4,5], [7,8]))

Z = np.dot(X, Y)

print(Z)

В приведенном выше скрипте мы создали матрицу 3×2 с именем X и матрицу 2×3 с именем Y . Затем мы находим точечное произведение двух матриц и присваиваем результирующую матрицу переменной Z . Наконец, мы выводим полученную матрицу на консоль. На выходе вы должны увидеть матрицу 2×2, как показано ниже:

[[30 36]
 [66 81]]

Вы также можете умножить две матрицы по элементам. Для этого размеры двух матриц должны совпадать, как при сложении массивов. Функция multiply используется для поэлементного умножения.

Давайте попробуем умножить матрицы X и Y по элементам:

Z = np.multiply(X, Y)

При выполнении приведенного выше кода возникнет следующая ошибка:

ValueError: operands could not be broadcast together with shapes (2,3) (3,2)

Ошибка возникает из-за несоответствия размеров матриц X и Y . Теперь давайте попробуем умножить матрицу X на саму себя с помощью функции multiply :

Z = np.multiply(X, X)

Теперь, если вы напечатаете матрицу Z , вы увидите следующий результат:

[[ 1  4  9]
 [16 25 36]]

Матрица X была успешно умножена на саму себя, потому что размеры умноженных матриц совпадали.

Нахождение обратной матрицы

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

Для нашего примера давайте найдем обратную матрицу 2×2. Взгляните на следующий код:

Y = np.array(([1,2], [3,4]))
Z = np.linalg.inv(Y)
print(Z)

Вывод приведенного выше кода выглядит следующим образом:

[[-2.   1. ]
 [ 1.5 -0.5]]

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

W = Y.dot(Z)
print(W)
[[1.00000000e+00 1.11022302e-16]
 [0.00000000e+00 1.00000000e+00]]

И результат оказался таким, как мы и ожидали. Единицы в диагонали и нули (или очень близкие к нулю) в другом месте.

Нахождение определителя матрицы

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

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

Z = np.linalg.det(X)

print(Z)

В приведенном выше сценарии мы создали матрицу 3×3 и нашли ее определитель с помощью метода det . В выходных данных вы должны увидеть “6.66133814775094 e-16”.

Нахождение следа матрицы

След матрицы – это сумма всех элементов в диагонали матрицы. Библиотека NumPy содержит функцию trace , которая может быть использована для поиска трассировки матрицы. Посмотрите на следующий пример:

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

Z = np.trace(X)

print(Z)

На выходе вы должны увидеть “15”, так как сумма диагональных элементов матрицы X равна 1 + 5 + .

Вывод

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

Хотя мы рассмотрели довольно много основных функций Numpy, нам еще предстоит многому научиться. Если вы хотите узнать больше, я бы предложил вам попробовать такой курс , который охватывает NumPy, Pandas, Scikit-learn и Matplotlib гораздо глубже, чем то, что мы смогли охватить здесь.

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