NumPy — Python для науки о данных

Оглавление:

В этом учебнике по Numpy мы изучим следующие понятия.

  • Необходимые условия:
  • A). Введение в Numpy:
  • B). Импортирование пакета:
  • C). Создание массива Numpy различными способами:
  • D). Shape, ReShape массива Numpy:
  • E). Индексирование и нарезка массива Numpy:
  • F). Специальные массивы Numpy:
  • G). Копирование или дублирование массивов Numpy:
  • H). Трансляция в Numpy:
  • I). Числовые операции над массивом Numpy:
  • J). Матрицы против Numpy Ndarray:
  • K). Встроенные функции Numpy:
  • Заключение:

Предварительные условия:

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

Например: * Если мы понимаем что-то среднее между основами математических операций и продвинутым исчислением, мы можем применить концепции Numpy, чтобы добиться результата в нашем анализе. *


A). Введение:

  • Numpy — это фундаментальный пакет python для научных вычислений. Он используется для создания или манипулирования многомерными массивами или матрицами. Для выполнения сложных математических операций, статистических вычислений, тригонометрических операций и решения задач алгебры.

B). Импортируйте пакет:

import numpy as np
Войти в полноэкранный режим Выход из полноэкранного режима

Пояснения: Ключевое слово import используется для импорта нужного пакета в наш код. Ключевое слово as используется для присвоения псевдонима заданному пакету. numpy — числовой пакет python, используемый для создания числовых массивов в этом учебнике.
Пример: numpy — пакет, а np — псевдоним или краткое имя для numpy.


C). Создание массива Numpy:

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

C1). функция np.arange() :

C1 — Ex1). Функция np.arange() с конечным значением:

a = np.arange(10)
a
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Указана только конечная точка. Если функцияnp.arange() имеет один параметр, то по умолчанию он будет считаться конечным значением и от нуля до заданного числа с шагом =1 будет выведен в выходной массив.

Например: Здесь у нас есть 10 в качестве параметра. В этом случае начальная точка = 0, конечная точка = 10 и размер шага =1. На выходе мы получим список значений от 0 до 10 с пробелом 1, т.е. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Здесь конечная точка исключена из вывода.

Выходные данные:

C1 — Ex2). функция np.arange() со значением End:

a = np.arange(10)
type(a)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: С помощью метода type() можно проверить, что выходной массив является numpy - ndarray, т.е. Numpy- N-мерный массив.

Выходные данные:

C1 — Ex3). функция np.arange() со значениями Start, End:

a = np.arange(0, 10)
a
Войти в полноэкранный режим Выход из полноэкранного режима

Пояснение: Даны начальная и конечная точки. Если функция np.arange() имеет два параметра, то первый параметр — начальная точка и второй параметр — конечная точка с размером шага = 1 будут выведены в выходной массив.

Например: Здесь у нас есть начальная точка = 0, конечная точка = 10 и размер шага =1. На выходе мы получим список значений от 0 до 10 с пробелом 1, т.е. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Здесь конечная точка исключена из вывода.

Выходные данные:

C1 — Ex4). функция np.arange() со значениями Start, End, Step:

a = np.arange(0, 10, 2)
a
Вход в полноэкранный режим Выход из полноэкранного режима

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

Например: Здесь задано start=0, End=10 и Step=2. В выходном массиве первое значение будет 0, второе значение будет 0 + 2, то есть 2, третье значение будет 2 + 2. e. 4, четвертое значение будет 4 + 2 i.e. 6 и последнее значение будет 6 + 2 i.e. 8. На этом вывод прекратится, так как конечная точка будет исключена по умолчанию, поэтому на следующей итерации мы не получим никакого значения на выходе.

Выходные данные:

C1 — Ex5). Функция np.arange() со значениями Start, End, Step, Datatype:

a = np.arange(0, 10, 2, float)
a
Войти в полноэкранный режим Выход из полноэкранного режима

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

Например: Здесь задано start=0, End=10 и Step=2. В выходном массиве первое значение будет 0., второе значение будет 0 + 2, то есть 2.0, третье значение будет 2 + 2. e. 4.0, четвертое значение будет 4 + 2 i.e. 6.0 и последнее значение будет 6 + 2 i.e. 8.0. На этом вывод прекратится, так как конечная точка будет исключена по умолчанию, поэтому на следующей итерации мы не получим никакого значения на выходе.

Выходные данные:

C1 — Ex6). Функция np.arange() со значениями Start, End, Step для плавающих чисел:

a = np.arange(0.25, 10.25, 2)
a
Войти в полноэкранный режим Выход из полноэкранного режима

Пояснения: Здесь мы применяем функцию np.arange() для плавающих чисел. По умолчанию на выходе будут плавающие числа.

Например: Здесь задано start=0.25, End=10.25 и Step=2. В выходном массиве первое значение будет 0.25, второе значение будет 0.25 + 2, то есть 2.25, третье значение будет 2.25 + 2. e. 4.25, четвертое значение будет 4.25 + 2 i.e. 6.25 и последнее значение будет 6.25 + 2 i.e. 8.25. На этом вывод прекратится, так как конечная точка будет исключена по умолчанию, поэтому на следующей итерации мы не получим никакого значения на выходе.

Выходные данные:

C2). функция np.linspace() :

C2 — Ex1). Функция np.linspace() со значениями Start, End, количество элементов по умолчанию:

a = np.linspace(1,10)  #default number of elements=50
a
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Здесь мы указали только начальную и конечную точки, но не количество значений, которые мы хотим. В данном случае по умолчанию это будет 50. Мы создаем массив numpy со значениями от 1 до 10 и количеством элементов =50.

Выходные данные:

C2 — Ex2). Функция np.linspace() со значениями Start, End, количеством элементов по умолчанию:

a = np.linspace(1,10)  #default number of values=50
print(a)
print("Type of array: ", type(a))
print("Length of array: ", len(a))

Войти в полноэкранный режим Выход из полноэкранного режима

Пояснения: Здесь мы указали только начальную и конечную точки, но не количество значений, которые мы хотим. В данном случае по умолчанию это будет 50. Мы создаем массив numpy со значениями от 1 до 10 и количеством элементов =50.
Используя функцию type(), мы видим, что выходной массив является Numpy- N-димерным массивом.
Используя функцию len(), видим, что массив содержит 50 элементов.

Выходные данные:

C2 — Ex3). Функция np.linspace() со значениями Start, End, No..of Elements:

a = np.linspace(0,35,6) 
print(a)
print("Type of array: ", type(a))
print("Length of array: ", len(a))
Войти в полноэкранный режим Выход из полноэкранного режима

Пояснения: Здесь мы задали только начальную, конечную точки и количество значений, которые нам нужны. В данном случае от 0 до 35, если мы получим 6 значений между ними, то получим следующий результат.
Используя функцию type() можно заметить, что выходной массив представляет собой Numpy- N Dimesional array.
Используя функцию len(), мы видим, что массив содержит 6 элементов. В данном примере мы можем легко определить, что значения кратны числу 7 от 0, т.е. [0, 7, 14, 21, 35].

Выходные данные:

C3). функция np.array() :

Ex:

C3 — Ex1). функция np.array() с постоянным значением : 0-мерный массив:

a = np.array(40)

print("array : ", a)
print("Type of a:", type(a))
print("Dimentions of a: ", np.ndim(a))
print("Datatype of a: ", a.dtype)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Этот пример показывает, как создать массив numpy с одним скалярным значением, т.е. 40, заданным в качестве параметра функции np.array(). Это пример для 0-мерного массива.

  • В третьей строке с помощью функции np.ndim() мы можем увидеть размерность массива numpy, здесь данный массив является 0-мерным массивом.

Выходные данные:

C3 — Ex2). Функция np.array() с List : 1-мерный массив:

a = np.array([0,2,4,6,8,10,12])

print("Array : ", a)
print("Type of a:", type(a))
print("Dimentions of a: ", np.ndim(a))
print("Datatype of a: ", a.dtype)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Этот пример показывает, как создать массив numpy со списком значений, т.е. [0,2,4,6,8,10,12] задается в качестве параметра функции np.array(). Это пример для одномерного массива.

  • В третьей строке с помощью функции np.ndim() мы можем увидеть размерность массива numpy, здесь данный массив является 1-мерным массивом.

Выходные данные:

C3 — Ex3). Функция np.array() с массивом Numpy : одномерный массив:

a = np.array(np.arange(10,50,5))

print("Array : ", a)
print("Type of a:", type(a))
print("Dimentions of a: ", np.ndim(a))
print("Datatype of a: ", a.dtype)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Этот пример показывает, как создать массив numpy с выходом функции np.arange(), т.е. [10 15 20 25 30 35 40 45] в качестве параметра функции np.array(). Это пример для одномерного массива.

  • В третьей строке с помощью функции np.ndim() мы можем увидеть размерность массива numpy, здесь данный массив является 1-мерным массивом.

Выходные данные:

C3 — Ex4). Функция np.array() с двумерной матрицей: 2-мерный массив:

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

print("Array : n", a)
print("Type of a:", type(a))
print("Dimentions of a: ", np.ndim(a))
print("Datatype of a: ", a.dtype)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Этот пример показывает, как создать массив numpy с двумерной матрицей, заданной функцией np.array(). Если мы обратим внимание на начало и конец, то там стоят 2 квадратные скобки.

  • В третьей строке с помощью функции np.ndim() мы можем увидеть размерность массива numpy, здесь заданный массив является 2-мерным массивом.

Выходные данные:

C3 — Ex5). Функция np.array() с трехмерным массивом трехмерной матрицы:

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

print("Array : n", a)
print("nType of a:", type(a))
print("Dimentions of a: ", np.ndim(a))
print("Datatype of a: ", a.dtype)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Этот пример показывает, как создать массив numpy с трехмерной матрицей, заданной функцией np.array(). Если мы посмотрим на начало и конец, то там находятся 3 квадратные скобки.

  • В третьей строке с помощью функции np.ndim() мы можем увидеть размерность массива numpy, здесь заданный массив является 3-мерным массивом.

Вывод:


D). Shape, ReShape массива Numpy:

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

D1). функция shape() с постоянным значением: 0-мерный массив:

a = np.array(45)

print("Array: ", a)
print("Dimensions: ", np.ndim(a))
print("Shape: ", np.shape(a))  # Approach-1
Вход в полноэкранный режим Выход из полноэкранного режима
a = np.array(45)

print("Array: ", a)
print("Dimensions: ", np.ndim(a))
print("Shape: ", a.shape)  # Approach-2
Войти в полноэкранный режим Выход из полноэкранного режима

Пояснения: С помощью функции np.array() мы создали 0-мерный массив с постоянным значением 45. С помощью функции np.dim() мы можем получить размерность массива. Мы можем использовать любой из методов np.shape(a) или a.shape для вывода формы (количество строк, количество столбцов) массива. Чтобы избежать двусмысленности, в дальнейшем мы будем использовать функцию np.shape().

Пример: В приведенном ниже примере мы создали массив с постоянным значением, мы знаем, что это 0-дименсионный массив. Для 0-D массива функция np.shape() выдаст пустые значения, как показано ниже.

Вывод:

D2). функция shape() с List: 1-мерный массив:

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

print("Array:", a)
print("Dimensions: ", np.ndim(a))
print("Shape: ", np.shape(a))
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: С помощью функции np.array() мы создали одномерный массив с помощью Python List. С помощью функции np.dim() мы можем получить размерность массива, т.е. одномерного массива. С помощью функции np.shape(a) мы можем получить форму (количество строк, количество столбцов) массива. Здесь одномерный массив будет иметь только количество строк без столбцов. Здесь у нас 10 строк. Примечание: Пожалуйста, не путайте строки и столбцы. По умолчанию любой одномерный массив будет рассматриваться в вертикальном виде. На примере двумерных массивов мы сможем лучше понять функцию np.shape().

Вывод:

D3). функция shape() с двумерной матрицей: 2-мерный массив:

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

print("Array:n", a)
print("nDimensions: ", np.ndim(a))
print("Shape: ", np.shape(a))
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Мы создали двумерный массив numpy с двумерной матрицей. Функция np.ndim() выдает 2 в качестве размерности массива. Если посмотреть на форму массива, то он имеет 2 строки и 5 столбцов и выводится как (2, 5).

Вывод:

D4). функция shape() с трехмерной матрицей: 3-мерный массив:

a = np.array([[[ 0,  1,  2,  3],[ 4,  5,  6,  7],[ 8,  9, 10, 11]],
             [[12, 13, 14, 15],[16, 17, 18, 19],[20, 21, 22, 23]]])

print("Array:n", a)
print("nDimensions: ", np.ndim(a))
print("nShape: ", np.shape(a))
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: С заданной 3D матрицей мы создали трехмерный массив. С помощью np.ndim() мы видим, что это 3D массив. Функция np.shape() возвращает (2, 3, 4). 2 означает 2 набора матриц (3, 4). 3, 4 означает, что в каждом наборе есть 3-строки, 4-столбца. На диаграмме ниже мы можем легко понять форму 3D массива.

Вывод:

D5). функция reshape() — 1D в 2D массив:

li = np.arange(24)
a = li.reshape(4, 6)

print("Array:n", a)
print("nDimensions: ", np.ndim(a))
print("Shape: ", np.shape(a))
Вход в полноэкранный режим Выход из полноэкранного режима
a = np.arange(24).reshape(4, 6)
Войти в полноэкранный режим Выход из полноэкранного режима

Пояснение: У нас есть список или массив 1D со значениями 24. С помощью функции reshape() мы преобразовали массив 1D в массив 2D. В функции reshape мы должны указать размеры, а умножение этих размеров должно быть равно количеству значений в исходном массиве. Здесь 4 X 6 = 24.

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

Вывод:

D6). Функция reshape() — преобразование массива из одномерного в трехмерный:

a = np.arange(24).reshape(2, 3, 4)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Здесь должно быть 2 X 3 X 4 = 24. Здесь мы преобразуем массив 1D в массив 3D с помощью функции reshape(). Объяснение массива 3D мы видели в предыдущем разделе.

Вывод:

D7). функция reshape() — Массив из 2D в 3D:

a = (np.arange(24).reshape(4, 6)).reshape(2, 3, 4)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: С помощью кода (np.arange(24).reshape(4, 6)) мы имеем массив 2D, а затем с внешней стороны применили reshape(2, 3, 4) для преобразования массива 2D в массив 3D. Обратите внимание, что при преобразовании в разные измерения умножение формы должно быть равно количеству элементов исходного массива, например 24 = 4 X 6 = 2 X 3 X 4.

Выход:

D8). функция reshape() — преобразование массива 3D в 2D:

a = (np.arange(24).reshape(2,3,4)).reshape(4,6)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: С помощью кода (np.arange(24).reshape(2,3,4)) мы имеем массив 3D, а затем с внешней стороны мы применили reshape(4,6) для преобразования массива 3D в массив 2D. Обратите внимание, что при преобразовании в разные размерности умножение формы должно быть равно количеству элементов исходного массива, например 24 = 4 X 6 = 2 X 3 X 4. Мы можем преобразовать массив любой размерности в массив нужной размерности тогда и только тогда, когда заданное умножение совпадает.

Выход:


E). Индексирование и нарезка массива Numpy :

E1). Индексирование и нарезка одномерного массива : Array[ :: ].

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

print("Array:", a)
print("Array Length:", len(a))

print("n*********** :Indexing Examples: ***********")
print("1.Access first elements in Array: ", a[0])
print("2.Access last elements in Array with [-1] index: ", a[-1])
print("3.Access last elements in Array : ", a[9])
print("4.Access 3rd elements in Array: ", a[2])

print("n*********** :Slicing Examples: ***********")
print("1.Slice the array from 4th element to end: ", a[3:])
print("2.Slice the such that only even indexes should come: ", a[::2])
print("3.Slice the such that only odd indexes should come: ", a[1::2])
print("4.Print the array in reverse order: ", a[::-1])
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Для одномерного массива мы можем использовать a[начало, конец, шаг].

Индексирование : Для массивов Numpy индекс начинается с 0. Для доступа к первому элементу мы используем a[0], что означает a — имя массива numpy, а 0 — индекс. Аналогично для доступа к последнему элементу у нас есть 2 варианта. Мы можем использовать length -1, т.е. a[9], чтобы получить последний элемент, или мы можем использовать -1, например a[-1]. Например, если мы хотим получить доступ к n-му элементу массива, мы должны передать n-1 в качестве значения индекса массива.

Нарезка : Если мы хотим получить небольшую часть массива, мы можем использовать подход [Start:Stop:Step]. Чтобы получить подмассив от 4-го элемента до конца, мы можем использовать a[3:]. Здесь мы говорим о печати от индекса 3 до конца. Для печати элементов с четным индексом мы можем использовать a[::2]. Это означает печать элементов от начала до конца с размером шага 2. Аналогично для нечетных позиций индекса мы будем использовать a[1::2], потому что мы знаем, что первое нечетное число 1 до конца с размером шага 2. Чтобы развернуть заданный массив numpy простым способом, используйте -1 в качестве размера шага, как a[::-1]. Здесь мы ожидаем получить результат от начала до конца в обратном порядке.

Вывод:

E2). Индексирование и нарезка двумерного массива : Array[ :: , :: ]

a = np.arange(24).reshape(4, 6)

print("Array:n", a)
print("nArray Length:", np.size(a))

print("n*********** :Indexing Examples: ***********")
print("1.Print 16 value:", a[2, 4])
print("2.Print 21 value:", a[3, 3])
print("3.Print 9 value:", a[1, 3])
print("4.Print 23 value:", a[-1, -1])

print("n*********** :Slicing Examples: ***********")
print("1.Access 1st row in Array: ",  a[0,:])
print("2.Access last row in Array: ", a[-1,:])
print("3.Access first column in Array: ", a[:,0])
print("4.Access last column in Array: ",  a[:,-1])
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Для двумерного массива мы используем формат [ :: , :: ], который разделяется , и в левой части мы можем делать индексацию или нарезку для строк, в правой части мы можем делать индексацию или нарезку для столбцов, поскольку это двумерный массив, мы должны иметь дело со строками и столбцами. В каждой стороне мы можем применять операции индексирования списка, например [start:end:step].

Примеры индексирования: Если мы посмотрим на скриншот ниже, то при индексе строки=2 и индексе столбца=4 мы получим значение=16. Аналогичным образом в заголовке ниже 2D массив Index with array element: мы имеем индексы по строке и столбцу, чтобы получить значение пертикулярного массива.

Примеры нарезки: Для получения всего первого ряда мы используем синтаксис a[ 0 , : ]. Это означает, что при индексации строк мы ожидаем вывести первую строку, а при индексации столбцов - все столбцы из первой строки.

Вывод:

E3). Индексирование и нарезка 3D массива : Array[ :: , :: , :: ]

a = np.arange(24).reshape(2, 3, 4)

print("Array:n", a)
print("nArray Length:", np.size(a))

print("n*********** :Indexing Examples: ***********")
print("1.Print 5 value:", a[0, 1, 1])
print("2.Print 8 value:", a[0, 2, 0])
print("3.Print 17 value:", a[1, 1, 1])
print("4.Print 23 value:", a[1, 2, 3])

print("n*********** :Slicing Examples: ***********")
print("1.Access 1st set in 3D Array: n",  a[0 , : , : ])
print("2.Access 2nd set in 3D Array: n",  a[1 , : , : ])
print("3.Access 1st column in all set in 3D Array: n",  a[: , : , 0 ])
print("4.Access 1st row in all set in 3D Array: n",  a[: , 0 , : ])
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Для 3D массива мы используем формат [ :: , :: , :: ], который разделяется , и первый используется для выбора набора, второй используется для индексации или нарезки для строк, а третий используется для индексации или нарезки для столбцов, поскольку это 3D массив, мы должны иметь дело с наборами, строками и столбцами. На каждой стороне мы можем применять операции индексирования списка, например [start:end:step].

Примеры индексирования: Если мы видим скриншот ниже, чтобы проиндексировать любое значение, мы должны использовать set value, row value, column value. Для получения значения 5 оно доступно в set value =0, row value=1 и column value =1 .

Примеры нарезки : Чтобы получить всю первую строку, мы используем синтаксис a[ :, 0 , : ]. Это означает, что нужно выбрать значения во всех наборах, в каждом наборе выбрать только строку=1 и все столбцы.

Вывод:

E4). Булева индексация массива Numpy:

# Given 2D numpy array.
a = np.array(np.arange(40,60).reshape(4,5))
print("Array:n",a)

# Check each value odd or even number in given numpy array 
print("Check each value in numpy array is even or odd number:n")
print(a%2==0)

print("nConvert Boolean values into Integers(0,1):")
b = a%2==0
print(b.astype(int))
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Использование любых операторов сравнения (<, <=, >, >=, ==) поверх массива numpy создаст массив с булевой индексацией. С помощью np.arange(40,60).reshape(4,5) мы создаем двумерный массив numpy. Массив будет содержать 4 X 5 = 20 элементов. С помощью кода a%2==0 мы проверяем четное или нечетное значение каждого элемента. В итоге этот код создаст булев массив размером 4 X 5, содержащий значения true или false. Мы можем преобразовать булевы значения (true, false) в целочисленные значения (0,1) с помощью преобразования типов, называемого функцией astype(int).

Выходные данные:


F). Специальные массивы Numpy:

В этом разделе мы узнаем о ones(), ones_like(), zeros(), zeros_like(), empty(), full(), transpose() специальных функциях массивов numpy.

F1). функция ones():

print("***** Ones() Example: with float type. *****")
a = np.ones(5)
print("Array:n",a)
print("Array Dimension:", a.ndim)

print("n***** Ones() Example: with integer type. *****")
a = np.ones(5, dtype='int')
print("Array:n",a)
print("Array Dimension:", a.ndim)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Функция ones() будет полезна, когда мы хотим создать массив numpy со всеми элементами, установленными в 1 или 1. на основе типа данных с заданными размерами. По умолчанию все значения будут с плавающей точкой, например (1.), мы можем изменить тип данных каждого значения с помощью параметра dtype=int на целочисленные значения, например (1). С помощью аргумента a.ndim мы можем увидеть размеры массива.

Например: В функции ones() мы указываем 5, что означает 1D массив с 5 элементами и dtype='int', что означает, что вывод должен быть в целочисленном типе данных.

Вывод:

F2). функция ones() для 2D, 3D массивов:

print("***** Ones() Example 2D Array *****")
a = np.ones((2,3), dtype='int')
print("Array:n",a)
print("Array Dimension:", a.ndim)

print("n***** Ones() Example 3D Array *****")
a = np.ones((2,3,4), dtype='int')
print("Array:n",a)
print("Array Dimension:", a.ndim)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Мы можем применять эти специальные функции и для массивов большей размерности. Мы будем задавать необходимые размеры, например (2,3) или (2,3,4). Мы можем проверить размеры с помощью аргумента ndim.

Выход:

F3). функция ones_like() для массивов 1D, 2D, 3D:

print("********** ones_like() Example 1D Array **********")
given_array = np.array([8,4,5,6,3])
target_array = np.ones_like(given_array)
print("Given Array:n",given_array)
print("nTarget Array:n",target_array)
print("nGiven_array Dimension:", given_array.ndim)
print("Target_array Dimension:", target_array.ndim)

print("n********** ones_like() Example 2D Array **********")
given_array = np.arange(6).reshape(2,3)
target_array = np.ones_like(given_array)
print("Given Array:n",given_array)
print("nTarget Array:n",target_array)
print("nGiven_array Dimension:", given_array.ndim)
print("Target_array Dimension:", target_array.ndim)

print("n********** ones_like() Example 3D Array **********")
given_array = np.arange(24).reshape(2,3,4)
target_array = np.ones_like(given_array)
print("Given Array:n",given_array)
print("nTarget Array:n",target_array)
print("nGiven_array Dimension:", given_array.ndim)
print("Target_array Dimension:", target_array.ndim)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Функции ones(), ones_like() обслуживают одну и ту же функциональность. Используя функцию ones_like(), мы также можем создать массив numpy со всеми элементами =1, но для целей размерности мы будем давать ссылочный массив numpy. Если мы дадим в качестве ссылки двумерный массив, то двумерный массив со всеми элементами будет 1.

Пример: В приведенных ниже примерах мы имеем 1D, 2D, 3D numpy-массивы вместе с их ones_like массивами с теми же размерами.

Выход:

F4). функция zeros() для массивов 1D, 2D, 3D:

print("***** Zeros() Example 1D Array *****")
a = np.zeros(5, dtype='int')
print("Array:n",a)
print("Array Dimension:", a.ndim)

print("n***** Zeros() Example 2D Array *****")
a = np.zeros((2,3), dtype='int')
print("Array:n",a)
print("Array Dimension:", a.ndim)

print("n***** Zeros() Example 3D Array *****")
a = np.zeros((2,3,4), dtype='int')
print("Array:n",a)
print("Array Dimension:", a.ndim)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Подобно функции ones(), мы можем использовать функцию zeros() для создания массива numpy с заданными размерами, установив все элементы в 0. Мы можем использовать функцию zeros() для любой заданной размерности.

Вывод:

F5). функция zeros_like() для массивов 1D, 2D, 3D:

print("********** zeros_like() Example 1D Array **********")
given_array = np.array([8,4,5,6,3])
target_array = np.zeros_like(given_array)
print("Given Array:n",given_array)
print("nTarget Array:n",target_array)
print("nGiven_array Dimension:", given_array.ndim)
print("Target_array Dimension:", target_array.ndim)

print("n********** zeros_like() Example 2D Array **********")
given_array = np.arange(6).reshape(2,3)
target_array = np.zeros_like(given_array)
print("Given Array:n",given_array)
print("nTarget Array:n",target_array)
print("nGiven_array Dimension:", given_array.ndim)
print("Target_array Dimension:", target_array.ndim)

print("n********** zeros_like() Example 3D Array **********")
given_array = np.arange(24).reshape(2,3,4)
target_array = np.zeros_like(given_array)
print("Given Array:n",given_array)
print("nTarget Array:n",target_array)
print("nGiven_array Dimension:", given_array.ndim)
print("Target_array Dimension:", target_array.ndim)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Функции zeros(), zeros_like() выполняют одну и ту же функцию. Используя функцию zeros_like(), мы также можем создать массив numpy со всеми элементами =0, но для целей размерности мы будем задавать эталонный массив numpy. Если мы дадим в качестве ссылки двумерный массив, то двумерный массив со всеми элементами будет 0.

Пример: В приведенных ниже примерах мы имеем 1D, 2D, 3D numpy-массивы вместе с их нуль_подобными массивами с одинаковыми размерами.

Выход:

F6). функция empty():

a = np.empty((3,5))
print("Array:n", a)
print("nDimensions =", a.ndim)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Функция np.empty() генерирует массив numpy, устанавливая все элементы =0 на основе заданной формы. Она работает так же, как и функция np.zeros().

Выход:

F7). функция full():

a = np.full((2,3,4), 999, dtype=int)
print("Array:n", a)
print("nArray Dimensions = ", a.ndim)
print("Array Shape = ", a.shape)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Функция np.full() будет полезна, когда мы хотим создать массив numpy с заданным значением и заданными размерами. Здесь 999 - значение, которое мы хотим задать всем элементам массива, а (2,3,4) - размеры, с которыми мы хотим создать массив numpy.

Вывод:

F8). функция transpose():

print(" ***** Original Array: ***** n",a)
a = np.array(np.arange(12).reshape(3,4))
print("nShape of Original Array:",a.shape)
print("Dimensions of Original Array:",a.ndim)


print("n ***** Transposed Array: ***** n",b)
#b = a.transpose()  --> #same as below
b = np.transpose(a)
print("nShape of Transposed Array:",b.shape)
print("Dimensions of Transposed Array:",b.ndim)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Используя функцию transpose(), мы можем менять строки на столбцы и столбцы на строки массива numpy или матрицы. Мы можем представить себе вращающийся массив.
Это очень полезно в математической области и в области Data Science.
Например: В примере ниже у нас есть исходный массив с формой = (3,4), т.е. 3 строки, 4 столбца. После применения функции transpose() теперь мы имеем массив shape = (4,3), то есть 4 строки, 3 столбца. Мы можем использовать a.transpose(), np.transpose(a) любой из способов для получения требуемого результата. Первая строка (0,1,2,3) в исходном массиве становится первым столбцом (0,1,2,3) в транспонированном массиве.

Выход:

F9). функция identity():

print("***** (4 X 4) Identity Matrix with Floating values: *****")
a = np.identity(4)
print(a)

print("n***** (4 X 4) Identity Matrix with Integer values: *****")
a = np.identity(4, dtype=int)
print(a)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Функция np.identity() используется для создания n X n квадратной матрицы тождества (2D массив), где все диагональные элементы установлены в 1, а остальные элементы в 0. По умолчанию тип данных элементов будет плавающим числом. Мы можем использовать параметр dtype=int для преобразования плавающих чисел в целые значения. Эта матрица будет очень полезна в математике и науке о данных. Здесь n=4, поэтому будет создана квадратная матрица тождества 4 X 4.

Вывод:

F10). функция eye():

print("*****(A): (4 X 4) Identity Square Matrix: *****")
a = np.eye(4, dtype=int)
print(a)
print("nShape = ",a.shape)

print("n*****(B): (4 X 6) Identity Rectangle Matrix: *****")
a = np.eye(4,6, dtype=int)
print(a)
print("nShape = ",a.shape)

print("n*****(C): (4 X 6) Identity Rectangle Matrix Indentity starts at k=2: *****")
a = np.eye(4,6,k=2, dtype=int)
print(a)
print("nShape = ",a.shape)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: С помощью функции np.eye() мы можем создать квадратную матрицу идентичности, а также прямоугольную матрицу идентичности на основе формы, которую мы предоставляем функции.

Пример - A Мы задали np.eye(4, dtype=int) и на выходе получим 4 X 4 квадратную матрицу тождеств, где все диагональные элементы будут установлены в 1, а остальные элементы будут установлены в 0 и диагональ начинается в (0,0) позиции.

Ex - B Мы задали np.eye(4,6, dtype=int) и результатом будет 4 X 6 прямоугольная матрица тождества, где все диагональные элементы будут установлены в 1, а остальные элементы будут установлены в 0 и диагональ начинается в позиции (0,0). Но последние 2 столбца не будут иметь 1 в диагонали, так как этот массив не является квадратной матрицей.

Ex - C Мы задали np. eye(4,6,k=2, dtype=int) и результатом будет 4 X 6 прямоугольная матрица тождества, где все диагональные элементы будут установлены в 1, а остальные элементы будут установлены в 0 и диагональ начинается в позиции (0,2), так как мы установили k=2 и диагональ тождества будет начинаться с k=2. Но первые 2 столбца не будут иметь 1 в диагонали, так как этот массив не является квадратной матрицей и мы упомянули, что диагональ начинается с k=2.

Выход:


G). Копирование или дублирование массивов Numpy:

У нас есть целых 3 способа копирования или дублирования массивов numpy.

Прежде чем перейти к концепции копирования массивов, нам необходимо понять функцию id() и атрибут base. С помощью этих двух функций мы сможем легко понять концепции копирования массивов.

G1). Функция ID, атрибуты Base массива Numpy :

print("*****(A): ID() function: *****")
print("ID(5): ", id(5))
x = 5
print("ID(X): ", id(x))
y = x
print("ID(Y): ", id(y))
z = [1,2,3]
print("ID(Z): ", id(z))

print("n*****(B): base attribute: *****")
p=np.arange(10)
print("P.Base = ", p.base)
print("P.Base is None = ", p.base is None)

q = p[5:]
print("nQ.Base = ", q.base)
print("Q.Base is P = ", q.base is p)
print("Q.Base None = ", q.base is None)

r = p
print("nR.Base = ", r.base)
print("R.Base is P = ", r.base is p)
print("R.Base is None = ", r.base is None)
Войти в полноэкранный режим Выход из полноэкранного режима

Объяснение: Ex - A : id() : Эта функция используется для печати идентификатора конкретного объекта python (это может быть переменная, список, кортеж, словарь, .....) и является целочисленным значением.
Это значение будет оставаться неизменным в течение всего времени жизни объекта в данной программе.

Ex -A-Output : В приведенном выше примере значение 5 имеет некоторый ID, 5 присваивается переменной x и x также имеет тот же ID. Переменная x присвоена переменной y и y также имеет тот же ID. Это означает, что если одно значение присваивается нескольким переменным с помощью оператора присваивания =, то эти объекты также имеют одинаковые ID. ID для списка z отличается от ID x, y.

Ex - B : base: Этот атрибут используется для проверки того, является ли базовая память данного объекта производной от какого-либо другого объекта или нет. Если данный объект не является производным от других объектов, то base = None.

Ex -B-Output : В приведенном выше примере p - это массив numpy, имеющий значения от 0 до 9. Он не основан и не является производным от какого-либо существующего объекта и создается функцией numpy, поэтому p.base = None. q является подмассивом p, поэтому он получен из памяти p. Поэтому q.base = p, то есть массив numpy от 0 до 9. r присвоен p, но не является подразделением p, поэтому r.base = None так же, как p.base = None .

Вывод:

G2). Простое назначение =:

print("*****(A): Create numpy array and make a copy with assignment operator: *****")
a = np.array(np.arange(10))
b = a
print("Original_Array A:n",a)
print("nTemp_Array B:n",b)

print("n*****(B): Check the ID, Base of each array before modification: *****")
print("ID of A :",id(a))
print("ID of B :",id(b))
print("nB is A:",b is a)
print("A is B:",a is b)
print("nB.base is A:",b.base is a)
print("A.base is B:",a.base is b)

print("n*****(C): Modify the Temp array and check the ID, Base of each array: *****")
b[0] = 9999
print("Original_Array A:n",a)
print("nTemp_Array B:n",b)
print("nID of A :",id(a))
print("ID of B :",id(b))

print("n*****(D): Modify the Original array and check the ID, Base of each array: *****")
a[0] = 2222
print("Original_Array A:n",a)
print("nTemp_Array B:n",b)
print("nID of A :",id(a))
print("ID of B :",id(b))
Войти в полноэкранный режим Выйти из полноэкранного режима

Пояснения: Простые присваивания не делают копий объектов или их данных.

В разделе A: мы просто создали массив numpy a = np.array(np.arange(10)) и просто присвоили b = a. Будем считать, что a - это исходный массив, а b - временный массив для нашего понимания.

В разделе B: мы пытаемся проверить расположение в памяти переменных a, b с помощью функции id(), а переменные a, b имеют одинаковый ID. Используя ключевое слово is можно проверить, что переменные a, b одинаковы и не было создано скрытого представления, а b is a , a is b дают на выходе True. Используя атрибут base, мы можем проверить, что одна переменная является производной или вырезанной из другой переменной. Здесь b.base is a, a.base is b дают на выходе False, потому что ни один из массивов не является производным или вырезанным из другой переменной.

В разделе С: мы пытаемся изменить один индекс во временном массиве b как b[0] = 9999. Теперь, если мы видим, что исходный массив также был изменен, и идентификаторы обоих массивов a, b также одинаковы. Это означает, что при присвоении = вторая копия массива не была создана.

В разделе D: мы пытаемся изменить один индекс в исходном массиве a как a[0] = 2222. Теперь, если мы видим, что временный массив также был изменен, и идентификаторы обоих массивов a, b также одинаковы. Это означает, что при присвоении = вторая копия массива не была создана.

Вывод:

G3). View() или Shallow copy:

print("*****(A): Create numpy array and make a copy with view() function: *****")
a = np.array(np.arange(10))
b = a.view()
print("Original_Array A:n",a)
print("nTemp_Array B:n",b)

print("n*****(B): Check the ID, Base of each array before modification: *****")
print("ID of A :",id(a))
print("ID of B :",id(b))
print("nB is A:",b is a)
print("A is B:",a is b)
print("nB.base is A:",b.base is a)
print("A.base is B:",a.base is b)

print("n*****(C): Modify the Temp array and check the ID, Base of each array: *****")
b[0] = 9999
print("Original_Array A:n",a)
print("nTemp_Array B:n",b)
print("nID of A :",id(a))
print("ID of B :",id(b))

print("n*****(D): Modify the Original array and check the ID, Base of each array: *****")
a[0] = 2222
print("Original_Array A:n",a)
print("nTemp_Array B:n",b)
print("nID of A :",id(a))
print("ID of B :",id(b))
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Функция view() создает неглубокую копию для переменной. Shallow copy означает неполную копию.

В разделе A: мы только что создали массив numpy a = np.array(np.arange(10)) и создали временный массив b = a.view(). Будем считать, что a - это исходный массив, а b - временный массив для нашего понимания.

В разделе B: мы пытаемся проверить расположение в памяти переменных a, b с помощью функции id(), а переменные a, b не имеют одинакового ID. Используя ключевое слово is можно проверить, что переменные a, b не одинаковы и было создано скрытое представление, а b is a , a is b дают False в качестве вывода, потому что была создана неглубокая копия, из-за чего ID не совпадают. Используя атрибут base, мы можем проверить, что одна переменная является производной или срезом другой переменной. Здесь b.base is a является True, потому что b является производной от a. a.base is b выдают False, потому что a не является производной или срезом от b.

В разделе С: мы пытаемся изменить один индекс во временном массиве b как b[0] = 9999. Теперь, если мы видим, что исходный массив также был изменен, но идентификаторы обоих массивов a, b не совпадают, это и означает shallow copy. Это означает, что при использовании функции view() идентификаторы будут отличаться, но изменение одного массива отразится на другом.

В разделе D: мы пытаемся изменить один индекс в исходном массиве a как a[0] = 2222. Теперь, если мы видим, что временный массив также был изменен, но идентификаторы обоих массивов a, b не совпадают, это и означает shallow copy. Это означает, что при использовании функции view() идентификаторы будут отличаться, но изменение одного массива отразится на другом.

Вывод:

G4). Copy() или Глубокое копирование:

print("*****(A): Create numpy array and make a copy with copy() function: *****")
a = np.array(np.arange(10))
b = a.copy()
print("Original_Array A:n",a)
print("nTemp_Array B:n",b)

print("n*****(B): Check the ID, Base of each array before modification: *****")
print("ID of A :",id(a))
print("ID of B :",id(b))
print("nB is A:",b is a)
print("A is B:",a is b)
print("nB.base is A:",b.base is a)
print("A.base is B:",a.base is b)

print("n*****(C): Modify the Temp array and check the ID, Base of each array: *****")
b[0] = 9999
print("Original_Array A:n",a)
print("nTemp_Array B:n",b)
print("nID of A :",id(a))
print("ID of B :",id(b))

print("n*****(D): Modify the Original array and check the ID, Base of each array: *****")
a[0] = 2222
print("Original_Array A:n",a)
print("nTemp_Array B:n",b)
print("nID of A :",id(a))
print("ID of B :",id(b))
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Функция copy() создаст глубокую копию для переменной. Глубокая копия означает полную отдельную копию.

В разделе A: мы просто создали массив numpy a = np.array(np.arange(10)) и создали временный массив b = a.view(). Будем считать, что a - это исходный массив, а b - временный массив для нашего понимания.

В разделе B: мы пытаемся проверить расположение в памяти переменных a, b с помощью функции id(), а переменные a, b не имеют одинакового ID. Используя ключевое слово is, можно проверить, что переменные a, b не одинаковы и было создано отдельное представление, а b is a , a is b дают False в качестве вывода, потому что была создана глубокая отдельная копия, из-за чего ID не совпадают. Используя атрибут base, мы можем проверить, является ли одна переменная производной или срезом другой переменной. Здесь b.base is a является False, потому что b является глубокой копией a, а не производной от a. a.base is b дают на выходе False, потому что a не является производным или срезом от b.

В разделе С: мы пытаемся изменить один индекс во временном массиве b как b[0] = 9999. Теперь, если мы видим, что исходный массив не модифицируется. Это потому, что a, b теперь являются двумя глубокими (отдельными) копиями и ID обоих массивов a, b не совпадают, что и означает Deep copy. Это означает, что при использовании функции copy() идентификаторы будут отличаться, и изменение одного массива не отразится на другом.

В разделе D: мы пытаемся изменить один индекс в исходном массиве a как a[0] = 2222. Теперь, если мы видим, что исходный массив не модифицируется. Это потому, что a, b теперь являются двумя глубокими (отдельными) копиями и ID обоих массивов a, b не совпадают, что и означает Deep copy. Это означает, что при использовании функции copy() идентификаторы будут отличаться, и изменение одного массива не отразится на другом.

Вывод:


H). Браудкастинг в Numpy

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

H1). Трансляция Пример-1:

a = np.array(np.arange(12).reshape(3,4))
print("nArray A: n", a)

b = np.array(np.arange(4))
print("nArray B: n", b)

c = a + b
print("nArray C = A + B :n",c)

print("nArray A dimensions: ", a.shape)
print("Array B dimensions: ", b.shape)
print("Array C dimensions: ", c.shape)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: С помощью a = np.array(np.arange(12).reshape(3,4)) мы создали массив размерностью 3 X 4, а с помощью b = np.array(np.arange(4)) мы создали 1 размерный массив, имеющий 4 значения. Теперь, когда мы пытаемся напечатать print("nArray C = A + B :n",c), мы получаем выходной массив также в 3 X 4 размерности. Здесь массив B был преобразован в размерность 3 X 4 автоматически без использования дополнительных ключевых слов. Но здесь размер столбцов должен совпадать, иначе эта трансляция не будет работать. Здесь массив A имеет 3 строки, 4 столбца, а массив B имеет 1 строку, 4 столбца, поэтому размер столбцов совпадает и трансляция произошла автоматически, когда мы применяем арифметические операции над массивами Numpy.

Вывод:

H2). Пошаговое объяснение процесса трансляции:

print("nLet's see how array B has broadcasted into given Bigger array shape:")
c = np.array([b,b,b])
#c = np.array([b]*3)
#c= np.array([b,]*3)
print(c)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Приведенное выше объяснение будет таким же и здесь, если мы хотим вручную превратить массив малого размера в массив большего размера без трансляции, мы можем использовать любую из приведенных выше команд. c = np.array([b,b,b]) или c = np.array([b]*3) или c= np.array([b,]*3).

Выходные данные:


I). Числовые операции над массивом Numpy:

  • В этом разделе мы будем работать над добавлением числа к массиву numpy или умножением числа на массив numpy, а также над сложением или умножением со значением или массивом numpy.
  • Для умножения двух массивов numpy необходимо, чтобы количество столбцов левой части массива и количество строк правой части массива совпадали.
  • Чтобы сложить 2 массива numpy, форма обоих массивов должна совпадать, иначе трансляция будет применяться для массива меньшего размера.

I1). Массив Numpy с любым числовым значением:

a = np.array(np.arange(40,60).reshape(4,5))
print("Original Array :n",a)

#Symbols: +, -, *, /, **

print("nArray+10 : Addition of array and value :n",a+10)
print("nArray*10 : Multiplication of array and value :n",a*10)
Войти в полноэкранный режим Выход из полноэкранного режима

Пояснения: Мы можем использовать любую из арифметических операций (+, -, , /, *), упомянутых выше. Если мы добавим (или выполним любую арифметическую операцию) к массиву numpy с любым заданным значением, то операция будет выполнена в каждом элементе массива с заданным числом и выдаст результат в той же позиции индексации.

Выходные данные:

I2). 2 массива Numpy одинаковой формы: Без трансляции:

a = np.array(np.arange(20).reshape(4,5))
print("Array A:n",a)

b = np.array(np.arange(60,80).reshape(4,5))
print("nArray B:n",b)

print("nA + B: Addition of 2 numpy arrays with same shape :n", a + b)
print("nA * B: Multiplication of 2 numpy arrays with same shape :n", a * b)
Войти в полноэкранный режим Выход из полноэкранного режима

Пояснения: Здесь 2 массива numpy имеют одинаковый размер, поэтому трансляция не требуется. Если мы выполним сложение (или арифметическую операцию) над двумя массивами, то данная операция будет выполнена над соответствующими индексными элементами в каждом массиве.
Например: (0,0) Индексный элемент в массиве A - 0, а в массиве B - 60. Если данная операция +, то в выходном массиве будет 0 + 60 = 60 в индексе (0,0). То же самое относится ко всем арифметическим операциям. Если операция *, то 0 * 60 = 0 в индексе (0,0).

Выходные данные:

I3). 2 массива Numpy одинаковой формы: С помощью Broadcast:

a = np.array(np.arange(20).reshape(4,5))
print("Array A:n",a)

b = np.array(np.arange(60,65).reshape(1,5))
print("nArray B:n",b)

print("nA + B: Addition of 2 numpy arrays with same shape :n", a + b)
print("nA * B: Multiplication of 2 numpy arrays with same shape :n", a * b)
Войти в полноэкранный режим Выход из полноэкранного режима

Объяснение: Форма массива A - (4,5), а форма массива B - (1,5). Если мы применим любую арифметическую операцию между этими двумя массивами, то наименьший массив (массив B) будет автоматически транслирован в форму (4,5) и затем будут выполнены операции. Мы уже рассмотрели процесс трансляции в предыдущем разделе.
Примечание: Если и только если количество строк наименьшего массива =1, а количество столбцов должно совпадать с количеством столбцов наибольшего массива , то можно выполнять подобные арифметические операции.

Вывод:


J). Матрицы против Numpy Ndarray :

  • Класс Numpy matrix является подмножеством класса Numpy ndarray.
  • Массивы Numpy могут быть преобразованы в матрицу с помощью функции mat() или matrix().
  • Мы можем увидеть разницу между матрицей и ndarrays, используя операцию * или multiplication.

J1). Создание матрицы, Ndarrays:

print('n', "*" * 20,'Numpy Arrays', "*" * 20, 'n')

a = np.array(np.arange(4).reshape(2,2))
print("Numpy Array A:n",a)
print("Type of A: ",type(a))
print("Shape of A: ",np.shape(a))

b = np.array(np.arange(4,8).reshape(2,2))
print("nNumpy Array B:n",b)
print("nType of B: ",type(b))
print("Shape of B: ",np.shape(b))

print('n', "*" * 20,'Numpy Matrix', "*" * 20, 'n')

Mat_A = np.matrix(a)
print("Numpy Matrix Mat_A:n",Mat_A)
print("Type of Mat_A: ",type(Mat_A))
print("Shape of Mat_A: ",np.shape(Mat_A))

Mat_B = np.matrix(b)
print("nNumpy Matrix Mat_B:n",Mat_B)
print("Type of Mat_B: ",type(Mat_B))
print("Shape of Mat_B: ",np.shape(Mat_B))
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснение: Мы создали массивы Numpy, как обычно. С помощью функций mat() или matrix() мы можем преобразовать массив Numpy в матрицу Numpy. Мы можем провести перекрестную проверку классов с помощью метода type().

Вывод:

J2). Массивы Numpy, матричное умножение:

print('n', "*" * 20,':Numpy Arrays Multiplication:', "*" * 20, 'n')

a = np.array(np.arange(4).reshape(2,2))
b = np.array(np.arange(4,8).reshape(2,2))
print("Numpy Array A:n",a)
print("nNumpy Array B:n",b)
print("nNumpy Arrays Multiplication A*B:n",a*b)
print("nNumpy Arrays Matrix Multiplication dot(A,B):n",np.dot(a,b))

print('n', "*" * 20,':Numpy Matrix Multiplication:', "*" * 20, 'n')

Mat_A = np.matrix(a)
Mat_B = np.matrix(b)
print("Numpy Matrix Mat_A:n",Mat_A)
print("nNumpy Matrix Mat_B:n",Mat_B)
print("nNumpy Matrixs Multiplication Mat_A*Mat_B:n",Mat_A*Mat_B)
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Мы можем ясно видеть, что в операции * (умножение) есть разница между массивами и матрицами. В массивах операция * происходит по соответствующему индексу массива. Если индекс (0,0) в массиве A равен 0, а в массиве B - 4, то на выходе получится 0 X 4 = 0. В матричном умножении мы видим, что выходное значение по индексу (0,0) = (A[0,0] X B[0,0]) + (A[0,1] x B[1,0]) = 6. Более подробно об умножении матриц можно прочитать на странице Википедии здесь. Ту же операцию можно проделать с массивами Numpy, используя метод dot().

Выходные данные:


K). Встроенные функции Numpy :

  • Статистические функции Numpy: min(), max(), mean(), mode(), std(), var(), ...
  • Numpy Тригонометрические, экспоненциальные, логарифмические функции: sin(), cos(), tan(), exp(), log(), ...
  • Функции округления Numpy: round(), ceil(), floor().

K1). Статистические функции Numpy:

a = np.array(np.arange(6).reshape(2,3))
print("Given Array A:n",a)

print('n', "*" * 20,':Numpy Statistical functions:', "*" * 20)
print("nMinimum value in A: ", np.min(a))
print("Maximum value in A: ", np.max(a))
print("Mean of Array A: ", np.mean(a))
print("Median of Array A: ", np.median(a))
print("Variance of Array A: ", np.var(a))
print("Standard Deviation of Array A: ", np.std(a))
print("Sum of Array A: ", np.sum(a))
print("Count of Array A: ", np.size(a))
Вход в полноэкранный режим Выход из полноэкранного режима

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

Выход:

K2). Тригонометрические, экспоненциальные, логарифмические функции Numpy:

a = np.array(np.arange(6).reshape(2,3))
print("Given Array A:n",a)

print('n', "*" * 20,':Numpy Trigonometric functions:', "*" * 20)
print("nApply sin() function to array A: n", np.sin(a))
print("nApply cos() function to array A: n", np.cos(a))
print("nApply tan() function to array A: n", np.tan(a))
print("nApply inverse sin() function to array A: n", np.arcsin(a))
print("nApply inverse cos() function to array A: n", np.arccos(a))
print("nApply inverse tan() function to array A: n", np.arctan(a))

print('nn', "*" * 20,':Numpy Exponential, Logarithmic functions:', "*" * 20)
print("nApply exp() exponential function to array A: n", np.exp(a))
print("nApply log() logarithmic function to array A: n", np.log(a))
Войти в полноэкранный режим Выход из полноэкранного режима

Пояснения: Тригонометрические, экспоненциальные и логарифмические функции очень полезны в области Data Science и машинного обучения.

Выход:

K3). Функции округления Numpy:

a = np.array([5.56, 1.24, 0.89, 0.12, -1.456, -3.78]).reshape(2,3)
print("Given Array A:n",a)

print('n', "*" * 20,':Numpy Rounding functions:', "*" * 20)
print("nApply round() function to array A: n", np.round(a))
print("nApply floor() function to array A: n", np.floor(a))
print("nApply ceil() function to array A: n", np.ceil(a))
Вход в полноэкранный режим Выход из полноэкранного режима

Пояснения: Эти функции округления очень полезны в научных расчетах и концепциях машинного обучения.
Функция round() округлит элемент или число до ближайшего округленного числа (увеличит или уменьшит число, чтобы округлить его до ближайшего числа).
Функция floor() округляет заданное число до ближайшего малого числа. (для 5.56 ближайшее маленькое число будет 5.0).
Функция ceil округляет заданное число до ближайшего большого числа. (для 0.12 ближайшее большое число будет 1.0).

Вывод:


Вывод:

Я надеюсь, что вы изучили концепции Numpy на простых примерах.

Счастливого обучения!!!

Оставьте комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *