• NumPy — это фундаментальный пакет для научных вычислений на Python. Или вы можете сказать, что это универсальный стандарт для работы с числовыми данными в Python.
  • Библиотека NumPy содержит структуры данных многомерных массивов и матриц.
  • Он предоставляет ndarray, однородный объект n-мерного массива, методы для эффективной работы с ним.
  • Его можно использовать для выполнения широкого спектра математических операций с массивами.
  • Он добавляет в Python мощные структуры данных, которые гарантируют эффективные вычисления с массивами и матрицами.

Разница между списком Python и массивом NumPy?

  • Массивы NumPy работают быстрее и компактнее, чем списки Python.
  • К массивам NumPy предъявляются строгие требования к однородности объектов.
  • Например, массив строк NumPy может содержать только строки и не содержать других типов данных, но список Python может содержать смесь строк, чисел, логических значений и других объектов.
  • Массив NumPy потребляет меньше памяти и удобен в использовании, т. е. использует гораздо меньше памяти для хранения данных, поскольку предоставляет механизм указания типов данных. Это позволяет еще больше оптимизировать код.

Существует 6 общих механизмов создания массивов:

  1. Преобразование из других структур Python (например, списков и кортежей)
  2. Встроенные функции создания массива NumPy (например, диапазон, единицы, нули и т. д.)
  3. Репликация, объединение или изменение существующих массивов
  4. Чтение массивов с диска в стандартных или пользовательских форматах.
  5. Создание массивов из необработанных байтов с помощью строк или буферов.
  6. Использование специальных библиотечных функций (например, случайных)

Несколько способов создания массивов NumPy

  1. np.array()
  2. np.zeros()
  3. np.ones()
  4. np.empty()
  5. np.arange()
  6. НП.linspace()
  7. np.identity() или np.eye()
# import the module
import numpy as np

1. np.array()

# Convert a list to array
my_list = [1,2,3666666,4,5]

# We can pass a list and specify a datatype (optional) in which we want to store the value in array
arr_1d = np.array(my_list, np.int32)  
array([      1,       2, 3666666,       4,       5], dtype=int32)
# Data type of the array
arr_1d.dtype
dtype('int32')
# Dimension of the array
arr_1d.shape # 1-Dimension array having 5 elements
(5,)
# new array
arr_2d = np.array([[1,2,3],[4,5,6]])
# Dimension of the array
arr_2d.shape # Rows = 2 & Cols = 3 --> 2 Dimension
(2, 3)
# Change shape
arr_2d.reshape(3,2)  # we have to maintain the product of original array i.e. 2x3 = 6
array([[1, 2],
       [3, 4],
       [5, 6]])
# Change shape
arr_2d.reshape(1,6) # Product is 1x6 = 6
array([[1, 2, 3, 4, 5, 6]])

Чтобы визуализировать разницу между 1D и 2D

  • 1D будет иметь одну открывающую квадратную скобку и одну закрывающую квадратную скобку.
  • 2D будет иметь две открывающие квадратные скобки и две закрывающие квадратные скобки.
# Convert a tuple to array
arr_from_tup = np.array((3.4,4.5,5.3,6.6))
# Shape of array
arr_from_tup.shape
(4,)
# data Type of array
arr_from_tup.dtype
dtype('float64')

2. np.arange()

Мы можем создать массив с диапазоном элементов

# Create an array from 1 to 10
np.arange(start=1, stop=10)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
# Create an array from 1 to 10 with step-size=2
np.arange(start=1, stop=10, step=2)
array([1, 3, 5, 7, 9])
# Right now its 1D
np.arange(1,10,2).shape
(5,)
# Convert to 2D
np.arange(1,10,2).reshape(5,1).shape
(5, 1)
np.arange(50,1,-1)
array([50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34,
       33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
       16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2])
np.arange(1,18,3)
np.arange(1,18,3).shape
np.arange(1,18,3).reshape(2,3)
array([[ 1,  4,  7],
       [10, 13, 16]])

3. np.linspace()

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

# linspace -- equally spaced elements

np.linspace(1,20,30)  # 30 number of elements between 1 to 20 (including 1 and 20 both)
array([ 1.        ,  1.65517241,  2.31034483,  2.96551724,  3.62068966,
        4.27586207,  4.93103448,  5.5862069 ,  6.24137931,  6.89655172,
        7.55172414,  8.20689655,  8.86206897,  9.51724138, 10.17241379,
       10.82758621, 11.48275862, 12.13793103, 12.79310345, 13.44827586,
       14.10344828, 14.75862069, 15.4137931 , 16.06896552, 16.72413793,
       17.37931034, 18.03448276, 18.68965517, 19.34482759, 20.        ])
# reshaping
np.linspace(1,20,30).reshape(3,10)
array([[ 1.        ,  1.65517241,  2.31034483,  2.96551724,  3.62068966,
         4.27586207,  4.93103448,  5.5862069 ,  6.24137931,  6.89655172],
       [ 7.55172414,  8.20689655,  8.86206897,  9.51724138, 10.17241379,
        10.82758621, 11.48275862, 12.13793103, 12.79310345, 13.44827586],
       [14.10344828, 14.75862069, 15.4137931 , 16.06896552, 16.72413793,
        17.37931034, 18.03448276, 18.68965517, 19.34482759, 20.        ]])

4. np.zeros()

Мы можем создать массив, заполненный нулями.

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

5. np.ones()

Мы можем создать массив, заполненный единицами

# ones
np.ones(3)
array([1., 1., 1.])
# ones
np.ones((3,4))
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])
# ones
np.ones((5,2,8))  
# 2,8 denotes the inner most array of 2 rows and 8 columns
# and there are 5 sets of 2,8 arrays making it 3D array
array([[[1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1.]],

       [[1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1.]],

       [[1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1.]],

       [[1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1.]],

       [[1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1.]]])

6. np.empty()

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

Причина использования empty вместо zeros — скорость — просто не забудьте потом заполнить каждый элемент!

# empty
np.empty((3,7))
array([[0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0.]])

7. np.identity()

Верните массив идентификаторов.

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

# identity matrix of 4x4 shape
np.identity(4)
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

Добавление, удаление и сортировка элементов

  1. np.sort()
  2. np.concatenate()
arr = np.array([4,3,6,7,1,9])
print(arr)
np.sort(arr)
[4 3 6 7 1 9]
array([1, 3, 4, 6, 7, 9])
# Concatenating same size of two array
a = np.array([1,2,3,4])
b = np.array([5,6,7,8])
np.concatenate((a,b))
array([1, 2, 3, 4, 5, 6, 7, 8])
# Concatenating different sizes of array by axis=0
a = np.array([[1,2], [3,4]])
b = np.array([[5,6]])
np.concatenate((a,b), axis=0)
array([[1, 2],
       [3, 4],
       [5, 6]])
# Concatenating different sizes of array by axis=1
a = np.array([[1,2], [3,4]])
b = np.array([[5,6]])
np.concatenate((a,b.T), axis=1)
array([[1, 2, 5],
       [3, 4, 6]])

Форма и размер массива

  1. ndarray.ndim
  2. ndarray.size
  3. ndarray.shape

ndarray.ndim

сообщает нам количество осей или измерений массива.

arr = np.array([[[0, 1, 2, 3], [4, 5, 6, 7]],
                [[0, 1, 2, 3], [4, 5, 6, 7]],
                [[0 ,1 ,2, 3], [4, 5, 6, 7]]])
arr.ndim  # gives the dimension of the array
3

ndarray.size

находит общее количество элементов в массиве

arr.size
24

ndarray.shape

находит форму массива

arr.shape
(3, 2, 4)

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

Примечание: мы можем изменить форму массива до любого размера, сохранив размер исходного массива прежним.

# arr.reshape()

arr = np.arange(12)  # here size is 12
print(arr)
print()

# reshaping into 2D array of Rows=2 and Columns=6, Size = 12
print(arr.reshape(2,6))

# reshaping into 2D array of Rows=4 and Columns=3, Size = 12
print(arr.reshape(4,3))

# reshaping into 3D array of 3,2,2 maintaining the Size = 12
print(arr.reshape(3,2,2))
[ 0  1  2  3  4  5  6  7  8  9 10 11]

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

[[[ 0  1]
  [ 2  3]]
 [[ 4  5]
  [ 6  7]]
 [[ 8  9]
  [10 11]]]

Случайный модуль NumPy

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

np.random.rand()

Генерация случайных чисел (равномерное распределение)

np.random.rand(2,3)
array([[0.0117202 , 0.86750348, 0.45139067],
       [0.1103309 , 0.30405034, 0.08778116]])

np.random.randn()

Генерация случайных чисел (нормальное распределение со средним значением = 0 и стандартным отклонением = 1)

np.random.randn(2,3)
array([[ 1.59436956,  1.65239378, -0.70732319],
       [-1.37190062, -1.47977959,  0.90136213]])

np.random.randint()

Возвращать случайные целые числа из «дискретного равномерного» распределения заданного размера от низкого (включительно) до высокого (исключительного)

np.random.randint(low=1, high=100, size=10)  # here size=10, which gives 10 number between min and max limit
array([12, 45, 68, 54, 65, 43, 79, 94, 96, 28])
# we can create a n-dimensional array by specifying the size 
np.random.randint(1,100,(4,4))  # here it is 4x4 size of array having random values
array([[53,  6, 65, 69],
       [20, 82, 27, 55],
       [89, 98, 71, 34],
       [58, 23, 17, 36]])

np.random.random_sample()

Возвращает случайные числа с плавающей запятой в полуоткрытом интервале [0.0, 1.0).

np.random.random_sample(size=(2,6))
array([[0.19465933, 0.72918811, 0.33219758, 0.04920512, 0.99888788,
        0.32102308],
       [0.08149279, 0.05946466, 0.27319728, 0.28875117, 0.55290726,
        0.19653602]])

np.random.normal()

Нарисуйте случайные выборки из нормального (гауссовского) распределения.

np.random.normal(loc=0, scale=1, size=15)  # 'loc' denotes mean & 'scale' denotes Standard Deviation for 15 numbers
array([ 1.40924246,  0.00650419,  0.5397556 , -2.49951693, -0.55381917,
        0.4406829 ,  0.27065829,  0.94675684,  1.95851061,  0.1540836 ,
       -0.88915799, -0.31680415, -0.12880158, -1.19021509,  0.25109025])

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

Мы можем индексировать и нарезать массивы NumPy так же, как мы нарезаем списки Python.

arr = np.arange(0,11)
arr
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
# data at position 1
arr[1]
1
# data from position 2 till the end of array
arr[2:]
array([ 2,  3,  4,  5,  6,  7,  8,  9, 10])
# data between position 2 and 7 (exclusive)
arr[2:7]
array([2, 3, 4, 5, 6])
# Negative indexing from last till 3rd last
arr[-1:7:-1]
array([10,  9,  8])
# Negative indexing from last till 3rd last
arr[-1:-4:-1]
array([10,  9,  8])
# print all of the values in the array that are less than equal to 5
arr[arr<=5]
array([0, 1, 2, 3, 4, 5])
# select elements that satisfy two conditions using the & and | operators
arr[(arr<=8) & (arr>2)]
array([3, 4, 5, 6, 7, 8])

Постановка задачи

arr1 = np.random.randint(2,100,20).reshape(5,4)
arr1
array([[34, 40, 30, 23],
       [46, 85, 23, 56],
       [ 4, 23, 55,  6],
       [64, 94, 28, 84],
       [20, 48,  7, 87]])
# all data till 3rd row and all data till 3rd column 
arr1[:3,:3]
array([[34, 40, 30],
       [46, 85, 23],
       [ 4, 23, 55]])
# all data starting from 3rd row and all data starting from 1st column 
arr1[3:,1:]
array([[94, 28, 84],
       [48,  7, 87]])
# all data starting from 2nd row till 3rd row and all data of 1st and last column 
arr1[2:4,[0,-1]]
array([[ 4,  6],
       [64, 84]])

Основные операции с массивами

5 + np.ones((3,5))  # add 5 to all elements in an array
array([[6., 6., 6., 6., 6.],
       [6., 6., 6., 6., 6.],
       [6., 6., 6., 6., 6.]])

arr1 = np.random.randint(1,20,(2,2))
arr2 = np.random.randint(10,20,(2,2))
print(f"Array1: \n{arr1}")

print(f"\nArray2: \n{arr2}")
Array1: 
[[18 14]
 [ 7  4]]

Array2: 
[[15 10]
 [10 16]]
print(f"\n Addition: \n{arr1 + arr2}")
print(f"\n Subtraction: \n{arr1 - arr2}")
print(f"\n Multiplication: \n{arr1 * arr2}")
print(f"\n Division: \n{arr1 / arr2}")
Addition: 
[[33 24]
 [17 20]]

 Subtraction: 
[[  3   4]
 [ -3 -12]]

 Multiplication: 
[[270 140]
 [ 70  64]]

 Division: 
[[1.2  1.4 ]
 [0.7  0.25]]
# sum
print(arr1)
print("Sum without axis", arr1.sum())
print("Sum axis=0", arr1.sum(axis=0))
print("Sum axis=1", arr1.sum(axis=1))
[[18 14]
 [ 7  4]]
Sum without axis 43
Sum axis=0 [25 18]
Sum axis=1 [32 11]
# Addition
arr1 + arr2
array([[33, 24],
       [17, 20]])
# Square Root
np.sqrt(arr1)
array([[4.24264069, 3.74165739],
       [2.64575131, 2.        ]])
# Exponential
np.exp(arr2)
array([[3269017.37247211,   22026.46579481],
       [  22026.46579481, 8886110.52050787]])
# Logarithmic
np.log10(arr1)
array([[1.25527251, 1.14612804],
       [0.84509804, 0.60205999]])

Как создать массив из существующих данных

1. Радиовещание

  • Трансляция — это механизм, позволяющий NumPy выполнять операции с массивами различной формы.
  • Размеры массива должны быть совместимыми, например, когда размеры обоих массивов равны или когда один из них равен 1.
  • Если размеры несовместимы, вы получите ValueError.
# Broadcasting
arr = np.arange(1,10)
arr[2:] = 1000
print(arr)
[   1    2 1000 1000 1000 1000 1000 1000 1000]
# Broadcasting | NumPy understands that the multiplication should happen with each cell. That concept is called broadcasting. 
data = np.array([1.0, 2.0])
data * 1.6
array([1.6, 3.2])

2. Копирование массивов

# Arrays are Reference typed, that means assigning one array to another also shares the same memory reference.add()
# To prevent, the above, we must use copy() method

arr1 = arr.copy()
print(arr)


arr1[3:] = 500
print(arr1)
[   1    2 1000 1000 1000 1000 1000 1000 1000]
[   1    2 1000  500  500  500  500  500  500]

3. Укладка (вертикальная и горизонтальная)

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

print(f"Vertical Stack: \n{np.vstack((arr1, arr2))}")

print(f"\nHorizontal Stack: \n{np.hstack((arr1, arr2))}")
Vertical Stack: 
[[1 1]
 [2 2]
 [3 3]
 [4 4]]

Horizontal Stack: 
[[1 1 3 3]
 [2 2 4 4]]

Получайте уникальные предметы и счетчики

arr = np.array([11, 11, 12, 13, 14, 15, 16, 17, 12, 13, 11, 14, 18, 19, 20])
arr
array([11, 11, 12, 13, 14, 15, 16, 17, 12, 13, 11, 14, 18, 19, 20])
unique_values = np.unique(arr)  # alternatively, we can remove duplicates from the array
unique_values
array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
unique_values, index_positions = np.unique(arr, return_index=True) 
print(unique_values)
print(index_positions)
[11 12 13 14 15 16 17 18 19 20]
[ 0  2  3  4  5  6  7 12 13 14]
unique_values, counts = np.unique(arr, return_counts=True) 
print(unique_values)
print(counts)
[11 12 13 14 15 16 17 18 19 20]
[3 2 2 2 1 1 1 1 1 1]

NumPy: упражнения

# Write a NumPy program to create an array of all even integers from 30 to 70.

np.arange(start=30, stop=70, step=2)
array([30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62,
       64, 66, 68])
# Write a NumPy program to create a 3x3 identity matrix.
np.identity(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
# Write a NumPy program to generate an array of 15 random numbers from a standard normal distribution.
np.random.normal(loc=0, scale=1, size=15)  # 'loc' denotes mean & 'scale' denotes Standard Deviation
array([ 0.15030259,  1.30645184, -0.28881421, -0.99897669, -0.41408066,
       -1.83996599, -1.37655922,  0.74360087,  0.11151737, -0.23403126,
        0.12432222,  0.56679231,  0.13377066,  0.70120379, -0.90153684])
# Write a NumPy program to create a 2D array with 1 on the border and 0 inside.
arr = np.ones((5,5))
arr[1:-1, 1:-1] = 0
arr
array([[1., 1., 1., 1., 1.],
       [1., 0., 0., 0., 1.],
       [1., 0., 0., 0., 1.],
       [1., 0., 0., 0., 1.],
       [1., 1., 1., 1., 1.]])
# Write a NumPy program to test whether each element of a 1-D array is also present in a second array.
arr1 = np.array([ 0, 10, 20, 40, 60])
arr2 = np.array([0, 40])
# for i in range(len(arr1)):
#     if arr1[i] in arr2:
#         arr1[i] = True
#     else:
#         arr1[i] = False
print("Compare each element of array1 and array2")
np.in1d(arr1, arr2)
Compare each element of array1 and array2





array([ True, False, False,  True, False])
# Write a Python program to find the maximum and minimum value of a given flattened array.
arr = np.array([[0, 1],
[2, 3]])
print(f"Max: {np.amax(arr)}")
print(f"Min: {np.amin(arr)}")
Max: 3
Min: 0

Ресурсы

Функции Numpy: https://www.w3resource.com/numpy/index.php

Практические упражнения Numpy: https://www.w3resource.com/python-exercisions/numpy/index.php

Краткое содержание

Мы рассмотрели основы «Что», «Как», «Когда» — о NumPy.

Приятного кодирования!

На простом английском языке

Спасибо, что вы являетесь частью нашего сообщества! Прежде чем уйти: