Основы массивов и списков Numpy

Таблица вещей, которые вы, возможно, захотите посмотреть

∘ Введение
∘ Формат учебного пособия
∘ # Важное примечание #
∘ Импорт Numpy
∘ Определение массивов и списков Numpy
∘ Формы и размеры
∘ Индексация
∘ Немного математики
∘ Булева маскировка

Вступительные примечания

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

Учебный формат

# The Code
print('Output')

  • Заметки по теме.
# The code continous
print('Output2')

  • Примечания к новой части кода.

# Важное примечание #

Я настоятельно рекомендую вам сначала проверить выходное изображение, а затем, если вы считаете, что вам это нужно, прочитать или запустить код !!!

Импорт NumPy

import numpy as np
  • Здесь нет никаких заметок, перейдите к следующему изображению.

Определение массивов и списков NumPy

arr1 = np.array([30,20,40,20,60,80,70,60,20])
print("1-dimensional array:")
print(arr1)
arr2 = np.array([[50,20,10,40],[30,20,40,50]])
print("\n2-dimensional array:")
print(arr2)
arr3 = np.array([[[30,20,40],[20,40,50]],[[50,20,10],[30,40,10]]])
print("\n3-dimensional array:")
print(arr3)
print('\n\n--list version--\n')
list1 = [30,20,40,20,60,80,70,60,20]
print("1-dimensional list:")
print(list1)
list2 = [[50,20,10,40],[30,20,40,50]]
print("\n2-dimensional list:")
print(list2)
list3 = [[[30,20,40],[20,40,50]],[[50,20,10],[30,40,10]]]
print("\n3-dimensional list:")
print(list3)

  • При определении массива NumPy просто напишите объявление списка внутри этой функции: np.array().
  • Это объявление одинаково для многомерных массивов NumPy.

Формы и размеры

print('arr1 dimension: ', arr1.ndim,", arr1 shape: ",arr1.shape)
print('arr2 dimension: ', arr2.ndim,", arr2 shape: ",arr2.shape)
print('arr3 dimension: ', arr3.ndim,", arr3 shape: ",arr3.shape)

print('\narr1 with its new shape (3,3):\n',np.reshape(arr1, (3,3)))
print('\narr2 with its new shape (4,2):\n',np.reshape(arr2, (4,2)))
print('\narr3 with its new shape (4,3):\n',np.reshape(arr3, (4,3)))
print('\nhorizantal stack of arr2 and arr3 with their new shapes:\n',np.hstack([np.reshape(arr2, (4,2)),np.reshape(arr3, (4,3))]))
print('\nvertical stack of arr1 and arr3 with their new shapes:\n',np.vstack([np.reshape(arr1, (3,3)),np.reshape(arr3, (4,3))]))

  • Посмотрите, как изменить форму и объединить массивы NumPy.
print('--list version--')
print('list1 dimension: ', list1.ndim)

  • Списки не имеют атрибута ndim.
print('list1 shape: ', list1.shape)

  • Списки также не имеют формы атрибута.
print('list1 shape: ',len(list1))
print('list2 shape: ',len(list2),len(list2[0]))
print('list3 shape: ',len(list3),len(list3[0]),len(list3[0][0]))

  • Вот как вы можете получить форму списков.
print('\nlist1 with its new shape (3,3):\n',np.reshape(list1, (3,3)))
print('\nlist2 with its new shape (4,2):\n',np.reshape(list2, (4,2)))
print('\nlist3 with its new shape (4,3):\n',np.reshape(list3, (4,3)))
print('\nhorizantal stack of list2 and list3 with their new shapes:\n',np.hstack([np.reshape(list2, (4,2)),np.reshape(list3, (4,3))]))
print('\nvertical stack of list1 and list3 with their new shapes:\n',np.vstack([np.reshape(list1, (3,3)),np.reshape(list3, (4,3))]))

  • Таким образом, вы можете изменять форму и объединять списки как массивы NumPy.

Индексация

print('array itself:\n',arr2)
print('\narray element at index 1,2:\n',arr2[1,2])
arr2[1,2] = -5
print('\narray element at index 1,2 has changed:\n',arr2[1,2])
print('\nupdated array:\n',arr2)

  • Определенный индекс обновляется для массива NumPy.
print('array itself:\n',arr2)
print('\nfourth column with index 3:\n',arr2[:,3])
arr2[:,3] = [0,0]
print('\nfourth column has changed:\n',arr2[:,3])
print('\nupdated array:\n',arr2)

  • Определенный столбец обновляется для массива NumPy.
print('--list version--\n')
print('list itself:\n',list2)
print('\narray element at index 1,2:\n',list2[1,2])
list2[1,2] = -5
print('\narray element at index 1,2 has changed:\n',list2[1,2])
print('\nupdated array:\n',list2)

  • Списки нельзя индексировать как массивы NumPy, если они многомерны.
print('array itself:\n',arr3)
print('\n arr3[0,:,:]\n------------\n',arr3[0,:,:])
print('\n arr3[:,0,:]\n------------\n',arr3[:,0,:])
print('\n arr3[:,:,0]\n------------\n',arr3[:,:,0])
print('\n arr3[0,0,:]\n------------\n',arr3[0,0,:])
print('\n arr3[:,0,0]\n------------\n',arr3[:,0,0])
print('\n arr3[0,:,0]\n------------\n',arr3[0,:,0])
print('\n arr3[0,0,0]\n------------\n',arr3[0,0,0])

  • Выше приведены примеры индексации для трехмерного массива.
arr4 = np.array([1,2,3,4,5,6,7,8,9])
print('start_index : end_index : step_size => ',arr4[2:9:3])
print('reverse version of previous example => ',arr4[-1:1:-3])
print('reversed array (step -1 through all elements): ',arr4[::-1])
print('\n\n--list version--\n')
list4 = [1,2,3,4,5,6,7,8,9]
print('start_index : end_index : step_size => ',list4[2:9:3])
print('reverse version of previous example => ',list4[-1:1:-3])
print('reversed array (step -1 through all elements): ',list4[::-1])

  • Для одномерного массива и списка индексация аналогична.
print('array elements at indices [0,5,8]: ',arr4[[0,5,8]])
print('\n\n--list version--\n')
print('list elements at indices [0,5,8]: ',list4[0,5,8])

  • Тем не менее, хотя вы можете использовать списки в качестве индексов массивов NumPy, вы не можете использовать списки в качестве индексов других списков.
print('all zeros:\n',np.zeros((3,3)))
print('\nall ones:\n',np.ones((3,3)))
print('\nidentity matrix:\n',np.identity(2))
print('\nall a number:\n',np.full((2,3),100))
print('\narray with a number in shape arr1:\n',np.full_like(arr1,10))
print('\narray with a number in shape arr2:\n',np.full_like(arr2,10))
print('\narray with a number in shape arr3:\n',np.full_like(arr3,10))
print('\nrandom numbers:\n',np.random.rand(2,2))
print('\nrandom integers with an upper bound 5:\n',np.random.randint(5,size=(2,2)))
print('\nrandom integers between -10 and 10:\n',np.random.randint(-10,10,size=(2,2)))

  • Обратите внимание на некоторые конкретные объявления массивов.
print('array itself:')
arr = np.array([[1,2,3,4,5]])
print(arr,'\n\nrepeat array 4 times on axis 0:')
print(np.repeat(arr,4,axis=0))
print('\n\n--list version--\n')
print('list itself:')
l = [[1,2,3,4,5]]
print(l,'\n\nrepeat list 4 times on axis 0:')
print(np.repeat(l,4,axis=0))

  • Вот как вы можете повторять массивы и списки NumPy.

Немного математики

x = np.array([1,3,5,7])
print('array itself:\n',x)
print('\nx * 2:\n', x * 2)
x += 1
print('\nx += 1:\n', x)
print('\nx / 4:\n', x / 4)
print('\nx (This happened after x += 1):\n', x)
print('\nx * x:\n', x * x)
print('\nx ** 2:\n', x ** 2)
print('\nx ** 3:\n', x ** 3)
print('\nnp.log2(x):\n', np.log2(x))

  • Чтобы найти больше математических функций, посетите здесь.
print('\n\n--list version--\n')
x = [1,3,5,7]
print('array itself:\n',x)
print('\nx * 2:\n', x * 2)
x += 1
print('\nx += 1:\n', x)

  • Если вы умножаете список, вы умножаете длину, а не значение.
  • Вы не можете использовать присваивание сложения или любое другое присваивание оператора для списков, как вы можете сделать для массивов NumPy.
print('\nx / 4:\n', x / 4)

  • Для списков также нет разделения, как для массивов NumPy.
print('\nx (This happened after x += 1):\n', x)
print('\nx * x:\n', x * x)

  • После x += 1 ничего не произошло, кроме ошибки.
  • Между двумя списками также нет умножения в виде массивов NumPy.
print('\nx ** 2:\n', x ** 2)

  • Вы не можете получить силу списка, как вы можете догадаться.
print('\nnp.log2(x):\n', np.log2(x))

  • Тем не менее, вы можете выполнять более сложную математику со списком :) (конечно, используя функции NumPy)
  • Используйте функции, чтобы делать математику со списками.
print('\nx (as a list):\n', x)
print('\nnp.power(x,2):\n', np.power(x,2))
print('\nnp.subtract(x,1):\n', np.subtract(x,1))
print('\nnp.divide(x,10):\n', np.divide(x,10))

  • Вот немного математики со списками.
a_list = [1,1,1]
an_array = np.array([[2,2],[2,2],[2,2]])
print('The result of a matrix multiplication between a list and a NumPy array:\n',np.matmul(a_list,an_array))

  • Оба поддерживают матричные операции, если вы используете функции NumPy.
print('Average of a list:',np.average(a_list))
print('Sum of a Numpy array:',np.sum(an_array))

  • Оба поддерживают статистику суммы с функциями NumPy.

Логическое маскирование

an_arr = np.array([1,2,3,4,5,6,7,8,9])
print('array itself:\n', an_arr)
print('\narray less than 5:\n',an_arr<5)
print('\narray less than 5 elements:\n',an_arr[an_arr<5])
print('\narray between 2 and 5:\n',((an_arr<5) & (an_arr>2)))
print('\narray between 2 and 5 elements:\n',an_arr[(an_arr<5) & (an_arr>2)])
print('\n\n--list version--\n')
a_list = np.array([1,2,3,4,5,6,7,8,9])
print('list itself:\n', a_list)
print('\nlist less than 5:\n',a_list<5)
print('\nlist less than 5 elements:\n',a_list[a_list<5])
print('\nlist between 2 and 5:\n',((a_list<5) & (a_list>2)))
print('\nlist between 2 and 5 elements:\n',a_list[(a_list<5) & (a_list>2)])

  • Вот как вы можете маскировать массивы и списки NumPy в Python.

Спасибо, что дошли до конца =)

Больше контента на plainenglish.io. Подпишитесь на нашу бесплатную еженедельную рассылку новостей. Получите эксклюзивный доступ к возможностям написания и советам в нашем сообществе Discord.