How To Multiply Matrices In Python

Matrix multiplication stands as a cornerstone operation in linear algebra, serving as the computational engine behind everything from computer graphics and physics simulations to the neural networks powering modern artificial intelligence. For developers and data scientists working in Python, understanding how to multiply matrices in Python efficiently is not just a syntax exercise—it is a fundamental skill that dictates the performance and scalability of an application. While the mathematical definition remains constant, the Python ecosystem offers several distinct pathways to achieve this, each with specific trade-offs regarding speed, memory usage, and syntax readability Nothing fancy..

The Mathematical Foundation: A Quick Refresher

Before diving into code, it is crucial to visualize the rule that governs this operation. Unlike element-wise multiplication (the Hadamard product), standard matrix multiplication follows the dot product rule. Now, for two matrices, A (dimensions $m \times n$) and B (dimensions $n \times p$), the operation is valid only if the number of columns in A matches the number of rows in B (the inner dimensions). The resulting matrix C will possess dimensions $m \times p$ (the outer dimensions) Most people skip this — try not to. Which is the point..

Each element $c_{ij}$ in the resulting matrix is calculated as the sum of products of corresponding elements from the $i$-th row of A and the $j$-th column of B:

$c_{ij} = \sum_{k=1}^{n} a_{ik} \cdot b_{kj}$

Keeping this "row-by-column" mechanic in mind helps debug shape errors, which are the most common stumbling block when implementing matrix multiplication in Python.

Method 1: The Modern Standard — NumPy’s @ Operator and matmul

If you are doing any serious numerical computing in Python, NumPy is the de facto foundation. Now, since Python 3. 5, the language has supported the @ infix operator specifically for matrix multiplication, mapping directly to numpy.That's why matmul. This is currently the most Pythonic, readable, and performant way to handle standard 2D matrix multiplication That's the part that actually makes a difference..

import numpy as np

# Define two matrices
# Matrix A: 2 rows, 3 columns (2x3)
A = np.array([[1, 2, 3], 
              [4, 5, 6]])

# Matrix B: 3 rows, 2 columns (3x2)
# Inner dimensions match (3 and 3), Result will be 2x2
B = np.array([[7, 8], 
              [9, 1], 
              [2, 3]])

# The modern, preferred syntax
C = A @ B

print("Result using @ operator:")
print(C)
# Output:
# [[ 31  19]
#  [ 85  55]]

Why prefer @ over np.dot? While np.dot(A, B) works for 2D arrays, its behavior becomes ambiguous with higher-dimensional arrays (tensors). np.matmul (and the @ operator) follows stricter, more predictable broadcasting rules aligned with linear algebra conventions for stacks of matrices. For 2D arrays, they are functionally identical, but @ signals intent clearly: "This is matrix multiplication."

Method 2: Handling Batches and Higher Dimensions

One of the superpowers of np.matmul (and @) is broadcasting over batch dimensions. Imagine you have a batch of 10 transformation matrices (shape 10, 4, 4) and a batch of 10 vectors (shape 10, 4, 1). You can multiply them all in a single vectorized call without writing a for loop.

# Batch of 3 matrices (3x2x2) multiplied by batch of 3 matrices (3x2x2)
batch_A = np.random.rand(3, 2, 2)
batch_B = np.random.rand(3, 2, 2)

# Performs 3 independent 2x2 matrix multiplications
batch_C = batch_A @ batch_B 
print(batch_C.shape) # (3, 2, 2)

This vectorization is where Python—via NumPy—bridges the gap between interpreted language slowness and C/Fortran backend speed Practical, not theoretical..

Method 3: The dot Method and Function (Legacy Context)

You will encounter np.dot() method in older codebases, tutorials, and scientific literature. Think about it: dotor the. For strictly 2D matrices, it produces the exact same result as @ Simple, but easy to overlook..

# Equivalent to A @ B
C_legacy = np.dot(A, B)
# Or
C_method = A.dot(B)

Critical Distinction: np.dot behaves differently for 1D arrays (vectors) and N-D arrays ($N > 2$).

• 1D vectors: np.dot computes the inner product (scalar), whereas @ raises a ValueError if shapes aren't aligned for matrix multiplication (expecting 2D).
• N-D arrays ($N>2$): np.dot performs a sum product over the last axis of a and the second-to-last axis of b, which is a tensor contraction, not a batch matrix multiply.

Best Practice: Use @ for matrix multiplication. Reserve np.dot for explicit vector dot products or tensor contractions where that specific mathematical behavior is required.

Method 4: Element-Wise Multiplication (The Hadamard Product)

A frequent source of bugs is confusing matrix multiplication with element-wise multiplication. But in NumPy, the * operator performs the Hadamard product, multiplying corresponding elements. This requires both matrices to have the exact same shape (or be broadcastable to the same shape).

# Element-wise multiplication (Hadamard Product)
# Shapes must match exactly (or broadcast)
D = np.array([[1, 2], 
              [3, 4]])
E = np.array([[5, 6], 
              [7, 8]])

hadamard_result = D * E
print("Element-wise result:")
print(hadamard_result)
# Output:
# [[ 5 12]
#  [21 32]]

Mental Check: If you see * between two NumPy arrays, think "element-wise." If you see @, think "linear algebra dot product."

Method 5: Pure Python Implementation (No Dependencies)

In constrained environments—such as coding interviews, embedded systems without NumPy, or educational contexts—you must implement the algorithm using standard lists. This reinforces the $O(n^3)$ complexity of the naive algorithm.

def matrix_multiply_pure(A, B):
    # Validate dimensions
    rows_A = len(A)
    cols_A = len(A[0])
    rows_B = len(B)
    cols_B = len(B[0])

    if cols_A != rows_B:
        raise ValueError("Incompatible dimensions: cols(A) must equal rows(B)")

    # Initialize result matrix with zeros (rows_A x cols_B)
    # Using list comprehension for clean initialization
    result = [[0 for _ in range(cols_B)] for _ in range(rows_A)]

    # The triple nested loop: Row -> Col -> Dot Product Summation
    for i in range(rows_A):          # Iterate rows of A
        for j in range(cols_B):      # Iterate cols of B
            for k in range(cols_A):  # Iterate cols of A / rows of B
                result[i][j] += A[i][k] * B[k][j]
    
    return result

# Usage
A_list = [[1, 2, 3], [4, 5, 6]]
B_list = [[7,