Python Matrix – Use list of lists for matrix representation

Representing Matrices Using Lists of Lists in Python

In Python, a matrix can be efficiently represented using a list of lists. Each inner list represents a row of the matrix, making it a simple yet powerful way to perform matrix operations. This article will explore how to create, access, and manipulate matrices using this representation, providing you with a solid foundation for numerical computations and data analysis. We’ll delve into various methods, providing real-world examples and clear code outputs to illustrate each concept of list of lists.

Here’s a basic example of a matrix represented as a list of lists:

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

print(matrix)

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

Creating a Matrix

Creating a matrix using lists of lists involves defining a list where each element is another list representing a row. This approach offers flexibility in defining the size and elements of the matrix.

# Method 1: Direct Initialization
matrix1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print("Matrix 1:", matrix1)

# Method 2: Creating an empty matrix and populating it
rows = 3
cols = 3
matrix2 = [[0 for _ in range(cols)] for _ in range(rows)] # Create a 3x3 matrix filled with zeros
print("Matrix 2 (Initialized with zeros):", matrix2)

# Method 3: Creating a matrix from user input
rows = int(input("Enter the number of rows: "))
cols = int(input("Enter the number of columns: "))

matrix3 = []
for i in range(rows):
    row = []
    for j in range(cols):
        element = int(input(f"Enter element at position ({i+1}, {j+1}): "))
        row.append(element)
    matrix3.append(row)

print("Matrix 3 (User Input):", matrix3) # Output depends on user input.

Matrix 1: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Matrix 2 (Initialized with zeros): [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
Matrix 3 (User Input): [[1, 2], [3, 4]]  # Example if user enters 2 rows, 2 columns, and 1,2,3,4 as values.

Explanation:

• Method 1 demonstrates the simplest way to create a matrix by directly initializing it with values.
• Method 2 shows how to create an empty matrix of a specific size and populate it with a default value (in this case, 0). The [[0 for _ in range(cols)] for _ in range(rows)] uses list comprehension for a concise way to generate the matrix.
• Method 3 takes user input to define the size and elements of the matrix, providing a dynamic way to create matrices.

Accessing Matrix Elements

Accessing elements in a matrix involves using indices for both rows and columns. Python uses zero-based indexing, meaning the first element is at index 0.

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

# Accessing element at row 0, column 1 (value: 2)
element = matrix[0][1]
print("Element at (0, 1):", element)

# Accessing element at row 2, column 2 (value: 9)
element = matrix[2][2]
print("Element at (2, 2):", element)

# Accessing a row
row = matrix[1]
print("Row 1:", row)

Element at (0, 1): 2
Element at (2, 2): 9
Row 1: [4, 5, 6]

Explanation:

The code demonstrates how to access specific elements using their row and column indices. For example, matrix[0][1] accesses the element at the first row (index 0) and the second column (index 1).

Modifying Matrix Elements

Modifying matrix elements is as straightforward as assigning a new value to a specific position using its row and column indices.

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

# Modifying the element at row 0, column 0
matrix[0][0] = 10
print("Modified Matrix:")
for row in matrix:
    print(row)

# Modifying an entire row
matrix[1] = [14, 15, 16]
print("Modified Matrix after Row update:")
for row in matrix:
    print(row)

Modified Matrix:
[10, 2, 3]
[4, 5, 6]
[7, 8, 9]
Modified Matrix after Row update:
[10, 2, 3]
[14, 15, 16]
[7, 8, 9]

Explanation:

The code shows how to modify individual elements and entire rows within the matrix. Direct assignment using indices makes it easy to update the matrix’s contents.

Matrix Operations: Addition

Matrix addition involves adding corresponding elements of two matrices. It’s crucial that the matrices have the same dimensions for the addition to be valid.

# Matrix Addition
matrix1 = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

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

# Check if matrices have the same dimensions
if len(matrix1) != len(matrix2) or len(matrix1[0]) != len(matrix2[0]):
    print("Matrices must have the same dimensions for addition.")
else:
    result_matrix = []
    for i in range(len(matrix1)):
        row = []
        for j in range(len(matrix1[0])):
            row.append(matrix1[i][j] + matrix2[i][j])
        result_matrix.append(row)

    print("Matrix Addition Result:")
    for row in result_matrix:
        print(row)

Matrix Addition Result:
[10, 10, 10]
[10, 10, 10]
[10, 10, 10]

Explanation:

This code performs matrix addition by iterating through the rows and columns of the input matrices and adding the corresponding elements. It also includes a check to ensure that the matrices have compatible dimensions.

Matrix Operations: Multiplication

Matrix multiplication is more complex than addition. The number of columns in the first matrix must be equal to the number of rows in the second matrix. The resulting matrix has the number of rows of the first matrix and the number of columns of the second matrix.

# Matrix Multiplication
matrix1 = [
    [1, 2],
    [3, 4]
]

matrix2 = [
    [5, 6],
    [7, 8]
]

# Check if matrices can be multiplied
if len(matrix1[0]) != len(matrix2):
    print("Matrices cannot be multiplied due to incompatible dimensions.")
else:
    rows_m1 = len(matrix1)
    cols_m1 = len(matrix1[0])
    rows_m2 = len(matrix2)
    cols_m2 = len(matrix2[0])

    result_matrix = [[0 for _ in range(cols_m2)] for _ in range(rows_m1)]

    for i in range(rows_m1):
        for j in range(cols_m2):
            for k in range(cols_m1):  # or rows_m2
                result_matrix[i][j] += matrix1[i][k] * matrix2[k][j]

    print("Matrix Multiplication Result:")
    for row in result_matrix:
        print(row)

Matrix Multiplication Result:
[19, 22]
[43, 50]

Explanation:

This code implements matrix multiplication using nested loops. The outer loops iterate through the rows of the first matrix and the columns of the second matrix. The inner loop performs the dot product calculation.

Transposing a Matrix

Transposing a matrix involves swapping its rows and columns. The element at position (i, j) becomes the element at position (j, i).

# Matrix Transpose
matrix = [
    [1, 2, 3],
    [4, 5, 6]
]

transposed_matrix = [[matrix[j][i] for j in range(len(matrix))] for i in range(len(matrix[0]))]

print("Original Matrix:")
for row in matrix:
    print(row)

print("Transposed Matrix:")
for row in transposed_matrix:
    print(row)

Original Matrix:
[1, 2, 3]
[4, 5, 6]
Transposed Matrix:
[1, 4]
[2, 5]
[3, 6]

Explanation:

This code uses list comprehension to create the transposed matrix. It iterates through the columns of the original matrix and constructs the rows of the transposed matrix.

Slicing Matrices

Slicing can be used to extract a submatrix from a given matrix. This involves selecting a subset of rows and columns.

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

# Extract a submatrix (rows 0:2, columns 1:3)
submatrix = [row[1:3] for row in matrix[0:2]]

print("Original Matrix:")
for row in matrix:
    print(row)

print("Submatrix:")
for row in submatrix:
    print(row)

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

Explanation:

The code demonstrates how to use slicing to extract a portion of the original matrix. matrix[0:2] selects the first two rows, and row[1:3] selects the second and third columns of each selected row.