Матрицы являются одним из основных объектов в математике. Они используются для представления и манипулирования данными в виде таблицы, состоящей из строк и столбцов. Их используют для решения систем линейных уравнений, определения матричных действий, преобразования координат и многого другое.
В этой статье мы опишем несколько способов создать матрицу в Python. И дополнительно рассмотрим некоторые основные операции, такие как сложение, умножение и определение обратной матрицы.
Что такое матрица
Матрица — это таблица из чисел, которая используется в математике и инженерных науках для представления данных. Матрицы имеют форму таблицы, состоящей из строк и столбцов. Каждый элемент имеет свой уникальный индекс, обозначающий строку и столбец, в котором он находится. Например, матрица размером 3x3 будет иметь 3 строки и 3 столбца, и каждый элемент будет иметь индекс вида (i, j), где i — номер строки, а j — номер столбца.
Создание матрицы
В Python существует несколько способов создания матрицы. Ниже приведены некоторые из них:
- С помощью списков. Можно создать матрицу, используя вложенные списки. Каждый вложенный список будет соответствовать одной строке. Так можно создать квадратную матрицу Python:
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
- С помощью NumPy. NumPy — это библиотека для математических вычислений и обработки данных. В ней есть класс Array, который можно использовать для создания матрицы:
import numpy as np
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
Если вам нужно производить стандартные математические операции с матрицами, то стоит использовать NumPy. Его проще использовать и все операции уже реализованы в библиотеке. А если вы хотите самостоятельно создавать методы, например, в образовательных целях, или же планируете совершать нестандартные манипуляции, то используйте вложенные списки.
Теперь рассмотрим матричные операции и поработаем с ними с помощью вложенных списков и NumPy.
Матричные операции
Вот список основных манипуляций:
- Сложение. Две матрицы можно сложить, если их размеры совпадают. Каждый элемент итоговой матрицы будет равен сумме соответствующих элементов исходных матриц.
- Вычитание. Одну матрицу можно вычесть из другой, если их размеры совпадают. Каждый элемент итоговой матрицы будет равен разности соответствующих элементов исходных матриц.
- Умножение на число. Каждый элемент итоговой матрицы будет равен произведению соответствующего элемента исходной матрицы на число.
- Произведение матриц. Матрицы можно перемножить, если число столбцов первой матрицы равно числу строк второй матрицы. В результате получится новая матрица с размером, соответствующим числу строк первой матрицы и числу столбцов второй матрицы. Более подробно эту операцию мы разберем чуть дальше.
- Транспонирование матрицы. Транспонирование — это операция, в которой строки и столбцы меняются местами. Т.е. первый столбец становится первой строкой, второй столбец — второй строкой и так далее.
- Нахождение обратной матрицы. Матрица B будет являться обратной матрицей для матрицы A, если результатом операции A*B является единичная матрица.
Сложение
Важно не забывать, что при сложении двух матриц их размеры должны совпадать.
Вот пример сложения с помощью вложенных списков и циклов:
matrix1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
matrix2 = [[9, 8, 7], [6, 5, 4], [3, 2, 1]]
result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for i in range(len(matrix1)):
for j in range(len(matrix1[0])):
result[i][j] = matrix1[i][j] + matrix2[i][j]
print(result)
Результат:
[[10, 10, 10], [10, 10, 10], [10, 10, 10]]
Вот аналогичное сложение с помощью метода add() из библиотеки NumPy:
import numpy as np
matrix1 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
matrix2 = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
result = np.add(matrix1, matrix2)
print(result)
Результат:
[[10 10 10]
[10 10 10]
[10 10 10]]
Вычитание
В Python можно выполнять вычитание матриц с помощью цикла или метода subtract() из библиотеки NumPy. При вычитании размеры должны совпадать.
Вычитание с помощью цикла:
matrix1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
matrix2 = [[9, 8, 7], [6, 5, 4], [3, 2, 1]]
result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for i in range(len(matrix1)):
for j in range(len(matrix1[0])):
result[i][j] = matrix1[i][j] - matrix2[i][j]
print(result)
Результат:
[[-8, -6, -4], [-2, 0, 2], [4, 6, 8]]
Вычитание с помощью метода subtract() из библиотеки NumPy:
import numpy as np
matrix1 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
matrix2 = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
result = np.subtract(matrix1, matrix2)
print(result)
Результат:
[[-8 -6 -4]
[-2 0 2]
[ 4 6 8]]
Умножение на число
В Python умножение матрицы на число можно реализовать с помощью цикла или воспользоваться методом dot() из библиотеки NumPy.
При умножении матрицы на число, каждый элемент умножается на это число.
Умножение с помощью цикла:
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
scalar = 2
result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for i in range(len(matrix)):
for j in range(len(matrix[0])):
result[i][j] = matrix[i][j] * scalar
print(result)
Результат:
[[2, 4, 6], [8, 10, 12], [14, 16, 18]]
Вот пример работы метода dot() из библиотеки NumPy с теми же вводными:
import numpy as np
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
scalar = 2
result = np.dot(matrix, scalar)
print(result)
Результат:
[[ 2 4 6]
[ 8 10 12]
[14 16 18]]
Также вместо метода dot() можно использовать знак операции умножения *:
import numpy as np
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
scalar = 2
result = matrix * scalar
print(result)
Результат:
[[ 2 4 6]
[ 8 10 12]
[14 16 18]]
В большинстве случаев метод dot() работает быстрее вручную реализованных циклов.
Облачные серверы
по всему миру с почасовой оплатой.
Произведение матриц
Произведение — это операция, в результате которой получается новая матрица с числом строк первой матрицы и числом столбцов второй. При матричном умножении, число столбцов первой матрицы должно совпадать с числом строк второй. Каждый элемент новой матрицы — это сумма произведения элементов строки первой матрицы и элементов столбцов второй матрицы, как на картинке ниже:
Как и прежде, реализуем произведение с помощью циклов и NumPy.
Умножение, реализованное на циклах, может иметь такой вид:
matrix1 = [[1, 2], [3, 4]]
matrix2 = [[5, 6], [7, 8]]
result = [[0, 0], [0, 0]]
for i in range(len(matrix1)):
for j in range(len(matrix2[0])):
for k in range(len(matrix2)): result[i][j] += matrix1[i][k] * matrix2[k][j]
print(result)
Результат:
[[19, 22], [43, 50]]
В NumPy для матричного умножения используется метода dot():
import numpy as np
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
result = np.dot(matrix1, matrix2)
print(result)
Результат:
[[19 22]
[43 50]]
Аналогично методу dot() работает операция @:
import numpy as np
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
result = matrix1 @ matrix2
print(result)
Результат:
[[19 22]
[43 50]]
Использование метода dot() или оператора @ даёт более быстрый, по сравнению с использованием вручную реализованных циклов, результат.
Не забывайте, что произведение является некоммутативной операцией, то есть порядок умножения матриц имеет значение и результат будет разным, если их переставить местами.
Транспонирование
Транспонирование — это операция, в результате которой строки исходной матрицы становятся столбцами новой матрицы, а столбцы — строками.
В Python можно выполнить транспонирование с помощью свойства T или метода transpose() из библиотеки NumPy.
Пример транспонирования с использованием свойства T:
import numpy as np
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
result = matrix.T
print(result)
Результат:
[[1 4 7]
[2 5 8]
[3 6 9]]
И пример транспонирования с использованием метода transpose():
import numpy as np
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
result = np.transpose(matrix)
print(result)
Результат:
[[1 4 7]
[2 5 8]
[3 6 9]]
В обоих случаях результат одинаковый.
С помощью цикла транспонирование можно реализовать следующим образом:
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for i in range(len(matrix)):
for j in range(len(matrix[0])):
result[j][i] = matrix[i][j]
print(result)
Результат:
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
Этот метод может быть медленным и неэффективным для больших матриц, поэтому для более быстрого и эффективного решения рекомендуется использовать NumPy.
Нахождение обратной матрицы
Обратная матрица — это матрица, которая при умножении на исходную матрицу в результате дает единичную матрицу (с единицами на диагонали и нулями в остальных ячейках).
В Python можно найти обратную матрицу с помощью метода inv() из библиотеки NumPy.
import numpy as np
matrix = np.array([[1, 2], [3, 4]])
result = np.linalg.inv(matrix)
print(result)
Результат:
[[-2. 1. ]
[ 1.5 -0.5]]
Если матрица не имеет обратной матрицы, то метод inv() вызовет исключение LinAlgError: Singular matrix.
Чтобы проверить, имеет ли матрица обратную, используйте метод det() из библиотеки NumPy, который возвращает определитель матрицы. Если определитель равен нулю, то матрица вырожденная и она не имеет обратной матрицы:
import numpy as np
matrix = np.array([[1, 2], [3, 4]])
determinant = np.linalg.det(matrix)
if determinant == 0:
print("The matrix does not have an inverse.")
else:
result = np.linalg.inv(matrix)
print(result)
Нахождение обратной матрицы с помощью циклов может быть достаточно сложным и трудоемким процессом, особенно для больших матриц. Поэтому рекомендуем использовать NumPy.
Разверните облачный сервер для своих проектов
477 ₽/мес
657 ₽/мес
Заключение
Матрицы являются важной концепцией в линейной алгебре и часто используются в различных областях, таких как искусственный интеллект, графика и оптимизация. В Python представлено множество инструментов для работы с матрицами, включая библиотеку NumPy. Понимание матриц и их операций может быть полезным для решения множества практических задач в различных областях.
