Как написать матрицу на питоне

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

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

Данные расположены по горизонтали, называемые строками, а по вертикали – столбцами. Количество элементов внутри матрицы равно (R) X (C), где R – строки, а C – столбцы. Python не имеет встроенного типа для матриц, поэтому мы будем использовать несколько списков в качестве матриц.

Мы изучим следующие операции, которые применяются к матрицам:

• сложение матриц;
• матричное вычитание;
• умножение матриц;
• скалярное произведение;
• векторное произведение;
• и многие другие операции.

Работа матриц

Приведенная ниже матрица имеет размер 2×2, что означает, что у нее две строки и два столбца.

 
[[2,4], 
[5,6]] 

Создание матрицы в Python

Мы можем создать матрицу на Python, используя вложенный список. Все элементы заключаются в квадратные скобки ([]) и разделяются запятой. Посмотрим на следующие примеры:

 
matrix = [[ 'Arun',  25, 90, 74], 
["Sachin", 410, 87.50, 130] 
[56, "Abhinay", 253, 471] 

• Мы создали матрицу 3×3, используя вложенный список.
• Первая строка содержит [‘Arun’, 25, 90, 74] в форме списка.
• Вторая строка содержит список [‘Sachin’, 410, 87.50, 130].
• Третья содержит [56, «Абхинай», 253, 471] в виде списка.
• Мы замечаем, что наша матрица состоит из чисел, а также строкового значения.

Чтение матричных данных

Прочитаем каждую строку определенной матрицы.

Пример –

 
matrix = [[ 'Arun',  25, 90, 74], 
['Sachin', 410, 87.50, 130], 
[56, 'Abhinay', 253, 471]] 
 
print("The matrix is: ", matrix) 

Выход:

 
The matrix is:  [['Arun', 25, 90, 74], ['Sachin', 410, 87.5, 130], [56, 'Abhinay', 253, 471]] 

В следующем примере мы прочитаем последний элемент каждой строки с помощью программы Python.

Пример –

 
matrix = [[ 'Arun',  25, 90, 74], 
['Sachin', 410, 87.50, 130], 
[56, 'Abhinay', 253, 471]] 
 
matrix_length = len(matrix) 
 
#To read the last element from each row. 
for i in range(matrix_length): 
    print(matrix[i][-1]) 

Выход:

74 
130 
471 

Объяснение:

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

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

Добавление двух матриц

Мы добавим две матрицы и, используя вложенный цикл for, пройдемся по заданным матрицам.

Пример –

 
mat1 = [[10, 13, 44],  
      [11, 2, 3],  
      [5, 3, 1]] 
 
mat2 = [[7, 16, -6], 
           [9, 20, -4],  
           [-1, 3 , 27]] 
 
mat3  = [[0,0,0], 
       [0,0,0], 
       [0,0,0]] 
matrix_length = len(mat1) 
 
#To Add mat1 and mat2 matrices 
for i in range(len(mat1)): 
    for k in range(len(mat2)): 
        mat3[i][k] = mat1[i][k] + mat2[i][k] 
 
#To Print the matrix 
print("The sum of Matrix mat1 and mat2 = ", mat3) 

Выход:

The sum of Matrix M1 and M2 =  [[17, 29, 38], [20, 22, -1], [4, 6, 28]] 

Объяснение:

• Первая и вторая матрицы – 3×3.
• Мы инициализировали еще одну матрицу mat3, в которой будет храниться равнодействующая матрица.
• Применили вложенный цикл for для перебора матриц, внешний цикл перебирает первую матрицу.
• Управление передается во внутренний цикл; затем переходит ко второму внутреннему циклу, здесь значение i равно нулю, и k также равно нулю.
• В первой итерации первые элементы mat1 и mat2, добавленные друг к другу, будет продолжаться до тех пор, пока не будут добавлены все элементы.

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

Умножение двух матриц такое же, как в приведенном выше коде,  только нужно изменить оператор + на *.

Пример –

 
mat1 = [[10, 13, 44], 
      [11, 2, 3], 
      [5, 3, 1]] 
 
mat2 = [[7, 16, -6], 
           [9, 20, -4], 
           [-1, 3 , 27]] 
 
mat3  = [[0,0,0], 
       [0,0,0], 
       [0,0,0]] 
matrix_length = len(mat1) 
 
#To Add mat1 and mat2 matrices 
for i in range(len(mat1)): 
    for k in range(len(mat2)): 
        mat3[i][k] = mat1[i][k]  * mat2[i][k] 
 
#To Print the matrix 
print("The sum of Matrix mat1 and mat2 = ", mat3) 

Выход:

The sum of Matrix mat1 and mat2 =  [[70, 208, -264], [99, 40, -12], [-5, 9, 27]] 

Транспонирование матрицы

Транспонирование – это операция, при которой строка данной матрицы преобразуется в столбец и наоборот. Рассмотрим на примере.

Пример –

 
# Program to transpose a matrix using a nested loop 
 
mat1 = [[12,7], 
    [4 ,5], 
    [3 ,8]] 
 
res = [[0,0,0], 
         [0,0,0]] 
 
# iterate through rows 
for i in range(len(mat1)): 
   # iterate through columns 
   for j in range(len(mat1[0])): 
       res[j][i] = mat1[i][j] 
 
for r in res: 
   print(r) 

Выход:

[12, 4, 3] 
[7, 5, 8] 

Объяснение:

В приведенном выше коде у нас есть два цикла for для перебора каждой строки и каждого столбца. Как мы видим, в приведенном выше выводе мы присвоили mat1 [i] [j] и res [j] [k].

Транспонирование с помощью списка

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

Пример –

 
mat1 = [[12,7], 
    [4 ,5], 
    [3 ,8]] 
 
res = [[0,0,0], 
         [0,0,0]] 
 
res = [[mat1[j][i] for j in range(len(mat1))] for i in range(len(mat1[0]))] 
 
for r in res: 
   print(r) 

Выход:

[12, 4, 3] 
[7, 5, 8] 

Результат такой же, как и выше. Значение списка сократило количество строк кода и транспонировало матрицу.

Получение матричного ввода от пользователя

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

Пример –

 
# A example for matrix input from user  
row = int(input("Enter the number of rows:"))  
column = int(input("Enter the number of columns:"))  
 
# Initialize empty matrix  
matrix = []  
print("Enter the entries row wise:")  
 
# For user input  
for i in range(row):       # A outer for loop for row entries  
   a =[]  
   for j in range(column):     # A inner for loop for column entries  
      a.append(int(input()))  
   matrix.append(a)  
 
# For printing the matrix  
for i in range(row):  
   for j in range(column):  
      print(matrix[i][j], end = " ")  
   print()  

Выход:

Enter the number of rows:3 
Enter the number of columns:3 
Enter the entries row wise: 
5 
6 
7 
8 
9 
2 
4 
3 
1 
5 6 7  
8 9 2  
4 3 1 

Объяснение:

В приведенном выше коде мы взяли данные пользователя, чтобы ввести количество строк и столбцов. Мы ввели 3 строки и 3 столбца; это означает, что в матрице будет 9 элементов. В цикле for элементы вставляются в пустую матрицу с помощью функции append(). Второй цикл for используется для печати входных данных в матричном формате.

Использование функции NumPy и map()

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

Пример: Создание матрицы с использованием библиотеки NumPy

Библиотека NumPy помогает нам работать с массивом. Чтобы работать с NumPy, нам нужно установить ее, используя следующую команду.

 
pip install Numpy  

После успешной установки мы должны импортировать ее в нашу программу.

 
import numpy as np 

Давайте разберемся в следующем примере.

Пример –

 
import numpy as np 
mat1 = np.array([[10, -5, 15], [30, -6, 91], [2, 8, 7]]) 
print("The matrix is: ") 
print(mat1) 

Выход:

The matrix is:  
[[10 -5 15] 
[30 -6 91] 
[ 2  8  7]] 

Работа с матрицей с помощью NumPy

Мы можем выполнять все операции с матрицей, используя numpy.array(), такие как сложение, вычитание, транспонирование, нарезание матрицы и т. д.

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

Мы создадим две матрицы с помощью функции numpy.array() и добавим их с помощью оператора +. Давайте разберемся в следующем примере.

Пример –

 
import numpy as np 
mat1 = np.array([[7, 8, 9], [3, -1, 17], [15, 10, 21]]) 
mat2 = np.array([[9, -18, 27], [11, 22, 33], [13, -26, 39]]) 
mat3 = mat1 + mat2   
print("The matrix addition is: ") 
print(mat3) 

Выход:

The matrix addition is:  
[[ 16 -10  36] 
 [ 14  21  50] 
 [ 28 -16  60]] 

Умножение

Мы будем использовать метод numpy.dot() для умножения обеих матриц. Это точечное умножение матриц mat1 и mat2, обрабатывает 2D-массив и выполняет умножение.

Пример –

 
import numpy as np 
mat1 = np.array([[4, 6], [5, 10]]) 
mat2 =  np.array([[3, -1], [11, 22]]) 
mat3 = mat1.dot(mat2)   
print("The matrix is:") 
print(mat3) 

Выход:

The matrix is: 
[[ 78 128] 
 [125 215]] 

Нарезка элементов

Мы можем разрезать элемент матрицы, как в стандартном списке Python. Нарезка возвращает элемент на основе индекса начала / конца. Мы также можем сделать отрицательную нарезку. Синтаксис приведен ниже.

Синтаксис –

 
arr[start: end]  

Arr представляет имя матрицы. По умолчанию начальный индекс равен 0, например – [: 3], это означает, что начальный индекс равен 0. Если мы не предоставим конечное значение, он будет учитывать длину массива. Мы можем передавать отрицательные значения индекса как в начало, так и в конец. В следующем примере мы применим нарезку в обычном массиве, чтобы понять, как она работает.

Пример –

 
import numpy as np 
 
arr = np.array([10,40,61,14,25,12,97]) 
print(arr[2:5]) # It will print the elements from 2 to 4 
print(arr[:4]) # It will print the elements from 0 to 3 
print(arr[3:]) # It will print the elements from 3 to length of the array. 

Выход:

[61 14 25] 
[10 40 61 14] 
[14 25 12 97] 

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

Mat1 [row_start: row_end, col_start: col_end]

В приведенном выше синтаксисе:

• Первое начало / конец представляет строки, которые означают выбор строк матрицы.
• Первое начало / конец представляет столбцы, которые означают выбор столбца матрицы.

Мы будем выполнять нарезку в приведенной ниже матрице.

 
mat1 = np.array([[4, 10, 60, 18, 20], 
    [35, 16, 19, -12, 41], 
    [23, 80, 42, 24, -20], 
    [7, -10, 15, 40, 17]]) 

Вышеупомянутая матрица состоит из четырех строк. В 0-м ряду есть [4, 10, 60, 18, 20], в 1-й строке – [35, 16, 19, -12, 41] и так далее. В нем пять столбцов. Рассмотрим на примере.

Пример –

 
import numpy as np  
mat1 = np.array([[4, 10, 60, 18, 20], 
    [35, 16, 19, -12, 41], 
    [23, 80, 42, 24, -20], 
    [7, -10, 15, 40, 17]]) 
print(mat1[1:3, 1:4]) 

Выход:

[[ 16  19 -12] 
 [ 80  42  24]] 

Объяснение:

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

Пример – печать первой строки и всех столбцов:

 
import numpy as np 
mat1 = np.array([[4, 10, 60, 18, 20], 
    [35, 16, 19, -12, 41], 
    [23, 80, 42, 24, -20], 
    [7, -10, 15, 40, 17]]) 
print(mat1[:1, ]) 

Выход:

[ 4 10 60 18 20]] 

Пример – печать строк матрицы:

 
import numpy as np 
mat1 = np.array([[14, 60, 29], [35, -10, 13], [4,8,12]]) 
print(mat1[0])  #first row 
print(mat1[1]) # the second row 
print(mat1[-1]) # -1 will print the last row 

Выход:

[14 60 29] 
[ 35 -10  13] 
[ 4  8 12] 

Заключение

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

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

В этой статье мы опишем несколько способов создать матрицу в 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. Понимание матриц и их операций может быть полезным для решения множества практических задач в различных областях.

Here we will discuss different ways how we can form a matrix using Python within this tutorial we will also discuss the various operation that can be performed on a matrix. we will also cover the external module Numpy to form a matrix and its operations in Python.

What is the matrix?

A matrix is a collection of numbers arranged in a rectangular array in rows and columns. In the fields of engineering, physics, statistics, and graphics, matrices are widely used to express picture rotations and other types of transformations.
The matrix is referred to as an m by n matrix, denoted by the symbol “m x n” if there are m rows and n columns.

Creating a simple matrix using Python

Method 1: Creating a matrix with a List of list

Here, we are going to create a matrix using the list of lists.

Output:

Matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

Method 2: Take Matrix input from user in Python

Here, we are taking a number of rows and columns from the user and printing the Matrix.

Output:

Enter the number of rows:2
Enter the number of columns:2
Enter the entries row wise:
5
6
7
8

5 6 
7 8 

Time Complexity: O(n*n)
Auxiliary Space: O(n*n)

Method 3: Create a matrix using list comprehension

List comprehension is an elegant way to define and create a list in Python, we are using the range function for printing 4 rows and 4 columns.

Output:

[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]

Assigning Value in a matrix

Method 1: Assign value to an individual cell in Matrix

Here we are replacing and assigning value to an individual cell (1 row and 1 column = 11) in the Matrix.

Output:

[[1, 2, 3], [4, 11, 6], [7, 8, 9]]

Method 2: Assign a value to an individual cell using negative indexing in Matrix

Here we are replacing and assigning value to an individual cell (-2 row and -1 column = 21) in the Matrix.

Output:

[[1, 2, 3], [4, 5, 21], [7, 8, 9]]

Accessing Value in a matrix

Method 1: Accessing Matrix values

Here, we are accessing elements of a Matrix by passing its row and column.

Output:

Matrix at 1 row and 3 column= 3
Matrix at 3 row and 3 column= 9

Method 2: Accessing Matrix values using negative indexing

Here, we are accessing elements of a Matrix by passing its row and column on negative indexing.

Output:

8

Mathematical Operations with Matrix in Python

Example 1: Adding values to a matrix with a for loop in python

Here, we are adding two matrices using the Python for-loop.

Output:

[10, 10, 10]
[10, 10, 10]
[10, 10, 10]

Time Complexity: O(n*n)
Auxiliary Space: O(n*n)

Example 2: Adding and subtracting values to a matrix with list comprehension

Performing the Basic addition and subtraction using list comprehension.

Output:

Matrix Addition
[10, 10, 10]
[10, 10, 10]
[10, 10, 10]


Matrix Subtraction
[-8, -6, -4]
[-2, 0, 2]
[4, 6, 8]

Time Complexity: O(n*n)
Auxiliary Space: O(n*n)

Example 3: Python program to multiply and divide two matrices

Performing the Basic multiplication and division using Python loop.

Output:

Matrix Multiplication
[9, 16, 21]
[24, 25, 24]
[21, 16, 9]

Matrix Division
[0, 0, 0]
[0, 1, 1]
[2, 4, 9]

Time Complexity: O(n*n)
Auxiliary Space: O(n*n)

Transpose in matrix

Example: Python Program to Transpose a Matrix using loop

Transpose of a matrix is obtained by changing rows to columns and columns to rows. In other words, transpose of A[][] is obtained by changing A[i][j] to A[j][i].

Output:

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

Time Complexity: O(n*n)
Auxiliary Space: O(n*n)

Matrix using Numpy

Create a matrix using Numpy 

Here we are creating a Numpy array using numpy.random and a random module.

Output:

[[2 7 5]
 [8 5 1]
 [8 4 6]]

Matrix mathematical operations in Python Using Numpy

Here we are covering different mathematical operations such as addition subtraction, multiplication, and division using Numpy.

Output:

The element wise addition of matrix is : 
[[ 8 10]
 [13 15]]
The element wise subtraction of matrix is : 
[[-6 -6]
 [-5 -5]]
The element wise multiplication of matrix is : 
[[ 7 16]
 [36 50]]
The element wise division of matrix is : 
[[0.14285714 0.25      ]
 [0.44444444 0.5       ]]

Dot and cross product with Matrix

Here, we will find the inner, outer, and cross products of matrices and vectors using NumPy in Python.

Output:

Dot product of two array is: [[ 30  24  18]
 [ 84  69  54]
 [138 114  90]]
Cross product of two array is: [[-10  20 -10]
 [-10  20 -10]
 [-10  20 -10]]

Matrix transpose in Python using Numpy

To perform transpose operation in matrix we can use the numpy.transpose() method.

Output:

[[1 4][2 5][3 6]]

Create an empty matrix with NumPy in Python

Initializing an empty array, using the np.zeros().

Output:

Matrix of 2x2: 
 [[0 0]
 [0 0]]

Matrix of 3x3: 
 [[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

Slicing in Matrix using Numpy

Slicing is the process of choosing specific rows and columns from a matrix and then creating a new matrix by removing all of the non-selected elements. In the first example, we are printing the whole matrix, in the second we are passing 2 as an initial index, 3 as the last index, and index jump as 1. The same is used in the next print we have just changed the index jump to 2.

Output:

[[  6   8  10]
 [  9 -12  15]
 [ 12  16  20]
 [ 15 -20  25]]

 Slicing Third Row-Second Column: [16]

 Slicing Third Row-Third Column: [20]

Delete rows and columns using Numpy

Here, we are trying to delete rows using the np.delete() function. In the code, we first tried to delete the 0_^th row, then we tried to delete the 2_nd row, and then the 3_rd row.

Output:

data after 0 th row deleted: 
[[  9 -12  15]
 [ 12  16  20]
 [ 15 -20  25]]

data after 1 st row deleted: 
[[  6   8  10]
 [ 12  16  20]
 [ 15 -20  25]]

data after 2 nd row deleted: 
[[  6   8  10]
 [  9 -12  15]
 [ 15 -20  25]]

Add row/columns in the Numpy array

We added one more column at the 4_th position using np.hstack. 

Output:

resultant array
 [[  6   8  10   1]
 [  9 -12  15   2]
 [ 15 -20  25   3]]

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

В Python подобные таблицы можно представить в виде списка, элементы которого являются другими списками. Для примера создадим таблицу с тремя столбцами и тремя строками, заполненными произвольными буквами:

mas = [['й', 'ц', 'у'], ['к','е','н'], ['г', 'ш', 'щ']] 
#Вывод всего двумерного массива 
print(mas) 
#Вывод первого элемента в первой строке 
print(mas[0][0]) # Выведет й 
#Вывод третьего элемента в третьей строке 
print(mas[2][2]) # Выведет щ 

Создание двумерных массивов

Создать такой массив в Python можно разными способами. Разберем первый:

# Создание таблицы с размером 3x3, заполненной нулями
a = 3           
mas = [0] * a 
for i in range(a): 
    mas[i] = [0] * a 
print(mas) # Выведет [[0, 0, 0], [0, 0, 0], [0, 0, 0]]     

Второй способ предполагает создание пустого списка с добавлением в него новых списков. Рассмотрим на примере:

# Создание таблицы с размером 2x2, заполненной единицами

a = 2
mas = [] 
for i in range(a): 
    mas.append([0] * a)
print(mas) # Выведет [[1, 1, 1], [1, 1, 1], [1, 1, 1]]                                 

Третьим и самым простым способом является генератор списков с x строками, которые будут состоять из y элементов. Пример: 

# Создание таблицы с размером 3x3, заполненной двойками
a = 3
mas = [[2] * a for i in range(a)]
print(mas) # Выведет [[2, 2, 2], [2, 2, 2], [2, 2, 2]]

Способы ввода двумерных массивов

Допустим, нам нужно ввести двумерный массив после запуска нашей программы. Для этого мы можем создать программу, которая будет построчно считывать значения нашего массива, а также количество строк в нем. Рассмотрим на примере:

a=int(input())
mas = [] 
for i in range(a): 
    mas.append(list(map(int, input().split())))
print(mas) 

Запускаем программу и сначала вводим количество строк в массиве (допустим, 3). Далее вводим строки в порядке их очереди. Например:

1 1 1
1 1 1
1 1 1

После этого данная программа выведет наш двумерный массив: [[1, 1, 1], [1, 1, 1], [1, 1, 1]].

То же самое можно сделать с помощью генератора двумерных массивов:

mas = [list(map(int, input().split())) for i in range(int(input()))]
# Вводим 
3
1 1 1
1 1 1
1 1 1
print(mas) # Выведет [[1, 1, 1], [1, 1, 1], [1, 1, 1]]

Вывод двумерных массивов

Для обработки и вывода списков используются два вложенных цикла. Первый цикл – по порядковому номеру строки, второй – по ее элементам. Например, вывести массив можно так:

mas = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
for i in range(0, len(mas)):
    for i2 in range(0, len(mas[i])):
        print(mas[i][i2], end=' ')
    print()
# Выведет
1 1 1
1 1 1
1 1 1

То же самое можно сделать не по индексам, а по значениям массива:

mas = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
for i in mas: 
    for i2 in i: 
        print(i2, end=' ') 
    print()
# Выведет
1 1 1
1 1 1
1 1 1

Способ с использованием метода join():

mas = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
for i in mas: 
    print(' '.join(list(map(str, i))))
# Выведет
1 1 1
1 1 1
1 1 1

Вывод одной из строк двумерного массива можно осуществить с помощью цикла и того же метода join(). Для примера выведем вторую строку в произвольном двумерном массиве:

mas = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
string = 2
for i in mas[string-1]:
    print(i, end=' ')
# Выведет 1 1 1

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

mas = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
column = 2
for i in mas:
    print(i[column-1], end=' ')
# Выведет 2 5 8

Обработка двумерных массивов

Составим произвольный двумерный массив с числами и размерностью 4×4:

2 4 7 3
4 5 6 9
1 0 4 2
7 8 4 7

Теперь поставим числа в каждой строке по порядку:

mas = [[2, 4, 7, 3], [4, 5, 6, 9], [1, 0, 4, 2], [7, 8, 4, 7]]
mas2 = []
for i in mas:
    mas2.append(sorted(i))
print(mas2)
# Выведет [[2, 3, 4, 7], [4, 5, 6, 9], [0, 1, 2, 4], [4, 7, 7, 8]]

А теперь расставим все числа по порядку, вне зависимости от их нахождения в определенной строке:

mas = [[2, 4, 7, 3], [4, 5, 6, 9], [1, 0, 4, 2], [7, 8, 4, 7]]
mas2 = []
for i in mas:
    for i2 in i:
        mas2.append(i2)
mas=sorted(mas2)
for x in range(0, len(mas), 4):
    e_c = mas[x : 4 + x]
    if len(e_c) < 4:
        e_c = e_c + [None for y in range(n - len(e_c))]
    print(list(e_c))
# Выведет
[0, 1, 2, 2]
[3, 4, 4, 4]
[4, 5, 6, 7]
[7, 7, 8, 9]

Итог

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

Мы можем реализовать матрицу Python в форме 2-го списка или 2-го массива. Для выполнения операций с Python Matrix нам необходимо импортировать Python NumPy Module.

Matrix важен в области статистики, обработки данных, обработки изображений и т. д.

Матрицу Python можно создать одним из следующих способов:

• Используя списки
• Используя метод arange()
• и метода matrix()

1 С использованием списков

numpy.array() можно использовать для создания массива, используя списки в качестве входных данных.

Пример:

import numpy
input_arr = numpy.array([[ 10, 20, 30],[ 40, 50, 60]])
print(input_arr)

Выход:

[[10 20 30]
 [40 50 60]]

Как видно выше, выходные данные представляют собой двумерную матрицу с заданным набором входных данных в виде списка.

2 С помощью функции numpy.arange()

numpy.arange() вместе со списком входов.

Пример:

import numpy

print(numpy.array([numpy.arange(10,15), numpy.arange(15,20)]))
 

Выход:

[[10 11 12 13 14]
 [15 16 17 18 19]]

3 С помощью функции numpy.matrix().

Функция numpy.matrix() , ее синтаксис:

numpy.matrix(input,dtype)

• input: элементы input для формирования матрицы.
• dtype: тип данных соответствующего вывода.

Пример:

import numpy as p


matA = p.matrix([[10, 20], [30, 40]])  
print('MatrixA:n', matA)



matB = p.matrix('[10,20;30,40]', dtype=p.int32)  # Setting the data-type to int
print('nMatrixB:n', matB)

Выход:

MatrixA:
 [[10 20]
 [30 40]]

MatrixB:
 [[10 20]
 [30 40]]

Сложение

Операцию сложения матриц можно выполнить следующими способами:

• Традиционный метод
• Используя оператор ‘+’

1 Традиционный метод

В этом традиционном методе мы в основном берем ввод от пользователя, а затем выполняем операцию сложения с использованием циклов for (для обхода элементов матрицы) и оператора ‘+’.

Пример:

import numpy as p


ar1 = p.matrix([[11, 22], [33, 44]])  
ar2 = p.matrix([[55, 66], [77, 88]])  
res = p.matrix(p.zeros((2,2)))  
print('Matrix ar1 :n', ar1)
print('nMatrix ar2 :n', ar2)

# traditional code
for x in range(ar1.shape[1]):
    for y in range(ar2.shape[0]):
        res[x, y] = ar1[x, y] + ar2[x, y]

print('nResult :n', res)

Примечание. Matrix.shape возвращает размеры конкретной матрицы.

Выход:

Matrix ar1 :
 [[11 22]
 [33 44]]

Matrix ar2 :
 [[55 66]
 [77 88]]

Result :
 [[  66.   88.]
 [ 110.  132.]]

2 Использование оператора «+»

Этот метод обеспечивает большую эффективность кода, поскольку он уменьшает LOC (количество строк кода) и, таким образом, оптимизирует код.

Пример:

import numpy as p


ar1 = p.matrix([[11, 22], [33, 44]])  
ar2 = p.matrix([[55, 66], [77, 88]])  
res = p.matrix(p.zeros((2,2)))  
print('Matrix ar1 :n', ar1)
print('nMatrix ar2 :n', ar2)

res = ar1 + ar2 # using '+' operator

print('nResult :n', res)

Выход:

Matrix ar1 :
 [[11 22]
 [33 44]]

Matrix ar2 :
 [[55 66]
 [77 88]]

Result :
 [[ 66  88]
 [110 132]]

Умножение матриц

Умножение матриц в Python можно обеспечить следующими способами:

• Скалярное произведение;
• Матричный продукт.

Скалярное произведение

В скалярном произведении постоянное значение умножается на каждый элемент матрицы.

Оператор ‘*’ используется для умножения скалярного значения на элементы входной матрицы.

Пример:

import numpy as p

matA = p.matrix([[11, 22], [33, 44]])  

print("Matrix A:n", matA)
print("Scalar Product of Matrix A:n", matA * 10)

Выход:

Matrix A:
 [[11 22]
 [33 44]]
Scalar Product of Matrix A:
 [[110 220]
 [330 440]]

Функция numpy.dot()

Как упоминалось выше, мы можем использовать оператор ‘*’ только для скалярного умножения. Чтобы продолжить умножение матриц, нам нужно использовать numpy.dot() .

Функция numpy.dot() принимает массивы NumPy в качестве значений параметров и выполняет умножение в соответствии с основными правилами умножения матриц.

Пример:

import numpy as p

matA = p.matrix([[11, 22], [33, 44]])  
matB = p.matrix([[2,2], [2,2]])

print("Matrix A:n", matA)
print("Matrix B:n", matB)
print("Dot Product of Matrix A and Matrix B:n", p.dot(matA, matB))

Выход:

Matrix A:
 [[11 22]
 [33 44]]
Matrix B:
 [[2 2]
 [2 2]]
Dot Product of Matrix A and Matrix B:
 [[ 66  66]
 [154 154]]

Вычитание

Оператор ‘-‘ используется для выполнения вычитания матриц.

Пример:

import numpy as p

matA = p.matrix([[11, 22], [33, 44]])  
matB = p.matrix([[2,2], [2,2]])

print("Matrix A:n", matA)
print("Matrix B:n", matB)
print("Subtraction of Matrix A and Matrix B:n",(matA - matB))
 

Выход:

Matrix A:
 [[11 22]
 [33 44]]
Matrix B:
 [[2 2]
 [2 2]]
Subtraction of Matrix A and Matrix B:
 [[ 9 20]
 [31 42]]

Деление

Скалярное деление может выполняться на элементах матрицы в Python с помощью оператора ‘/’.

Оператор ‘/’ делит каждый элемент матрицы на скалярное / постоянное значение.

Пример:

import numpy as p


matB = p.matrix([[2,2], [2,2]])


print("Matrix B:n", matB)
print("Matrix B after Scalar Division operation:n",(matB/2))
 

Выход:

Matrix B:
 [[2 2]
 [2 2]]
Matrix B after Scalar Division operation:
 [[ 1.  1.]
 [ 1.  1.]]

Транспонирование матрицы

Транспонирование матрицы в основном включает в себя переворачивание матрицы по соответствующим диагоналям, т. е. Меняет местами строки и столбцы входной матрицы. Строки становятся столбцами и наоборот.

Например: давайте рассмотрим матрицу A с размерами 3 × 2, т.е. 3 строки и 2 столбца. После выполнения операции транспонирования размеры матрицы A будут 2 × 3, т.е. 2 строки и 3 столбца.

Matrix.T основном выполняет транспонирование входной матрицы и создает новую в результате операции транспонирования.

Пример:

import numpy
 
matA = numpy.array([numpy.arange(10,15), numpy.arange(15,20)])
print("Original Matrix A:n")
print(matA)
print('nDimensions of the original MatrixA: ',matA.shape)
print("nTranspose of Matrix A:n ")
res = matA.T
print(res)
print('nDimensions of the Matrix A after performing the Transpose Operation:  ',res.shape)

Выход:

Original Matrix A:

[[10 11 12 13 14]
 [15 16 17 18 19]]

Dimensions of the original MatrixA: (2, 5)

Transpose of Matrix A:
 
[[10 15]
 [11 16]
 [12 17]
 [13 18]
 [14 19]]

Dimensions of the Matrix A after performing the Transpose Operation: (5, 2)

В приведенном выше фрагменте кода я создал матрицу размером 2 × 5, т.е. 2 строки и 5 столбцов.

После выполнения операции транспонирования размеры результирующей матрицы составляют 5 × 2, то есть 5 строк и 2 столбца.

Экспонента

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

Пример:

import numpy
 
matA = numpy.array([numpy.arange(0,2), numpy.arange(2,4)])
print("Original Matrix A:n")
print(matA)
print("Exponent of the input matrix:n")
print(matA ** 2) # finding the exponent of every element of the matrix

Выход:

Original Matrix A:

[[0 1]
 [2 3]]

Exponent of the input matrix:

[[0 1]
 [4 9]]

В приведенном выше фрагменте кода мы выяснили показатель степени каждого элемента входной матрицы, возведя его в степень 2.

Операция умножения с использованием методов NumPy

Для выполнения умножения матрицы NumPy можно использовать следующие методы:

• Использование метода multiply();
• метода matmul();
• Использование метода dot() — уже описано в этой статье.

Метод 1: использование метода multiply()

Метод numpy.multiply() выполняет поэлементное умножение входной матрицы.

Пример:

import numpy as p


matA = p.matrix([[10, 20], [30, 40]])  
print('MatrixA:n', matA)



matB = p.matrix('[10,20;30,40]', dtype=p.int32)  # Setting the data-type to int
print('nMatrixB:n', matB)

print("Matrix multplication using numpy.matrix() method")
res = p.multiply(matA,matB)
print(res)

Выход:

MatrixA:
 [[10 20]
 [30 40]]

MatrixB:
 [[10 20]
 [30 40]]
Matrix multplication using numpy.matrix() method
[[ 100  400]
 [ 900 1600]]

Метод 2: использование метода matmul()

Метод numpy.matmul() выполняет матричное произведение.

Пример:

import numpy as p


matA = p.matrix([[10, 20], [30, 40]])  
print('MatrixA:n', matA)



matB = p.matrix('[10,20;30,40]', dtype=p.int32)  # Setting the data-type to int
print('nMatrixB:n', matB)

print("Matrix multplication using numpy.matmul() method")
res = p.matmul(matA,matB)
print(res)

Выход:

MatrixA:
 [[10 20]
 [30 40]]

MatrixB:
 [[10 20]
 [30 40]]
Matrix multplication using numpy.matmul() method
[[ 700 1000]
 [1500 2200]]

Транспонирование матрицы NumPy

Функция numpy.transpose() выполняет транспонирование.

Пример:

import numpy
 
matA = numpy.array([numpy.arange(10,15), numpy.arange(15,20)])
print("Original Matrix A:n")
print(matA)
print('nDimensions of the original MatrixA: ',matA.shape)
print("nTranspose of Matrix A:n ")
res = matA.transpose()
print(res)
print('nDimensions of the Matrix A after performing the Transpose Operation:  ',res.shape)

Выход:

Original Matrix A:

[[10 11 12 13 14]
 [15 16 17 18 19]]

Dimensions of the original MatrixA: (2, 5)

Transpose of Matrix A:
 
[[10 15]
 [11 16]
 [12 17]
 [13 18]
 [14 19]]

Dimensions of the Matrix A after performing the Transpose Operation: (5, 2)