Как рассчитать матрицы в Python без NumPy?

Вертикальный ряд объектов в матрице Python обычно называют «столбцами», тогда как горизонтальный ряд объектов называется «строками». Как и во вложенном списке, строки и столбцы располагались друг над другом. Если матрица имеет «k» строк и «m» столбцов, и если «k» и «m» — положительные целые числа, порядок такого матричного объекта определяется «k-by-m».

Матрица может содержать строки, числа и другие объекты данных. В матрице данные располагаются как в столбцах, так и в строках. Ключевой структурой данных, поддерживающей вычисления в науке и математике, является матрица. Поскольку Python не предоставляет встроенного типа для матричного объекта, мы рассматриваем либо список среди списков, либо даже вложенный список как матрицу.

Как работают матрицы в Python

Данные записываются в двумерный массив для создания матрицы. Процедура следующая:

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

В качестве дисплея используется матрица 3 на 5. Следовательно, ее размер равен 3 на 5. Данные внутри этой матрицы состоят из объектов либо целого типа данных. Верхняя строка, Row1, имеет значения 1, 3, 5, 7 и 9, тогда как Row2 вместе со Row3 имеет значения (2, 4, 6, 8) и соответственно (0, 8, 7, 4).. Столбец 1 содержит значения (1, 2, 0), а столбец 2 имеет значения (3, 4, 8) и так далее.

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

Добавление матрицы Python

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

matrix1 = [[2, 4, 1],
[4, 1, 5],
[3, 6, 7]]

matrix2 = [[4, 2, —1],
[5, 6, —3],
[0, —4, 3]]

matrix3  = [[0,1,0],
[1,0,0],
[0,0,1]]

matrix4  = [[0,0,1],
[0,1,0],
[1,0,0]]

matrices_length = len(matrix1)

for row in range(len(matrix1)):
for column in range(len(matrix2[0])):
matrix4[row][column] = matrix1[row][column] + matrix2[row][column] + matrix3[row][column]

print(«The sum of the matrices is = «, matrix4)

Первоначально вместо использования NumPy мы напрямую построили три матрицы порядка 3 на 3. Мы указали порядок или длину матрицы 1 в качестве функции len() и других соответственно. С помощью вложенных циклов сначала были добавлены три матрицы. Затем сумма трех матриц была указана как матрица 4, и мы использовали функцию print() для отображения результатов.

Транспонировать матрицу в Python

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

Транспонирование матрицы обозначается символом At. Например, предположим, что у нас есть матрица «А», имеющая порядок:

3 на 2

Тогда транспонирование A:

матрица 2 на 3

Вычисление транспонирования матрицы с помощью вложенного цикла

Вложенный цикл можно использовать для многократного перебора столбцов и строк даже вложенного списка. Вставьте элемент в «i-ю» строку и «j-й» столбец матрицы F рядом с «j-й» строкой и «i-м» столбцом матрицы «F^T», чтобы получить транспонирование матрицы. «F ^ T» будет матрицей 2 на 3, предполагая, что «F» — матрица 3 на 2.

F = [[2, 3],
[5, 7],
[8, 1]]

F_T = [[0, 0, 0],
[0, 0, 0]]

for q in range(len(F)):
for w in range(len(F[0])):
F_T[w][q] = F[q][w]

for q in F_T:
print(q)

Сначала создается транспонированная матрица исходной матрицы и матрицы «F» с порядком 3 на 2. Предыдущая программа использует вложенные циклы for, постоянно повторяющиеся для каждой строки, а затем и для каждого столбца. На каждой итерации мы добавляем элемент из «F[q][w]» в «FT[w][q]». Наконец, мы выполняем метод print() для изображения транспонирования.

Использование понимания вложенного списка для поиска транспонирования матрицы

Вложенный список создается, когда понимание списка выполняется внутри другого понимания списка. Ниже приведен синтаксис для понимания вложенных списков:

new_list = [[expr. for a list item] for a list item]

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

J = [[1, 3],
[4, 6],
[9, 2]]

J_T = [[J[v][c] for v in range(len(J))] for c in range(len(J[0]))]

for c in J_T:
print(c)

Начнем с создания матрицы «J» порядка 3 на 2. Обработка вложенного списка в предыдущем коде перебирает элементы матрицы один раз за раз и вставляет элементы «J[v]» где-то в месте «J_T[v]». Столбцы матрицы повторяются на протяжении всей первой части такого вложенного списка, а ее строки повторяются во втором столбце.

Умножение двух матриц в Python

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

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

Использование вложенного списка для поиска умножения матрицы

Матрица может быть создана в Python как нечто большее, чем просто вложенный список, своего рода список внутри списка. Строка матрицы соответствует каждому значению вложенного списка. Давайте посмотрим на пример вложенного цикла, используемого для умножения двух матриц.

N = [[9, 1, 7],
[3, 5, 6],
[4, 7, 8]]

M = [[2, 3, 5, 6],
[8, 9, 1, 2],
[4, 5, 9, 3]]

result = [[0, 0, 0, 0],
[0,0,0,0],
[0,0,0,0]]

for u in range(len(N)):
for o in range(len(M[0])):
for p in range(len(M)):
result[u][o] += N[u][p] * M[p][o]
for d in result:
print(d)

В этом примере мы будем использовать вложенные циклы для выполнения программы, которая умножает две матрицы, но перед этим мы сгенерируем две матрицы, «N» и «M», которые имеют размеры 3 на 3 и 3-3. на-4 в порядке соответственно, а также третья матрица, которая имеет порядок 3-на-4. Затем мы проходим итерационный процесс, в котором мы используем элементы строк в «N», столбцов в «M» и строк в «M». Мы применили оператор печати для отображения умножения определенных матриц.

Использование понимания вложенных списков для нахождения умножения матриц

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

Синтаксис:

# new_list = [[expr. for a list item] for a list item]

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

E = [[8, 1, 3],
[8, 7, 3],
[7, 3, 5]]

R = [[2, 3, 6, 8],
[9, 8, 5, 3],
[1, 3, 8, 9]]

result = [[sum(f*g for f,g in zip(E_row, R_col)) for R_col in zip(*R)] for E_row in E]

for z in result:
print(z)

Чтобы получить сумму произведений каждого построчного умножения, мы перебираем в программе столбцы внутри матрицы «R» и строки внутри матрицы «E». Чтобы получить столбцы матрицы «R», мы используем метод zip(). Нам требуются элементы строки в матрице «E» в качестве второго компонента понимания вложенного списка для вычисления суммы произведений для каждой строки внутри этого вложенного списка. В конце будет использован оператор печати.

Заключение

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