Transpose Of A Matrix In Python

The transpose of a matrix in Python is a new matrix formed by converting every row of the original matrix into a column. If the original matrix has dimensions $m \times n$, its transpose has dimensions $n \times m$. This operation is useful in linear algebra, data processing, machine learning, image manipulation, and scientific computing.

Introduction

A matrix is a rectangular arrangement of numbers organized into rows and columns. Transposing it effectively reflects its elements across the main diagonal, which runs from the upper-left corner to the lower-right corner.

For example:

[ A = \begin{bmatrix} 1 & 2 & 3 \ 4 & 5 & 6 \end{bmatrix} ]

The transpose of $A$, written as $A^T$, is:

[ A^T = \begin{bmatrix} 1 & 4 \ 2 & 5 \ 3 & 6 \end{bmatrix} ]

The first row of the original matrix becomes the first column of the transposed matrix. Similarly, the second row becomes the second column.

In Python, a matrix is commonly represented as a nested list, where each inner list represents one row:

matrix = [
    [1, 2, 3],
    [4, 5, 6]
]

This represents a matrix with two rows and three columns.

How Matrix Transposition Works

If an element is located at row i and column j in the original matrix, it moves to row j and column i in the transposed matrix.

Mathematically:

[ B[j][i] = A[i][j] ]

Here, A is the original matrix and B is its transpose.

Consider this element mapping:

Original matrix:

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

Transposed matrix:

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

The element 4, originally at position [1][0], moves to position [0][1]. The element 3, originally at [0][2], moves to [2][0].

A square matrix has the same number of rows and columns. Its transpose has the same dimensions as the original matrix, but its elements may still change position.

Method 1: Transpose Using Nested Loops

The most explicit approach uses nested for loops. This method is useful for learning how transposition works Not complicated — just consistent..

matrix = [
    [1, 2, 3],
    [4, 5, 6]
]

rows = len(matrix)
columns = len(matrix[0])

transpose = []

for j in range(columns):
    new_row = []

    for i in range(rows):
        new_row.append(matrix[i][j])

    transpose.append(new_row)

print(transpose)

Output:

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

How the Code Works

1. rows stores the number of rows in the original matrix.
2. columns stores the number of columns.
3. The outer loop iterates through every original column.
4. The inner loop collects elements from that column across all rows.
5. Each collected column becomes a new row in the transposed matrix.

This method clearly demonstrates the relationship:

transpose[j][i] = matrix[i][j]

It works with both square and rectangular matrices.

Method 2: Transpose Using List Comprehension

List comprehension provides a shorter and more Pythonic solution.

matrix = [
    [1, 2, 3],
    [4, 5, 6]
]

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

print(transpose)

Output:

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

The outer comprehension iterates through column indexes, while the inner comprehension collects values from every row Practical, not theoretical..

Although this version is compact, the nested-loop approach is often easier for beginners to understand. Both methods create a completely new matrix and leave the original matrix unchanged Which is the point..

Method 3: Transpose Using zip()

Python’s built-in zip() function offers one of the cleanest ways to transpose a rectangular matrix.

matrix = [
    [1, 2, 3],
    [4, 5, 6]
]

transpose = [list(row) for row in zip(*matrix)]

print(transpose)

Output:

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

Understanding zip(*matrix)

The asterisk * unpacks the matrix into separate arguments:

zip([1, 2, 3], [4, 5, 6])

The zip() function then groups elements with the same index:

(1, 4)
(2, 5)
(3, 6)

Each tuple becomes one row of the transposed matrix. Since zip() produces tuples, list() is used to convert each tuple into a list Easy to understand, harder to ignore..

Without the conversion, the result would be:

[(1, 4), (2, 5), (3, 6)]

This is still a valid representation of a transposed matrix, but it uses tuples rather than lists.

Important Limitation of zip()

The zip() method assumes that every row has the same length. If the matrix is ragged, meaning its rows have different lengths, zip() stops when it reaches the end of the shortest row And that's really what it comes down to. Simple as that..

ragged_matrix = [
    [1, 2, 3],
    [4, 5]
]