Что такое NumPy?

NumPy расшифровывается как Numerical Python, это библиотека Python, которая позволяет выполнять числовые вычисления. Это одна из наиболее часто используемых библиотек для числовых и научных вычислений, а также основной строительный блок для таких библиотек, как Pandas, TensorFlow и Scikit-Learn. Это быстро, потому что он построен с помощью C. В отличие от списка, который имеет однородные значения данных, элементы массива Numpy имеют один тип данных (т.е. гетерогенный).

Массив NumPy имеет четыре категории измерений

1. Нульмерные массивы представляют скаляры

2. одномерные массивы представляют векторы

3. двумерные массивы представляют матрицы

4. Многомерные тензоры

Применение Numpy

1. Наука о данных

2. Искусственный интеллект/машинное обучение

3. Обработка сигналов и изображений

4. Научные и инженерные вычисления

Чтобы установить Numpy*pip install numpy*

# Array initialization using Numpy 
import numpy 
numpy_array = numpy.array([1,2,3,4,5,6])
print('Numpy_Array',numpy_array)
print('Numpy_Array',numpy_array * 2,"\n")

import numpy as np # using np as alias for numpy 
np = numpy.array([1,2,3,4,5,6])
print('Numpy_Array2',np /3)
print('Numpy_Array2',np)

форма()

Возвращает кортеж с указанием индексов и количества элементов (т.е. количества строк и столбцов)

import numpy as np
lst1 = [1,2,3,4,5,6]
list1 = np.array(lst1)
np.shape(lst1)

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

Категории функций Numpy

  1. Функции Numpy для создания или инициализации массива
  • массивы( )
  • глаз( )
  • те( )
  • Нули( )
  • полный( )

массивы()

Массив — это основная структура данных библиотеки Numpy. Массив Numpy представляет собой сетку значений одного типа и проиндексированных.

import numpy as np
numpy_array = np.array([1,2,3,4,5,6])
print(type(numpy))
print(numpy_array)

глаз()

Берет квадратную матрицу и инициализирует =›

  • все диагональные позиции до 1
  • все недиагональные позиции в 0

Синтаксис =› np.eye(строки/столбцы,dtype)

identity_matrix1 = np.eye((1,2),dtype=int)
identity_matrix2 = np.eye(2)
identity_matrix3 = np.eye(3,dtype=float)
identity_matrix4 = np.eye(5,dtype=int)
print(identity_matrix1,'n')
print(identity_matrix2,'n')
print(identity_matrix3,'n')
print(identity_matrix4,'n')

единицы()

Возвращает единицы как элемент или значение списка массивов

Синтаксис => np.ones(shape,dtype) dtype может быть либо с плавающей запятой, либо с целым числом, и по умолчанию он с плавающей запятой.

ones_array1 = np.ones((2)) # By default data type is float64 
ones_array2 = np.ones((2,3),dtype=np.int64)
ones_array3 = np.ones((2,4,2),dtype=  np.int32)
ones_array4 = np.ones((2,4,3,2),dtype=  np.int32)

print('ones_array1 = ',ones_array1) 
print('ones_array1 dataType: ',ones_array1.dtype) # ones_array1 dataType:  float64
print('ones_array1 dimension: ',ones_array1.ndim,"\n") # ones_array1 dimension:  1 

print('ones_array2 = ',ones_array2)
print('ones_array2 dataType: ',ones_array2.dtype) # ones_array2 dataType:  int64
print('ones_array2 dimension: ', ones_array2.ndim,"\n") # ones_array2 dimension:  2 

print('ones_array3 = ',ones_array3)
print('ones_array3 dataType: ',ones_array3.dtype) # ones_array3 dataType:  int32
print('ones_array3 dimension: ',ones_array3.ndim) # ones_array3 dimension:  3

print('ones_array4 = ',ones_array4) # Retturns 4 dimension of array 
print('ones_array4 dataType: ',ones_array4.dtype) # Retturns ones_array4 dataType:  int32
print('ones_array4 dimension: ',ones_array4.ndim)# ones_array4 dimension:  4

нули()

Возвращает нули в качестве элемента или значения списка массивов по заданной форме

Синтаксис => np.zeros(shape,dtype) dtype может быть либо с плавающей запятой, либо с целым числом, и по умолчанию он с плавающей запятой.

import numpy as np
zero_array1 = np.zeros((2,3))
zero_array2 = np.zeros((2))
zero_array3 = np.zeros((2,4),dtype=int)
zero_array4 = np.zeros((2,4),dtype=np.int)
print('zeros_array1  :  ',zero_array1)
print('zeros_array1 dimension: ',zero_array1.ndim)
print('zeros_array1 dataType: ',zero_array1.dtype,"\n")

print('zeros_array2 : ',zero_array2)
print('zeros_array2 dimension: ',zero_array2.ndim)
print('zeros_array2 dataType: ',zero_array2.dtype,"\n")

print('zeros_array3 : ',zero_array3)
print('zeros_array3 dimension: ',zero_array3.ndim)
print('zeros_array3 dataType: ',zero_array3.dtype,"\n")

print('zero_array4 : ',zero_array4)
print('zeros_array4 dimension: ',zero_array4.ndim)
print('zeros_array4 dataType: ',zero_array4.dtype,"\n")

полный()

Возвращает значение по умолчанию, переданное как элемент или значение списка массивов

синтаксис np.full (форма, значение по умолчанию)

full_array1 = np.full((5),56)
full_array2= np.full((5),56)
full_array3 = np.full((5),56)
full_array4 = np.full((3,5,3),56)
print('full_array1  :  ',full_array1)
print('full_array1 dimension: ',full_array1.ndim)
print('full_array1 dataType: ',full_array1.dtype,"\n")

print('full_array2 : ',full_array2)
print('full_array2 dimension: ',full_array2.ndim)
print('full_array2 dataType: ',full_array2.dtype,"\n")

print('full_array3 : ',full_array3)
print('full_array3 dimension: ',full_array3.ndim)
print('full_array3 dataType: ',full_array3.dtype,"\n")

print('full_array4 : ',full_array4)
print('full_array4 dimension: ',full_array4.ndim)
print('full_array4 dataType: ',full_array4.dtype,"\n")

2. Функции массивов с числовыми диапазонами

  • упорядочить ( )
  • LineSpace()
  • logSpace()

Они возвращают массив со значениями заданного диапазона и заданного значения по умолчанию или заданного типа данных.

упорядочить()

arange() Создает одномерный массив с равномерно заданным диапазоном чисел в течение заданного интервала или интервала по умолчанию (т.е. 1).

Синтаксис =› упорядочивать (индекс начала, индекс остановки, размер шага, тип dtype)

  • StartIndex: нижняя граница.
  • StopIndex: верхняя граница
  • размер шага: приращение, значение приращения по умолчанию равно 1. Это необязательно
import numpy as np 
arr_range1 = np.arange(50) # Returns 0 to 49 integers
arr_range2 = np.arange(50, dtype=int) # Returns 0 to 49 integers
arr_range3 = np.arange(1,50, dtype=float) # Returns 1 to 49 floats
arr_range4 = np.arange(1,50,2) # Returns 1 to 49 integers incremented by 2
arr_range5 = np.arange(1,50,2, dtype=float) # Returns 1 to 49 floats incremented by 2

print('array_range1 = ',arr_range1,"\n")
print('array_range2 = ',arr_range2,"\n")
print('array_range3 = ',arr_range3,"\n")
print('array_range4 = ',arr_range4,"\n")
print('array_range5 = ',arr_range5,"\n")

строчный интервал()

Синтаксис => linespace(startIndex, stopIndex, num, endpoint, restep, dtype)

  • StartIndex: нижняя граница
  • StopIndex: верхняя граница
  • num: количество требуемых значений в массиве, это необязательно, по умолчанию 50
  • конечная точка: если включен индекс истинной остановки, иначе, если индекс ложной остановки не включен, это необязательно. Принять логическое значение (т.е. True или False)
  • retsep (т.е. размер шага): разница между значениями, если значения True видны, иначе не видны по умолчанию False, это необязательно
  • dtype: принимает тип данных float или int. Тип данных по умолчанию — float

Возвращает числа, равномерно распределенные по заданному интервалу.

linespace1_arr = np.linspace(1,50) # Returns 1 to 50 floats
linespace2_arr = np.linspace(1,50,5) # Returns 5 floats within the range 1 to 50  
linespace3_arr = np.linspace(1,50,endpoint=True)  # Returns 1 to 50 floats and includes StopIndex
linespace4_arr = np.linspace(1,50,endpoint=False) # Returns 1 to 49 floats and Does not return stopIndex(i.e 50)  
linespace5_arr = np.linspace(1,50,retstep=False)   # Returns 1 to 50 floatsand and Does not return step size
linespace6_arr = np.linspace(1,50,num=2,endpoint=True) # Returns 2 floats 1 and 50
linespace7_arr = np.linspace(1,50,num=2,retstep=True) # Returns 2 floats 1 and 50 and a step size. By default 3rd arguments(i.e a number) is reads as 'num=' value   
linespace8_arr = np.linspace(1,50,2,endpoint=True,retstep=True,dtype=int) # Returns 1 to 50 Integers, including StopIndex and step size
print('linespace1_array = ',linespace1_arr,"\n")
print('linespace2_array = ',linespace2_arr,"\n")
print('linespace3_array = ',linespace3_arr,"\n")
print('linespace4_array = ',linespace4_arr,"\n")
print('linespace5_array = ',linespace5_arr,"\n")
print('linespace6_array = ',linespace6_arr,"\n")
print('linespace7_array = ',linespace7_arr,"\n")
print('linespace8_array = ',linespace8_arr,"\n")

logspace()

Возвращает числа, равномерно распределенные по логарифмической шкале.

Синтаксис => logspace(startIndex, stopIndex, num, endpoint, base, dtype)

  • StartIndex: нижняя граница
  • StopIndex: верхняя граница
  • num: количество обязательных значений в массиве, необязательно, по умолчанию 50
  • конечная точка: если включен индекс истинной остановки, иначе, если индекс ложной остановки не включен, это необязательно. Принять логическое значение (т.е. True или False)
  • база: база значения журнала, по умолчанию используется база 10. это необязательно.
  • dtype: принимает тип данных float или int
logspace1_arr = np.logspace(1,2) 
logspace2_arr = np.logspace(1,5,num=5,base=10) 
logspace3_arr = np.logspace(1,5,num=2,endpoint=True)  
logspace4_arr = np.logspace(1,5,num=2,endpoint=False) 
logspace5_arr = np.logspace(1,5,num=2,base=2)   
logspace6_arr = np.logspace(1,50,num=2,endpoint=True) 
logspace7_arr = np.logspace(1,2,2,base=16) 
logspace8_arr = np.logspace(1,2,2,endpoint=True,base=16,dtype=int) 

print('logspace1_array = ',logspace1_arr,"\n")# Return 50 floats spaced evenly on a log scale of base 10.
print('logspace2_array = ',logspace2_arr,"\n")# Return 5 floats spaced evenly on a log scale of base 10.
print('logspace3_array = ',logspace3_arr,"\n")# Returns 1 to 50 floats and includes StopIndex
print('logspace4_array = ',logspace4_arr,"\n")# Returns 1 to 49 floats and Does not return stopIndex(i.e 50)
print('logspace5_array = ',logspace5_arr,"\n")# Returns 1 to 50 floatsand and Does not return step size
print('logspace6_array = ',logspace6_arr,"\n")# Returns 2 floats 1 and 50
print('logspace7_array = ',logspace7_arr,"\n")# Returns 2 floats 1 and 50 and. By default 3rd arguments(i.e a number) is reads as 'num=' value
print('logspace8_array = ',logspace8_arr,"\n")# Returns 1 to 50 Integers, including StopIndex and step size

3. Функции Numpy для преобразования

Массивы с существующими типами данных

  • массив( )
  • из буфера()
  • изменить форму ( )

массив( )

Функция asarray() используется, когда мы хотим преобразовать ввод в массив. Входными данными могут быть списки, списки кортежей, кортежи, кортежи кортежей, кортежи списков и массивы.

Синтаксис =› asarray(input,dtype,order) порядок: основной ряд (**C**) или основной столбец (**F**)

array = [[10,20,30,40],[50,60,70,80]]
as_array = np.asarray(array,dtype=float,order='F')
print(as_array)
print(type(as_array))

из буфера()

frombuffer создаст массив с заданным типом данных заданной длины из заданной позиции

Синтаксис =›frombuffer(buffer, dtype, count, offset)

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

buff = np.frombuffer(b'Arewa Data  Science Academy',dtype='S1',count=-1,offset=5)
print(buff)

4. Агрегированные функции Numpy
1. sum()
2. prod()
3. mean()
4. median()
5. std ()
6. var()
7. amin()
8. amax()
9. all()
10. any()

сумма()

Функция sum() возвращает сумму всех элементов массива.

import numpy as np
arr11 = np.array([1,2,3,4,5,6,7,8])
arr1 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
print('arr11 : ',arr11.sum()) # Return the sum of all elements 
print('arr1 : ',arr1.sum()) # Return the sum of all elements

print('arr1-> axis=0 : ',np.sum(arr1, axis=0)) # Return an array list summing the corresponding columns
print('arr1-> axis=1 : ',np.sum(arr1,axis=1)) # Return an array list summing the rows

продукт()

Функция prod() возвращает произведение всех элементов заданного массива.

Синтаксис =› numpy.prod(array_list,axis=None,dtype=None,out=None, keepdims=‹нет значения›,*,где=‹нет значения›)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
prod1 = np.prod(arr1)
prod2 = np.prod(arr1,axis=0)

print(prod1)
print(prod2,'\n')

# 2D Array
arr2 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
prod4 = np.prod(arr2)
prod5 = np.prod(arr2,axis=0) # Return an array list product of the corresponding columns
prod6 = np.prod(arr2,axis=1) # Return an array list  product of each rows

print(prod4)
print(prod5)
print(prod6,'\n')

arr3 =np.prod(np.arange(1,11))
print(arr3)

arr4 = np.array([np.nan, 3, 4])
prod_result = np.prod(arr4, where=[False,True,True])
print(prod_result)

среднее()

Функция mean() возвращает среднее значение элементов массива.

Синтаксис =› numpy.mean(array_list,axis=None,dtype=None,out=None, keepdims=‹нет значения›,*,где=‹нет значения›)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5,6,7,8])
average1 = np.mean(arr1)


print(average1,'\n')

# 2D Array
arr2 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
average4 = np.mean(arr2)
average5 = np.mean(arr2,axis=0)

print(average4)
print(average5,'\n')

медиана()

Функция median() возвращает средний элемент отсортированного массива. Если 2 элемента связаны посередине, мы суммируем 2 элемента и делим на 2.

Синтаксис =› numpy.median(array_list,axis=None,dtype=None)

import numpy as np
arr1 = np.array([1,2,3,4,5,6,7,8])
middle1 = np.median(arr1)

print(middle1,'\n')

arr2 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
middle3 = np.median(arr2)
middle4 = np.median(arr2,axis=0)
print(middle3)
print(middle4,'\n')

var()

Дисперсия измеряет разброс распределения. шаги для ручного расчета номеров отклонений

1. вычислить среднее всех чисел

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

3. вычислить среднее значение этих квадратов разницы

Синтаксис =›numpy.var(array_list,axis=None,dtype=None,out=None,ddof=0,keepdims=‹нет значения›,*,где=‹нет значения›)

import numpy as np
arr = np.array([1,2,3,4,5])
var_result = np.var(arr)
print(var_result)

стандартный()

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

Синтаксис =› numpy.std(array_list,axis=None,dtype=None,out=None,ddof=0,keepdims=‹нет значения›,*,где=‹нет значения›)

import numpy as np
arr = np.array([100,200,300,400,500])
std_result = np.std(arr)
print(round(std_result,4))

амин()

Функция amin() возвращает минимальный элемент массива

Синтаксис =› numpy.amin(array_list,axis=None,dtype=None,out=None,keepdims=‹нет значения›, initial=‹нет значения›, где=‹нет значения›)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
minimum1 = np.amin(arr1)

print(minimum1,'\n')

# 2D Array
arr2 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
minimum4 = np.amin(arr2)
minimum5 = np.amin(arr2,axis=0) # Return an array list product of the corresponding columns
minimum6 = np.amin(arr2,axis=1) # Return an array list  product of each rows

print(minimum4)
print(minimum5)
print(minimum6,'\n')

arr3 =np.amin(np.arange(1,11))
print(arr3)

arr4 = np.array([np.nan, 2, 3, 4])
min_result = np.amin(arr4, initial=4 ,where=[False,True,True,True])
print(int(min_result))

амакс()

Функция amax() возвращает максимальный элемент массива

Синтаксис **-›** numpy.amax(array_list,axis=None,dtype=None,out=None,keepdims=‹нет значения›, initial=‹нет значения›, где=‹нет ценить>)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
maximum1 = np.amax(arr1)

print(maximum1,'\n')

# 2D Array
arr2 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
maximum4 = np.amax(arr2)
maximum5 = np.amax(arr2,axis=0) # Return an array list product of the corresponding columns
maximum6 = np.amax(arr2,axis=1) # Return an array list  product of each rows

print(maximum4)
print(maximum5)
print(maximum6,'\n')

arr3 =np.max(np.arange(1,11))
print(arr3)

arr4 = np.array([np.nan, 2, 3, 4])
max_result = np.amax(arr4, initial=4 ,where=[False,True,True,True])
print(int(max_result))

все()

Функция all() возвращает True, если все элементы массива отличны от нуля, и False, если какой-либо элемент равен нулю.

Синтаксис =› numpy.all(array_list,axis=None,dtype=None,out=None,keepdims=‹нет значения›, * ,где=‹нет значения›)

import numpy as np
# 1D Array
arr1 = np.array([0,1,2,3,4,5])
all1 = np.all(arr1)

print(all1,'\n')

# 2D Array
arr2 = np.array([[0,1,2,3,4,5],[6,7,8,9,10,11]])
all4 = np.all(arr2)
all5 = np.all(arr2,axis=0) # Return an array list product of the corresponding columns
all6 = np.all(arr2,axis=1) # Return an array list  product of each rows

print(all4)
print(all5)
print(all6,'\n')

arr3 =np.all(np.arange(1,11))
print(arr3)

любой( )

Функция any() возвращает True, если какой-либо элемент массива отличен от нуля, и False, если какой-либо элемент равен нулю.

Синтаксис =› numpy.all(array_list,axis=None,dtype=None,out=None,keepdims=‹нет значения›, * ,где=‹нет значения›)

import numpy as np
# 1D Array
arr1 = np.array([0,1,2,3,4,5])
any1 = np.any(arr1)
print(any1,'\n')

arr = np.array([0,0,0])
any2 = np.any(arr)
print(any2,'\n')

# 2D Array
arr2 = np.array([[0,1,2,3,4,5],[6,7,8,9,10,11]])
any4 = np.any(arr2)
any5 = np.any(arr2,axis=0) # Return an array list boolean of the corresponding columns
any6 = np.any(arr2,axis=1) # Return an array list boolean of each rows

print(any4)
print(any5)
print(any6,'\n')

arr3 =np.any(np.zeros((1,11),dtype=int))
print(arr3)

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

1. изменить форму ( )

2. транспонировать()

3. сортировать( )

4. сгладить()

5. распутать ( )

изменить форму()

форма массива хранит количество измерений или осей и количество элементов в каждом измерении. форма возвращает кортеж

Функция reshape() изменяет форму массива. Он не изменяет и не заменяет какой-либо элемент, изменяется только позиция элемента.

Синтаксис =› numpy.reshape(array_list,newshape, order='C')

import numpy as np
# 1D Array
arr1 = np.array([0,1,2,3,4,5])
reshape1 = np.reshape(arr1,(2,3))

print(reshape1,'\n')

# 2D Array
arr2 = np.array([[0,1,2,3,4,5],[6,7,8,9,10,11]])
reshape2 = np.reshape(arr2,(3,4))

print(reshape2,'\n')

arr3 = np.arange(1,11)
reshape3 = np.reshape(arr3,(5,2))

print(reshape3)

транспонировать ( )

Функция transpose() используется для реверсирования осей массива.

Синтаксис =› numpy.transpose(array_list, axes=None)

import numpy as np
# 1D Array
arr1 = np.array([0,1,2,3,4,5])
arr_transpose1 = np.transpose(arr1)
print(arr_transpose1,'\n')

# 2D Array
arr2 = np.array([[0,1,2,3,4,5],[6,7,8,9,10,11]])
arr_transpose2 = np.transpose(arr2)
print(arr_transpose2,'\n')

arr3 = np.arange(1,11)
reshape = np.reshape(arr3,(5,2))
arr_transpose3 = np.transpose(reshape)
print(arr_transpose3)

сортировать()

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

Синтаксис =› numpy.sort(array_list, axis=1, kind=None, order=None)

import numpy as np
# 1D Array
arr1 = np.array([0,3,4,1,2,5])
sorted_arr1 = np.sort(arr1)

print(sorted_arr1,'\n')

# 2D Array
arr2 = np.array([[0,1,2,10,11],[6,7,8,9,3,4,5]], dtype=object)
sorted_arr2 = np.sort(arr2)

print(sorted_arr2,'\n')

dtype =[("smartPhone","S10"),
        ("year_of_production",int),
        ("price",float)
]

product_price = [
    ("Tecno",100.5,2019),
    ("Gionee",120.5,2018),
    ("infinix",120.0,2010)
]

product_info = np.array(product_price,dtype=dtype)
result = np.sort(product_info,order=["year_of_production","price"])
print(result)

сгладить()

Функция flatten() является методом ndarray. Используется для сворачивания массива в одномерный массив.

Синтаксис =› ndarray.flatten(axis=1, kind=None, order=None)

import numpy as np
# 1D Array
arr1 = np.array([0,3,4,1,2,5])
flatten_arr1 = arr1.flatten()

print(flatten_arr1,'\n')

# 2D Array
arr2 = np.array([[0,1,2],[6,7,8]])
flatten_arr2 = arr2.flatten(order='C') 
flatten_arr3 = arr2.flatten(order='F')

print(flatten_arr2) # Return a flatten array list of each rows both rows
print(flatten_arr3,'\n') # Return a flatten array list of each corresponding colums

распутывать()

Функция ravel() принимает массив и возвращает одномерный массив

Синтаксис =› numpy.ravel(array_list, axis=1, kind=None, order=None)

import numpy as np
# 1D Array
arr1 = np.array([0,3,4,1,2,5])
raveled_arr1 = np.ravel(arr1)
print(raveled_arr1,'\n')

# 2D Array
arr2 = np.array([[0,1,2],[6,7,8]])
raveled_arr2 = np.ravel(arr2,order='C') 
raveled_arr3 = np.ravel(arr2,order='F')

print(raveled_arr2) # Return a raveled array list of each rows both rows
print(raveled_arr3,'\n') # Return a raveled array list of each corresponding colums

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

1. добавить()

2. вычесть ( )

3. умножить ( )

4. разделить( )

добавить()

Оператор «-» или функция add() используется для добавления двух или более массивов одинакового размера.

Синтаксис =› numpy.add(массив1, массив2 )

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([6,7,8,9,10])
sum1 = arr1 + arr2
sum2 = np.add(arr1,arr2)
print(sum1)
print(sum2,'\n')

# 2D Array
arr3 = np.array([[0,1,2],[6,7,8]])
arr4 = np.array([[3,4,5],[9,10,11]])
sum3 = arr3 + arr4 # Return array list of sum  each rows both rows
sum4 = np.add(arr4,arr3)
print(sum3) # Return an array lists of sum each corresponding colums
print(sum4,'\n')

вычитание()

Оператор ‘-’ или функция subtract() используется для вычитания двух или более массивов одинакового размера.

Синтаксис =› numpy.subtract(массив1, массив2)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([6,7,8,9,10])
sub1 = arr2 - arr1
sub2 = np.subtract(arr1,arr2)
print(sub1)
print(sub2,'\n')

# 2D Array
arr3 = np.array([[0,1,2],[6,7,8]])
arr4 = np.array([[3,4,5],[9,10,11]])
sub3 = arr3 - arr4 # Return array list of sum  each rows both rows
sub4 = np.subtract(arr4,arr3)
print(sub3) # Return an array lists of sum each corresponding colums
print(sub4,'\n')

умножить()

Оператор ‘*’ или функцияmulti() возвращает произведение двух массивов одинакового размера.

Синтаксис =› numpy.multiply(массив1, массив2)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([6,7,8,9,10])
product1 = arr2 * arr1
product2 = np.multiply(arr1,arr2)
print(product1)
print(product2,'\n')

# 2D Array
arr3 = np.array([[0,1,2],[6,7,8]])
arr4 = np.array([[3,4,5],[9,10,11]])
product3 = arr3 * arr4 # Return array list of product each rows both rows
product4 = np.multiply(arr4,arr3)
print(product3) # Return an array lists of product each corresponding colums
print(product4,'\n')

разделить()

Оператор ‘/’ или функция Division() возвращает частное двух массивов одинакового размера, выполняя поэлементное деление.

Синтаксис =› numpy.divide(массив1, массив2 )

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([6,7,8,9,10])
div1 = arr2 * arr1
div2 = np.multiply(arr1,arr2)
print(div1)
print(div2,'\n')

# 2D Array
arr3 = np.array([[0,1,2],[6,7,8]])
arr4 = np.array([[3,4,5],[9,10,11]])
div3 = arr3 * arr4 # Return array list of qoutient each rows both rows
div4 = np.multiply(arr4,arr3)
print(div3) # Return an array lists of qoutient each corresponding colums
print(div4,'\n')

Массив Numpy для объединения и разделения

1. объединить ()

2. стек ()

3. противстек()

4. стек()

5. разделить()

объединить()

Функция concatenate() объединяет два или более массивов в один массив

Синтаксис =› numpy.concatenate((array_list1,array_list2,array_list3,…),axis=0)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([6,7,8,9,10])
concateante = np.concatenate((arr1,arr2))
print(concateante,'\n')

# 2D Array
arr3 = np.array([[0,1,2],[6,7,8]])
arr4 = np.array([[3,4,5],[9,10,11]])
concateante2 = np.concatenate((arr3,arr4))
print(concateante2,'\n')

стек()

Функция stack() объединяет 1D-массивы в один 2D-массив и объединяет 2D-массивы в один 3D-массив. Массив должен быть одинаковой формы

Синтаксис =› numpy.stack((array_list1,array_list2,array_list3,…),axis=0)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([6,7,8,9,10])
stack = np.stack((arr1,arr2))
print(stack,'\n')

# 2D Array
arr3 = np.array([[0,1,2],[6,7,8]])
arr4 = np.array([[3,4,5],[9,10,11]])
stack2 = np.stack((arr3,arr4))
print(stack2,'\n')

противстек()

Функция vstack() объединяет два массива или массива в один массив по вертикали (построчно). Массив должен быть одинаковой формы

Синтаксис => numpy.vstack((массив_список1,массив_список2,массив_список3,…),ось=0)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([6,7,8,9,10])
vstack = np.vstack((arr1,arr2))
print(vstack,'\n')

# 2D Array
arr3 = np.array([[0,1,2],[6,7,8]])
arr4 = np.array([[3,4,5],[9,10,11]])
vstack2 = np.vstack((arr3,arr4))
print(vstack2,'\n')

hstack()

Функция hstack() объединяет два массива или массива в один массив по горизонтали (по столбцам). Массив должен быть одинаковой формы

Синтаксис =› np.hstack((array_list1,array_list2,array_list3,…),axis=0)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([6,7,8,9,10])
hstack = np.hstack((arr1,arr2))
print(hstack,'\n')

# 2D Array
arr3 = np.array([[0,1,2],[6,7,8]])
arr4 = np.array([[3,4,5],[9,10,11]])
hstack2 = np.hstack((arr3,arr4))
print(hstack2,'\n')

разделить()

Функции split() разбивают массив на несколько представлений подмассивов.

Синтаксис =› numpy.split(aarray_list1,section_or_indices,axis=0)

import numpy as np
# 1D Array
arr1 = np.array([1,2,3,4,5,6])
split = np.split(arr1,2)
split2 = np.split(arr1,3)
print(split,'\n')
print(split2,'\n')

# 2D Array
arr3 = np.array([[0,1,2],[6,7,8]])
split3 = np.split(arr3,1)
split4 = np.split(arr3,2)
print(split3)
print(split4,'\n')

Трансляция

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

arr1 = np.array([1,2,3,4,5])
add_broadcast = arr1 + 2 
sub_broadcast = arr1 - 2
multi_broadcast = arr1 * 2
div_broadcast = arr1 / 2
print(add_broadcast)
print(sub_broadcast)
print(multi_broadcast)
print(div_broadcast)

# 2D Array
arr2  = np.array([[0,1,2],[6,7,8]])
add2_broadcast = arr2 + 2 
sub2_broadcast = arr2 - 2
multi2_broadcast = arr2 * 2
div2_broadcast = arr2 / 2
print(add2_broadcast)
print(sub2_broadcast)
print(multi2_broadcast)
print(div2_broadcast)

Индексирование и нарезка массива

1. индексирование

2. Нарезка

3. фановое индексирование

4. Логическое индексирование

Индексирование

мы используем квадратную скобку [] для индексации элементов. индекс начинается с нуля (0) и заканчивается на (len (array_list) — 1) или -1

import numpy as np
numpy_index1D = np.array([1,2,3,4,5,6,7,8,9,10])
print(numpy_index1D[0]) # Returns 1st elements or data value
print(numpy_index1D[1]) # Returns second element or data value
print(numpy_index1D[-1]) # Returns last element or data value
print(numpy_index1D.ndim,"\n") # Returns dimension

numpy_index2D = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])
print(numpy_index2D[0]) # Returns first row [1,2,3,4,5]
print(numpy_index2D[-1]) # Returns last row [11,12,13,14,15]
print(numpy_index2D[1,1])# Returns second row and second column element 7
print(numpy_index2D.ndim,"\n") # Returns dimension

numpy_index3D = np.array([[[1,2,3,4,5],[6,7,8,9,10]],[[11,12,13,14,15],[16,17,18,19,20]]])
print(numpy_index3D[0])  # Returns first row of 3rd dimension [[1,2,3,4,5],[6,7,8,9,10]]
print(numpy_index3D[1])  # Returns second row of 3rd dimension [[11,12,13,14,15],[16,17,18,19,20]]
print(numpy_index3D[-1]) # Returns last row of 3rd dimension [[11,12,13,14,15],[16,17,18,19,20]]
print(numpy_index3D[1,1])# Returns second row of 3rd dimension [16,17,18,19,20]]
print(numpy_index3D.ndim,"\n") # Returns Dimension

***Разрез***

нарезка — это процесс извлечения элементов из массива numpy с использованием диапазона позиций индекса.

1. Используйте array_list[a:b:c] для нарезки одномерного массива, где a,b — это индексы Start, Stop (исключительно) и c в качестве приращения.

2. Используйте array_list[a:b:c, d,e,f, …] для нарезки многомерного массива.

3. Используйте array_list[:] или array_list[0:-1] для выбора всех элементов на заданной оси.

4. Используйте array_list[:b] для выбора всех элементов, начиная с индекса 0 и заканчивая индексом b.

5. Используйте array_list[a:] для выбора всех элементов, начиная с индекса до последнего индекса.

import numpy as np 
array_list = np.arange(1,11)
print('array_list = ',array_list)
print('array_list[3:6] = ',array_list[3:6])
print('array_list[1:] = ',array_list[1:])
print('array_list[:] = ',array_list[:])
print('array_list[:5] = ',array_list[:5])
print('array_list[7:-1] = ',array_list[7:-1])
print('array_list[0:6:3] = ',array_list[0:6:3])
print('array_list[::-1] = ',array_list[::-1])
print('array_list datatype : ',array_list.ndim,"\n")

numpy_slice2D = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])
print('numpy_slice2D[0] = ',numpy_slice2D[0]) 
print('numpy_slice2D[0:2] = ',numpy_slice2D[0:2]) 
print('numpy_slice2D[1:2] = ',numpy_slice2D[1:2]) 
print('numpy_slice2D[0] = ',numpy_slice2D[:]) 
print('numpy_slice2D[:, 1] = ',numpy_slice2D[:, 1]) 
print('numpy_slice2D[0:2, :3 ] = ',numpy_slice2D[0:2, :3 ]) 
print('numpy_slice2D[:,:] = ',numpy_slice2D[:, :]) # Returns [[1 2 3] [6 7 8]]
print(numpy_slice2D.ndim,"\n","\n") # Returns dimension

Функция индексации

Fancing Indexing — это процесс передачи массива индексов для одновременного доступа к нескольким элементам массива.

import numpy as np
arr = np.arange(1,11)
print(arr)

arr_list = np.array([1,2])
print(arr[arr_list])

Булево индексирование

С логическим индексированием Numpy использует массив логических значений для доступа к элементам. Будет возвращен только индекс, который имеет значение True.

import numpy as np
arr1 = np.arange(1,5)
arr2 = np.array([True,False,True,False])
arr3 = arr1[arr2]
print("arr1 : ",arr1)
print("arr2 : ",arr2)
print("arr3 : ",arr3)

arr11 = np.arange(1,9)
arr22 = arr11 <= 5
arr33 = arr11 == 4
arr44 = arr11 > 5

arr55 = arr11[arr22]
arr66 = arr11[arr33]
arr77 = arr11[arr44]
print("arr11 : ",arr11)
print("arr22 : ",arr22)
print("arr33 : ",arr33)
print("arr44 : ",arr44,'\n')

print("arr55 : ",arr55)
print("arr66 : ",arr66)
print("arr33 : ",arr77,'\n')

копировать()

Когда массив срезается, возвращаемый подмассив является представлением исходного массива. Если в подмассив были внесены какие-либо обновления, они отражаются обратно в исходный массив. Но чтобы избежать отражения, мы воспользуемся функцией copy().

import numpy as np
#  the View Original concept
arr1 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
arr2 = arr1[:,:3]
arr2[1,1] = 4

print(arr2)
print(arr3)
print(arr1,'\n')


# copy( ) concept
arr11 = np.array([[1,2,3,4],[5,6,7,8]])
arr22 = arr1[:,:3].copy()
arr22[1,1] = 4

print(arr11)
print(arr22)