Матрицы являются одним из основных объектов в математике. Они используются для представления и манипулирования данными в виде таблицы, состоящей из строк и столбцов. Их используют для решения систем линейных уравнений, определения матричных действий, преобразования координат и многого другое.
В этой статье мы опишем несколько способов создать матрицу в 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 npmatrix = 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. Понимание матриц и их операций может быть полезным для решения множества практических задач в различных областях.
В этой статье мы познакомим вас с матрицей 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 вместе с вами, читаю, собираю и записываю информацию опытных программистов.
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.
Python3
matrix = [[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]]
print("Matrix =", matrix)
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.
Python3
Row = int(input("Enter the number of rows:"))
Column = int(input("Enter the number of columns:"))
matrix = []
print("Enter the entries row wise:")
for row in range(Row):
a = []
for column in range(Column):
a.append(int(input()))
matrix.append(a)
for row in range(Row):
for column in range(Column):
print(matrix[row][column], end=" ")
print()
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.
Python3
matrix = [[column for column in range(4)] for row in range(4)]
print(matrix)
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.
Python3
X = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
row = column = 1
X[row][column] = 11
print(X)
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.
Python3
row = -2
column = -1
X[row][column] = 21
print(X)
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.
Python3
print("Matrix at 1 row and 3 column=", X[0][2])
print("Matrix at 3 row and 3 column=", X[2][2])
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.
Python3
import numpy as np
X = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(X[-1][-2])
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.
Python3
X = [[1, 2, 3],[4, 5, 6], [7, 8, 9]]
Y = [[9, 8, 7], [6, 5, 4], [3, 2, 1]]
result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for row in range(len(X)):
for column in range(len(X[0])):
result[row][column] = X[row][column]+ Y[row][column]
for r in result:
print(r)
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.
Python3
Add_result = [[X[row][column] + Y[row][column]
for column in range(len(X[0]))]
for row in range(len(X))]
Sub_result = [[X[row][column] - Y[row][column]
for column in range(len(X[0]))]
for row in range(len(X))]
print("Matrix Addition")
for r in Add_result:
print(r)
print("nMatrix Subtraction")
for r in Sub_result:
print(r)
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.
Python3
rmatrix = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for row in range(len(X)):
for column in range(len(X[0])):
rmatrix[row][column] = X[row][column] * Y[row][column]
print("Matrix Multiplication",)
for r in rmatrix:
print(r)
for i in range(len(X)):
for j in range(len(X[0])):
rmatrix[row][column] = X[row][column] // Y[row][column]
print("nMatrix Division",)
for r in rmatrix:
print(r)
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].
Python3
X = [[9, 8, 7], [6, 5, 4], [3, 2, 1]]
result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for row in range(len(X)):
for column in range(len(X[0])):
result[column][row] = X[row][column]
for r in result:
print(r)
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.
Python3
import numpy as np
array = np.random.randint(10, size=(3, 3))
print(array)
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.
Python3
x = numpy.array([[1, 2], [4, 5]])
y = numpy.array([[7, 8], [9, 10]])
print ("The element wise addition of matrix is : ")
print (numpy.add(x,y))
print ("The element wise subtraction of matrix is : ")
print (numpy.subtract(x,y))
print ("The element wise multiplication of matrix is : ")
print (numpy.multiply(x,y))
print ("The element wise division of matrix is : ")
print (numpy.divide(x,y))
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.
Python3
X = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]
Y = [[9, 8, 7], [6, 5, 4],[3, 2, 1]]
dotproduct = np.dot(X, Y)
print("Dot product of two array is:", dotproduct)
dotproduct = np.cross(X, Y)
print("Cross product of two array is:", dotproduct)
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.
Python3
matrix = [[1, 2, 3], [4, 5, 6]]
print("n", numpy.transpose(matrix))
Output:
[[1 4][2 5][3 6]]
Create an empty matrix with NumPy in Python
Initializing an empty array, using the np.zeros().
Python3
a = np.zeros([2, 2], dtype=int)
print("nMatrix of 2x2: n", a)
c = np.zeros([3, 3])
print("nMatrix of 3x3: n", c)
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.
Python3
X = np.array([[6, 8, 10],
[ 9, -12, 15],
[ 12, 16, 20],
[ 15, -20, 25]])
print(X[:])
print("nSlicing Third Row-Second Column: ", X[2:3,1])
print("nSlicing Third Row-Third Column: ", X[2:3,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 0th row, then we tried to delete the 2nd row, and then the 3rd row.
Python3
a = np.array([[6, 8, 10],
[ 9, -12, 15],
[ 12, 16, 20],
[ 15, -20, 25]])
data = np.delete(a, 0, 0)
print("data after 0 th row deleted: ", data)
data = np.delete(a, 1, 0)
print("ndata after 1 st row deleted: ", data)
data = np.delete(a, 2, 0)
print("ndata after 2 nd row deleted: ", data)
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 4th position using np.hstack.
Python3
ini_array = np.array([[6, 8, 10],
[9, -12, 15],
[15, -20, 25]])
column_to_be_added = np.array([1, 2, 3])
result = np.hstack((ini_array, np.atleast_2d(column_to_be_added).T))
print("nresultant arrayn", str(result))
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]]
Комьюнити теперь в Телеграм
Подпишитесь и будьте в курсе последних IT-новостей
Подписаться
Способы ввода двумерных массивов
Допустим, нам нужно ввести двумерный массив после запуска нашей программы. Для этого мы можем создать программу, которая будет построчно считывать значения нашего массива, а также количество строк в нем. Рассмотрим на примере:
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: создание матрицы, инициализация элементов, вывод, обработка элементов матрицы
Создание, вывод и ввод матрицы в Питоне
- Таким образом, получается структура из вложенных списков, количество которых определяет количество строк матрицы, а число элементов внутри каждого вложенного списка указывает на количество столбцов в исходной матрице.
- Вывод матрицы можно осуществить одним оператором, но такой простой способ не позволяет выполнять какой-то предварительной обработки элементов:
Для работы с матрицами в Python также используются списки. Каждый элемент списка-матрицы содержит вложенный список.
Рассмотрим пример матрицы размера 4 х 3:
matrix = [[-1, 0, 1], [-1, 0, 1], [0, 1, -1], [1, 1, -1]]
Данный оператор можно записать в одну строку:
matrix = [[-1, 0, 1], [-1, 0, 1], [0, 1, -1], [1, 1, -1]]
Результат:
- способ:
- способ:
1 2 3 4 5 |
def printMatrix ( matrix ): for i in range ( len(matrix) ): for j in range ( len(matrix[i]) ): print ( "{:4d}".format(matrix[i][j]), end = "" ) print () |
В примере i – это номер строки, а j – номер столбца;
len(matrix) – число строк в матрице.
1 2 3 4 5 |
def printMatrix ( matrix ): for row in matrix: for x in row: print ( "{:4d}".format(x), end = "" ) print () |
Внешний цикл проходит по строкам матрицы (row), а внутренний цикл проходит по элементам каждой строки (x).
1 2 3 4 |
from random import randint n, m = 3, 3 a = [[randint(1, 10) for j in range(m)] for i in range(n)] print(a) |
Обработка элементов двумерного массива
Нумерация элементов двумерного массива, как и элементов одномерного массива, начинается с нуля.
Т.е. matrix[2][3] — это элемент третьей строки четвертого столбца.
Пример обработки элементов матрицы:
Найти произведение элементов двумерного массива.
✍ Решение:
1 2 3 4 5 |
p = 1 for i in range(N): for j in range(M): p *= matrix[i][j] print (p) |
Пример:
Найти сумму элементов двумерного массива.
✍ Решение:
Более подходящий вариант для Python:
1 2 3 4 |
s = 0 for row in matrix: s += sum(row) print (s) |
Для поиска суммы существует стандартная функция sum.
Задание Python 8_0:
Получены значения температуры воздуха за 4 дня с трех метеостанций, расположенных в разных регионах страны:
| Номер станции | 1-й день | 2-й день | 3-й день | 4-й день |
|---|---|---|---|---|
| 1 | -8 | -14 | -19 | -18 |
| 2 | 25 | 28 | 26 | 20 |
| 3 | 11 | 18 | 20 | 25 |
Т.е. запись показаний в двумерном массиве выглядела бы так:
| t[0][0]=-8 | t[0][1]=-14 | t[0][2]=-19 | t[0][3]=-18 |
| t[1][0]=25 | t[1][1]=28 | t[1][2]=26 | t[1][3]=20 |
| t[2][0]=11 | t[2][1]=18 | t[2][2]=20 | t[2][3]=25 |
- Распечатать температуру на 2-й метеостанции за 4-й день и на 3-й метеостанции за 1-й день.
- Распечатать показания термометров всех метеостанций за 2-й день.
- Определить среднюю температуру на 3-й метеостанции.
- Распечатать, в какие дни и на каких метеостанциях температура была в диапазоне 24-26 градусов тепла.
Задание Python 8_1:
Написать программу поиска минимального и максимального элементов матрицы и их индексов.
Задание Python 8_2:
Написать программу, выводящую на экран строку матрицы, сумма элементов которой максимальна.
for i in range(N): # работаем с matrix[i][i]
for i in range(N): # работаем с matrix[i][N-1-i]
Пример:Переставить 2-й и 4-й столбцы матрицы. Использовать два способа.
✍ Решение:
for i in range(N): c = A[i][2] A[i][2] = A[i][4] A[i][4] = c
for i in range(N): A[i][2], A[i][4] = A[i][4], A[i][2]
Задание Python 8_3:
Составить программу, позволяющую с помощью датчика случайных чисел сформировать матрицу размерностью N. Определить: