Матрицы в python: Как создать матрицу в Python: инструкция

Как создать матрицу в Python: инструкция

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

В этой статье мы опишем несколько способов создать матрицу в Python. И дополнительно рассмотрим некоторые основные операции, такие как сложение, умножение и определение обратной матрицы.

Что такое матрица

Матрица — это таблица из чисел, которая используется в математике и инженерных науках для представления данных. Матрицы имеют форму таблицы, состоящей из строк и столбцов. Каждый элемент имеет свой уникальный индекс, обозначающий строку и столбец, в котором он находится. Например, матрица размером 3×3 будет иметь 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.

Заключение

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

Изучаем матрицы в питоне и массивы NumPy в Python

Матрица — это двухмерная структура данных, в которой числа расположены в виде строк и столбцов. Например:

Эта матрица является матрицей три на четыре, потому что она состоит из 3 строк и 4 столбцов.

• Матрицы в Python
• NumPy массивы в Python
• Как создать массив NumPy?
  • Массив целых чисел, чисел с плавающей точкой и составных чисел
  • Массив нулей и единиц
  • Использование arange() и shape()
• Операции с матрицами
  • Сложение двух матриц или сумма элементов массива Python
  • Умножение двух матриц Python
  • Транспонирование матрицы питон
• Доступ к элементам матрицы, строкам и столбца
  • Доступ к элементам матрицы
  • Доступ к строкам матрицы
  • Доступ к столбцам матрицы
• Разделение матрицы

Python не имеет встроенного типа данных для матриц. Но можно рассматривать список как матрицу. Например:

A = [[1, 4, 5], 
    [-5, 8, 9]]

Этот список является матрицей на 2 строки и 3 столбца.

Обязательно ознакомьтесь с документацией по спискам Python, прежде чем продолжить читать эту статью.

Давайте посмотрим, как работать с вложенным списком.

A = [[1, 4, 5, 12], 
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]]
print("A =", A) 
print("A[1] =", A[1])      # вторая строка
print("A[1][2] =", A[1][2])   # третий элемент второй строки
print("A[0][-1] =", A[0][-1])   # последний элемент первой строки
column = [];        # пустой список
for row in A:
  column.append(row[2])   
print("3rd column =", column)

Когда мы запустим эту программу, результат будет следующий:

A = [[1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19]]
A [1] = [-5, 8, 9, 0]
A [1] [2] = 9
A [0] [- 1] = 12
3-й столбец = [5, 9, 11]

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

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

• Ознакомьтесь: Как установить NumPy Python?
• Если вы работаете в Windows, скачайте и установите дистрибутив anaconda Python. Он поставляется вместе с NumPy и другими расширениями.

После установки NumPy можно импортировать и использовать его.

NumPy предоставляет собой многомерный массив чисел (который на самом деле является объектом). Давайте рассмотрим приведенный ниже пример:

import numpy as np
a = np.array([1, 2, 3])
print(a)               # Вывод: [1, 2, 3]
print(type(a))         # Вывод: <class 'numpy.ndarray'>

Как видите, класс массива NumPy называется ndarray.

Существует несколько способов создания массивов NumPy.

import numpy as np
A = np.array([[1, 2, 3], [3, 4, 5]])
print(A)
A = np.array([[1.1, 2, 3], [3, 4, 5]]) # Массив чисел с плавающей запятой
print(A)
A = np. array([[1, 2, 3], [3, 4, 5]], dtype = complex) # Массив составных чисел
print(A)

Когда вы запустите эту программу, результат будет следующий:

[[1 2 3]
 [3 4 5]]
[[1.1 2. 3.]
 [3. 4. 5.]]
[[1. + 0.j 2. + 0.j 3. + 0.j]
 [3. + 0.j 4. + 0.j 5. + 0.j]]

import numpy as np
zeors_array = np.zeros( (2, 3) )
print(zeors_array)
'''
 Вывод:
 [[0. 0. 0.]
  [0. 0. 0.]]
'''
ones_array = np.ones( (1, 5), dtype=np.int32 ) // указание dtype
print(ones_array)      # Вывод: [[1 1 1 1 1]]

Здесь мы указали dtype — 32 бита (4 байта). Следовательно, этот массив может принимать значения от -2^-31 до 2^-31-1.

import numpy as np
A = np.arange(4)
print('A =', A)
B = np.arange(12).reshape(2, 6)
print('B =', B)
''' 
Вывод:
A = [0 1 2 3]
B = [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
'''

Узнайте больше о других способах создания массива NumPy .

Выше мы привели пример сложение, умножение матриц и транспонирование матрицы. Мы использовали вложенные списки, прежде чем создавать эти программы.

Мы используем оператор +, чтобы сложить соответствующие элементы двух матриц NumPy.

import numpy as np
A = np.array([[2, 4], [5, -6]])
B = np.array([[9, -3], [3, 6]])
C = A + B      # сложение соответствующих элементов
print(C)
''' 
Вывод:
[[11  1]
 [ 8  0]]
 '''

Чтобы умножить две матрицы, мы используем метод dot(). Узнайте больше о том, как работает numpy.dot .

Примечание: * используется для умножения массива (умножения соответствующих элементов двух массивов), а не умножения матрицы.

import numpy as np
A = np.array([[3, 6, 7], [5, -3, 0]])
B = np.array([[1, 1], [2, 1], [3, -3]])
C = a.dot(B)
print(C)
''' 
Вывод:
[[ 36 -12]
 [ -1   2]]
'''

Мы используем numpy.transpose для вычисления транспонирования матрицы.

import numpy as np
A = np.array([[1, 1], [2, 1], [3, -3]])
print(A.transpose())
''' 
Вывод:
[[ 1  2  3]
 [ 1  1 -3]]
'''

Как видите, NumPy значительно упростил нашу задачу.

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

import numpy as np
A = np.array([2, 4, 6, 8, 10])
print("A[0] =", A[0])     # Первый элемент     
print("A[2] =", A[2])     # Третий элемент     
print("A[-1] =", A[-1])   # Последний элемент     

Когда вы запустите эту программу, результат будет следующий:

A [0] = 2
A [2] = 6
A [-1] = 10

Теперь выясним, как получить доступ к элементам двухмерного массива (который в основном представляет собой матрицу).

import numpy as np
A = np.array([[1, 4, 5, 12],
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
#  Первый элемент первой строки
print("A[0][0] =", A[0][0])  
# Третий элемент второй строки
print("A[1][2] =", A[1][2])
# Последний элемент последней строки
print("A[-1][-1] =", A[-1][-1])     

Когда мы запустим эту программу, результат будет следующий:

A [0] [0] = 1
A [1] [2] = 9
A [-1] [- 1] = 19

import numpy as np
A = np.  array([[1, 4, 5, 12], 
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
print("A[0] =", A[0]) # Первая строка
print("A[2] =", A[2]) # Третья строка
print("A[-1] =", A[-1]) # Последняя строка (третья строка в данном случае)

Когда мы запустим эту программу, результат будет следующий:

A [0] = [1, 4, 5, 12]
A [2] = [-6, 7, 11, 19]
A [-1] = [-6, 7, 11, 19]

import numpy as np
A = np.array([[1, 4, 5, 12], 
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
print("A[:,0] =",A[:,0]) # Первый столбец
print("A[:,3] =", A[:,3]) # Четвертый столбец
print("A[:,-1] =", A[:,-1]) # Последний столбец (четвертый столбец в данном случае)

Когда мы запустим эту программу, результат будет следующий:

A [:, 0] = [1 -5 -6]
A [:, 3] = [12 0 19]
A [:, - 1] = [12 0 19]

Если вы не знаете, как работает приведенный выше код, прочтите раздел «Разделение матрицы».

Разделение одномерного массива NumPy аналогично разделению списка. Рассмотрим пример:

import numpy as np
letters = np. array([1, 3, 5, 7, 9, 7, 5])
# с 3-го по 5-ый элементы
print(letters[2:5])        # Вывод: [5, 7, 9]
# с 1-го по 4-ый элементы
print(letters[:-5])        # Вывод: [1, 3]   
# с 6-го до последнего элемента
print(letters[5:])         # Вывод:[7, 5]
# с 1-го до последнего элемента
print(letters[:])          # Вывод:[1, 3, 5, 7, 9, 7, 5]
# список в обратном порядке
print(letters[::-1])          # Вывод:[5, 7, 9, 7, 5, 3, 1]

Теперь посмотрим, как разделить матрицу.

import numpy as np
A = np.array([[1, 4, 5, 12, 14], 
    [-5, 8, 9, 0, 17],
    [-6, 7, 11, 19, 21]])
print(A[:2, :4])  # две строки, четыре столбца
''' Вывод:
[[ 1  4  5 12]
 [-5  8  9  0]]
'''
print(A[:1,])  # первая строка, все столбцы
''' Вывод:
[[ 1  4  5 12 14]]
'''
print(A[:,2])  # все строки, второй столбец
''' Вывод:
[ 5  9 11]
'''
print(A[:, 2:5])  # все строки, с третьего по пятый столбец
''' Вывод:
[[ 5 12 14]
 [ 9  0 17]
 [11 19 21]]
'''

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

Вадим Дворниковавтор-переводчик статьи «Python Matrices and NumPy Arrays»

Дайте знать, что вы думаете по этой теме материала в комментариях. За комментарии, дизлайки, отклики, лайки, подписки низкий вам поклон!

numpy.matrix — NumPy v1.24 Manual

Возвращает матрицу из объекта, подобного массиву, или из строки данных. Матрица — это специализированный двумерный массив, сохраняющий свою двумерную природу. посредством операций. Он имеет определенные специальные операторы, такие как * . (умножение матрицы) и ** (мощность матрицы).

Матрица Python — Javatpoint

 ['4' '6' 'Гарри']
Тип данных объекта массива: 
 

 Матрица:
 [['Итика' '89' '91']
 ['Адити' '96' '82']
 ['Гарри' '91' '81']
 ['Эндрю' '87' '91']
 ['Питер' '72' '79']]
 

 [[3 4]
 [5 6]]
 

 ['Итика' '89' '91']
Оценки Эндрю по предмету Матрица: 91
 

 Массив целых чисел типа данных:
 [[4 2 7 3]
 [2 8 5 2]]
Массив данных типа float:
 [[1,5 2,2 3,1]
 [3. 4.4 2. ]]
Массив комплексных чисел типа данных:
 [[5.+0.к 3.+0.к 6.+0.к]
 [2.+0.к 5.+0.к 7. +0.к]]
 

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

 [0 1 2 3 4]
[[0 1 2]
 [3 4 5]]
 

 Сумма матриц = [[27, 46, 11], [49, 17, 21], [23, 8, 17]]
 

 [[44 26]
 [68 42]]
 

 [66, 60, 64, 62]
[108, 86, 124, 90]
[85, 67, 103, 68]
 

 [[-3.33333333e-01 -7.40148683e-17 3.33333333e-01]
 [ 1.25000000e-01 -3.75000000e-01 3.12500000e-01]
 [ 2.50000000e-01 2.50000000e-01 -3.75000000e-01]]
 

 [4, 3, 7]
[6, 7, 3]
[7, 2, 7]
[8, 7, 5]
 

 [[5 4]
 [7 2]
 [6 4]]