Введение

Библиотека NumPy предназначена для работы с многомерными массивам чисел. В том числе с последовательностями и таблицами чисел. Библиотека позволяет очень ёмко и быстро выполнять довольно обширный набор действий с массивами чисел.

Документация

• Оригинальный tutorial: https://numpy.org/doc/stable/user/quickstart.html;
• Оглавление документации: https://docs.scipy.org/doc/numpy/reference/index.html;
• Полный список команд: https://docs.scipy.org/doc/numpy/genindex.html;
• Перевод некоторых частей: https://pythonworld.ru/numpy/1.html;

Замечания по вводу-выводу

Циклами можно пользоваться только в задачах B и C (да и те можно решить без циклов).

Каждая программа должна начинаться со строк с импортированием NumPy и настройкой вывода:

import numpy as np
np.set_printoptions(precision=4, threshold=99999, linewidth=99999, suppress=True)

Если на вход в задаче даётся хотя бы один массив, то получать все данные необходимо из файла input.txt при помощи команды в духе

ar = eval(open('input.txt').read())
N, K, ar = eval(open('input.txt').read())
ar1, ar2 = eval(open('input.txt').read())

При выводе массивов всегда используйте функцию repr.

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

# Одномерный массив нулей
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
# Двумерный массив нулей
>>> np.zeros((2, 3))
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])
# Трёхмерный массив единиц
>>> np.ones((2,3,4))
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.]]])
# Массив нулей с указанием типа
>>> np.zeros(5, dtype=np.int)
array([0, 0, 0, 0, 0])
# Массив на основе списка
>>> np.array([2,3,1,0])
array([2, 3, 1, 0])
# Массив на основе списка списков
>>> np.array([[1,2.0],[0,0],(1+1j,3.)])
array([[ 1.+0.j,  2.+0.j],
       [ 0.+0.j,  0.+0.j],
       [ 1.+1.j,  3.+0.j]])
# Арифметическая прогрессия
>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# Арифметическая прогрессия с указанием типа
>>> np.arange(2, 10, dtype=np.float)
array([ 2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.])
# Арифметическая прогрессия с нецелой разностью
>>> np.arange(2, 3, 0.1)
array([ 2. ,  2.1,  2.2,  2.3,  2.4,  2.5,  2.6,  2.7,  2.8,  2.9])
# Арифметическая прогрессия с заданным количеством членов
>>> np.linspace(1., 4., 6)
array([ 1. ,  1.6,  2.2,  2.8,  3.4,  4. ])

Обращения по индексам

>>> x = np.arange(12).reshape(3, 4)
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
# Координаты указываем через запятую
>>> x[1, 2]
6

Срезы

>>> x = np.arange(12).reshape(3, 4)
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
# Любая координата может быть срезом (:, a:b, ::-1, a:b:c)
# Строка с индексом 1
>>> x[1, :]
array([4, 5, 6, 7])
# Столбец с индексом 2
>>> x[:, 2]
array([ 2,  6, 10])
# Строка в обратном порядке
>>> x[0, ::-1]
array([3, 2, 1, 0])

Использование списка индексов в срезах

>>> x = np.arange(12).reshape(3, 4)
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
# Вместо конкретного индекса можно передать набор индексов
>>> x[:, [1, 3]]
array([[ 1,  3],
       [ 5,  7],
       [ 9, 11]])
# Все передаваемые наборы должны быть одинаковой длины
>>> x[[0, 1], [1, 3]]
array([1, 7])
>>> x[np.arange(3), np.arange(3)]
array([ 0,  5, 10])

Векторные операции

>>> x = np.arange(12).reshape(2, 6)
# Можно ко всем элементам массива прибавлять числа и другие массивы
>>> x + 10
array([[10, 11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20, 21]])
# Можно все элементы массива умножать на числа или поэлементно на другие массивы
>>> x * 3
array([[ 0,  3,  6,  9, 12, 15],
       [18, 21, 24, 27, 30, 33]])
# Если формы массивов не одинаковые, то происходит "размножение" вдоль координат с размерностью 1
# Например к массиву формы (2, 6) прибавляем массив формы (6) = (1, 6).
# Вдоль координаты 1 (то есть построчно) происходит размножение
>>> x + np.array([0, 10, 100, -10, -100, 0])
array([[  0,  11, 102,  -7, -96,   5],
       [  6,  17, 108,  -1, -90,  11]])
# Например к массиву формы (2, 6) прибавляем массив формы (2, 1)
# Вдоль координаты 1 (то есть по столбцам) происходит размножение
>>> x + np.array([[0], [-100]])
array([[  0,   1,   2,   3,   4,   5],
       [-94, -93, -92, -91, -90, -89]])
>>> x + np.array([0, -100]).reshape((2, 1))
array([[  0,   1,   2,   3,   4,   5],
       [-94, -93, -92, -91, -90, -89]])
# Это самое размножение называется broadcasting, тема достаточно сложная.
# Если вы ничего не поняли, то можно для начала запомнить, что к массиву формы
# (m, n) можно построчно прибавить массив формы (1, n)
# или постолбцово прибавить массив формы (m, 1)
# Можно ко всем элементам массива применять различные функции, в том числе логические
>>> np.sqrt(np.abs(x))
array([[ 0.    ,  1.    ,  1.4142,  1.7321,  2.    ,  2.2361],
       [ 2.4495,  2.6458,  2.8284,  3.    ,  3.1623,  3.3166]])
>>> x > 3
array([[False, False, False, False,  True,  True],
       [ True,  True,  True,  True,  True,  True]], dtype=bool)
>>> (x > 3) & (x < 8)
array([[False, False, False, False,  True,  True],
       [ True,  True, False, False, False, False]], dtype=bool)

Использование массивов bool в срезах

>>> x = np.arange(12).reshape(2, 6)
# Вместо индекса можно передать массив bool-ов соответствующей длины: брать/не брать
>>> x[np.array([True, False]), :]
array([[0, 1, 2, 3, 4, 5]])
>>> x[:, np.array([True, True, False, False, False, True])]
array([[ 0,  1,  5],
       [ 6,  7, 11]])
# Соответствующие массивы bool-ов можно получать автоматически
>>> x > 3
array([[False, False, False, False,  True,  True],
       [ True,  True,  True,  True,  True,  True]], dtype=bool)
>>> x[x > 3]
array([ 4,  5,  6,  7,  8,  9, 10, 11])
# Можно использовать логические связки &=and и |=or, но нужно не забывать про скобки
>>> (x > 3) & (x < 8)
array([[False, False, False, False,  True,  True],
       [ True,  True, False, False, False, False]], dtype=bool)
>>> x[(x > 3) & (x < 8)]
array([4, 5, 6, 7])

Максимумы и минимумы

>>> x = np.arange(12).reshape(2, 6)
# Находить минимумы и максимумы, а также индексы соответствующих элементов бесконечно просто
>>> x = np.random.randint(0, 10, 10)
>>> x
array([8, 2, 8, 3, 4, 8, 9, 9, 3, 1])
>>> x.max(), x.min(), x.argmax(), x.argmin()
(9, 1, 6, 9)
# Если массив многомерный, то argmax и argmin возвращают не координату в массиве, а номер по порядку
>>> x = np.random.randint(0, 10, (2, 6))
>>> x
array([[1, 4, 9, 6, 6, 7],
       [9, 8, 9, 5, 2, 7]])
>>> x.argmax()
2
# Но его можно превратить в координату в массиве
>>> np.unravel_index(x.argmax(), x.shape)
(0, 2)
# А также найти все наборы координат по заданному правилу
>>> np.argwhere(x==x.max())
array([[0, 2],
       [1, 0],
       [1, 2]], dtype=int64)

Сортировка

>>> a = np.array([[1,4],[3,1]])
array([[1, 4],
       [3, 1]])
>>> np.sort(a)                # Сортировка вдоль последней оси (построчно)
array([[1, 4],
       [1, 3]])
>>> np.sort(a, axis=None)     # Сортировка "выпрямленного" массива
array([1, 1, 3, 4])
>>> np.sort(a, axis=0)        # Сортировка вдоль первой оси (по столбцам)
array([[1, 1],
       [3, 4]])

>>> x = np.array([3, 1, 2])
>>> np.argsort(x)
array([1, 2, 0], dtype=int64)
>>> x[np.argsort(x)]
array([1, 2, 3])
>>> x = np.array([[3, 1, 2], [0, 1, 2], [10, 11, 12]])
>>> x
array([[ 3,  1,  2],
       [ 0,  1,  2],
       [10, 11, 12]])
>>> x[:, np.argsort(x[0, :])]
array([[ 1,  2,  3],
       [ 1,  2,  0],
       [11, 12, 10]])
>>> x[np.argsort(x[:, 0]), :]
array([[ 0,  1,  2],
       [ 3,  1,  2],
       [10, 11, 12]])

Хранение картинок в компьютере

Картинки можно хранить в памяти компьютера как прямоугольную таблицу пикселей. Каждый пиксель — это одно число, если картинка чернобелая, либо тройка чисел — яркости красного, зелёного и синего (RGB).

Работа с картинками

В питоне можно очень легко прочитать картинку в NumPy-массив:

from skimage import io
img = io.imread('30x60c.png')

Посмотреть на прочитанную картинку:

io.imshow(img)
io.show()

И записать картинку из NumPy-массива в файл:

io.imsave('res.png', img)