SciPy – Using linalg.inv() function (4 examples)

Updated: March 7, 2024 By: Guest Contributor Post a comment


In this tutorial, we will explore how to use the linalg.inv() function from the SciPy library in Python. The inv() function is used to calculate the inverse of a square matrix. Understanding how to effectively use this function can be crucial in various scientific and engineering computations, where matrix inversion is a common task.

Before diving into the examples, it’s important to grasp what matrix inversion entails. The inverse of a matrix A is another matrix, often denoted as A-1, such that when A is multiplied by A-1, the result is the identity matrix. The existence of an inverse depends on the matrix being square (same number of columns and rows) and having a non-zero determinant.

Let’s proceed with our examples, illustrating the use of the linalg.inv() function from basic to more advanced scenarios.

Example 1: Inverting a Simple 2×2 Matrix

As our first example, we will invert a simple 2×2 matrix. This example serves as a foundation, demonstrating the basic usage of linalg.inv().

import numpy as np
from scipy.linalg import inv

# Define the matrix
A = np.array([[1, 2],
              [3, 4]])

# Calculate its inverse
A_inv = inv(A)


The output would be:

[[-2.   1. ]
 [ 1.5 -0.5]]

This output shows the inverse of our 2×2 matrix, aligning with the mathematical calculation for a matrix of this size.

Example 2: Handling Non-Invertible Matrices

Not all matrices can be inverted. For a matrix to be invertible, it must be square and have a non-zero determinant. This example will demonstrate how to handle situations where a matrix may not be invertible using the linalg.inv() function.

import numpy as np
from scipy.linalg import inv

# Attempt to invert a non-invertible matrix (singular matrix)
B = np.array([[2, 4],
              [1, 2]])

    B_inv = inv(B)
except Exception as e:
    print("Matrix is not invertible:", e)

The output would indicate a failure to invert the matrix due to it being singular:

Matrix is not invertible: singular matrix

This provides a straightforward method to manage errors when dealing with non-invertible matrices, allowing for robust code implementation.

Example 3: Inverting a Larger Matrix

Moving towards a more complex example, we demonstrate how to invert a larger matrix. This not only shows the robustness of linalg.inv() but also highlights its use in real-world applications where larger matrices are common.

import numpy as np
from scipy.linalg import inv

# Define a 4x4 matrix
C = np.array([[1, 2, 3, 4],
              [5, 6, 7, 8],
              [9, 10, 11, 12],
              [13, 14, 15, 16]])

# Calculate its inverse
C_inv = inv(C)

# Due to the complexity, we'll print just the determinant to check if it's invertible

# Assuming it's invertible, here's how you'd print the inverse
# (commented out due to potentially long output)
# print(C_inv)

Notice that this example emphasizes two points: the calculation of the determinant as a preliminary check for invertibility, and handling of larger matrices with the inv() function. The output will depend on the matrix provided but demonstrates the process for larger matrices.

Example 4: Application in Solving Linear System of Equations

Our final example illustrates a practical application of matrix inversion: solving a linear system of equations. By inverting the coefficient matrix and then multiplying it by the constant matrix, we can find the solution vector for the equations.

import numpy as np
from scipy.linalg import inv

# Define the coefficient matrix and constant vector
D = np.array([[2, 1],
              [1, 2]])
B = np.array([4, 3])

# Invert the coefficient matrix
D_inv = inv(D)

# Multiply the inverse by the constant vector to find the solution
solution =, B)


The output will display the solution to the linear equation set, showcasing a powerful application of matrix inversion in solving real-world problems.


We’ve seen how the linalg.inv() function from SciPy can be utilized across several examples ranging from basic to complex applications. Mastering this function can significantly enhance one’s ability to tackle numerical computations and mathematical problems in Python.