Как найти максимальное число в матрице питон

Матрица — это двумерный массив, состоящий из M строк и N столбцов. Матрицы часто используются в математических вычислениях. Программисты работают с матрицами в основном в научной области, однако их можно использовать и для других вещей, например, для быстрой генерации уровней в видео-игре.

Матрицы и библиотека NumPy

Программист может самостоятельно реализовать все функции для работы с матрицами: умножение, сложение, транспонирование и т. д. На Python это сделать гораздо проще, чем на более низкоуровневых языках, таких как C.

Но каждый раз писать одни и те же алгоритмы не имеет смысла, поэтому была разработана библиотека NumPy. Она используется для сложных научных вычислений и предоставляет программисту функции для работы с двумерными массивами.

Вместо того чтобы писать десятки строк кода для выполнения простых операций над матрицами, программист может использовать одну функцию из NumPy. Библиотека написана на Python, C и Фортране, поэтому функции работают даже быстрее, чем на чистом Python.

Подключение библиотеки NumPy

NumPy не встроена в интерпретатор Python, поэтому перед импортом её необходимо установить. Для этого в можно воспользоваться утилитой pip. Введите в консоле команду:

pip install numpy

Теперь, когда библиотека установлена, её можно подключить с помощью команды import. Для удобства переименуем numpy при импорте в np следующим образом:

import numpy as np

Ниже в примерах будет использован именно такой импорт, поэтому обращение к библиотеке будет через np, а не numpy!

Создание

Для создании матрицы используется функция array(). В функцию передаётся список. Вот пример создания, мы подаём в качестве аргумента функции двумерный список:

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

Вторым параметром можно задать тип элементов матрицы:

a = np.array([[3, 3, 3],[2, 5, 5]], int)
print(a)

Тогда в консоль выведется:

[[3 3 3]
 [2 5 5]]

Обратите внимание, что если изменить int на str, то тип элементов изменился на строковый. Кроме того, при выводе в консоль NumPy автоматически отформатировал вывод, чтобы он выглядел как матрица, а элементы располагались друг под другом.

В качестве типов элементов можно использовать int, float, bool, complex, bytes, str, buffers. Также можно использовать и другие типы NumPy: логические, целочисленные, беззнаковые целочисленные, вещественные, комплексные. Вот несколько примеров:

• np.bool8 — логическая переменная, которая занимает 1 байт памяти.
• np.int64 — целое число, занимающее 8 байт.
• np.uint16 — беззнаковое целое число, занимающее 2 байта в памяти.
• np.float32 — вещественное число, занимающее 4 байта в памяти.
• np.complex64 — комплексное число, состоящее из 4 байтового вещественного числа действительной части и 4 байтов мнимой.

Вы также можете узнать размер матрицы, для этого используйте атрибут shape:

size = a.shape
print(size) # Выведет (2, 3)

Первое число (2) — количество строк, второе число (3) — количество столбцов.

Нулевая матрица

Если необходимо создать матрицу, состоящую только из нулей, используйте функцию zeros():

a_of_zeros = np.zeros((2,2))
print(a_of_zeros)

Результат этого кода будет следующий:

[[0. 0.]
 [0. 0.]]

Получение строки, столбца и элемента

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

temp = a[0]
print(temp) #Выведет [3 3 3]

Получить столбец уже не так просто. Используем срезы, в качестве первого элемента среза мы ничего не указываем, а второй элемент — это номер искомого столбца. Пример:

arr = np.array([[3,3,3],[2,5,5]], str)
temp = arr[:,2]
print(temp) # Выведет ['3' '5']

Чтобы получить элемент, нужно указать номер столбца и строки, в которых он находится. Например, элемент во 2 строке и 3 столбце — это 5, проверяем (помним, что нумерация начинается с 0):

arr = np.array([[3,3,3],[2,5,5]], str)
temp = arr[1][2]
print(temp) # Выведет 5

Умножение и сложение

Чтобы сложить матрицы, нужно сложить все их соответствующие элементы. В Python для их сложения используется обычный оператор «+».

Пример сложения:

arr1 = np.array([[3,3,3],[2,5,5]])
arr2 = np.array([[2,4,2],[1,3,8]])
temp = arr1 + arr2
print(temp)

Результирующая матрица будет равна:

[[ 5  7  5]
 [ 3  8 13]]

Важно помнить, что складывать можно только матрицы с одинаковым количеством строк и столбцов, иначе программа на Python завершится с исключением ValueError.

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

Умножение в NumPy выполняется с помощью метода dot().

Пример умножения:

arr1 = np.array([[3,3],[2,5]])
arr2 = np.array([[2,4],[1,3]])
temp = arr1.dot(arr2)
print(temp)

Результат выполнения этого кода будет следующий:

[[ 9 21]
 [ 9 23]]

Как она получилась? Разберём число 21, его позиция это 1 строка и 2 столбец, тогда мы берем 1 строку первой матрицы и умножаем на 2 столбец второй. Причём элементы умножаются позиционно, то есть 1 на 1 и 2 на 2, а результаты складываются: [3,3] * [4,3] = 3 * 4 + 3 * 3 = 21.

Транспонированная и обратная

Транспонированная матрица — это матрица, у которой строки и столбцы поменялись местами. В библиотеки NumPy для транспонирования двумерных матриц используется метод transpose(). Пример:

arr1 = np.array([[3,3],[2,5]])
temp = arr1.transpose()
print(temp)

В результате получится матрица:

[[3 2]
 [3 5]]

Чтобы получить обратную матрицу, необходимо использовать модуль linalg (линейная алгебра). Используем функцию inv():

arr1 = np.array([[3,3],[2,5]])
temp = np.linalg.inv(arr1)
print(temp)

Результирующая матрица будет равна:

[[ 0.55555556 -0.33333333]
 [-0.22222222  0.33333333]]

Получение максимального и минимального элемента

Чтобы получить максимальный или минимальный элемент, можно пройтись по всем элементам матрицы с помощью двух циклов for. Это стандартный алгоритм перебора, который известен почти каждому программисту:

arr = np.array([[3,3],[2,5]])
min = arr[0][0]
for i in range(arr.shape[0]):
    for j in range(arr.shape[1]):
        if min > arr[i][j]:
            min = arr[i][j]
print("Минимальный элемент:", min) # Выведет "Минимальный элемент: 2"

NumPy позволяет найти максимальный и минимальный элемент с помощью функций amax() и amin(). В качестве аргумента в функции нужно передать саму матрицу. Пример:

arr1 = np.array([[3,3],[2,5]])
min = np.amin(arr1)
max = np.amax(arr1)
print("Минимальный элемент:", min) # Выведет "Минимальный элемент: 2"
print("Максимальный элемент:", max) # Выведет "Максимальный элемент: 5"

Как видим, результаты реализации на чистом Python и реализации с использованием библиотеки NumPy совпадают.

Заключение

На Python можно реализовать все необходимые функции для работы с матрицами. Чтобы упростить работу программистов, была создана библиотека NumPy. Она позволяет производить сложные математические вычисления легко и без ошибок, избавляя программиста от необходимости каждый раз писать один и тот же код.

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

Синтаксис

numpy.argmax(a, axis=None, out=None)

Параметры

• массив: входной
• ось [int, необязательно]: по умолчанию индекс находится в сплющенном массиве, если нет, то вдоль указанной оси.
• out [необязательный массив]: если указано, результат будет вставлен в этот массив. Он должен соответствовать по форме и типу.

Что мы получим?

Массив индексов в массив. Он будет иметь ту же форму, что и array.shape, но короче.

Находим максимальный элемент из матрицы с помощью numpy.argmax()

import numpy as np    

a = np.matrix([[1,2,3,33],[4,5,6,66],[7,8,9,99]])

print(np.argmax(a)) 
print(np.argmax(a[:,:]))  
print(np.argmax(a[:1])) 
print(np.argmax(a[:,2]))  
print(np.argmax(a[1:,2])) 

Вывод

11
11
3
2
1

argmax() возвращает позицию или индекс наибольшего значения в массиве. Массив может быть единичным или многомерным.

Используем np.unravel_index при выводе argmax

Можно использовать функцию np.unravel_index, чтобы получить индекс, соответствующий 2D-массиву из вывода numpy.argmax.

import numpy as np
a = np.arange(6).reshape(2,3) + 10
print(a)

index = np.unravel_index(np.argmax(a), a.shape)
print(index)
print(a[index])

Вывод

[[10 11 12]
 [13 14 15]]
(1, 2)
15

Ищем максимальное количество элементов по столбцам с помощью numpy.argmax()

Приведенный ниже код выводит значение индекса максимального количества элементов в каждом столбце.

import numpy as np
a = np.arange(12).reshape(4,3) + 10
print(a)

print("Max elements", np.argmax(a, axis=0))

Вывод

[[10 11 12]
 [13 14 15]
 [16 17 18]
 [19 20 21]]
Max elements [3 3 3]

Просмотры: 1 276