Python Numpy Eye Function Explained [3 Easy Examples]

In this article, we’ll explain in detail the Python Numpy eye function. Starting from its definition, then progressing forward to the eye() function parameters, and finally understanding its usage with proper practical Python code examples.

What is Python Numpy Eye Function?

The eye() functions come from the Numpy library. The role of this function is to generate a 2D array that has ones on the diagonal and zeros elsewhere. The common usage of this function is to create identity matrices. These type of matrices are square that has ones on the main diagonal while zeros are positioned everywhere else.

Syntax of eye() Function

numpy.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')

Explanation of eye() Parameters

1. The first parameter ‘N‘ specifies the number of rows that will be shown in the resulting array.
2. (Optional parameter): The second parameter ‘M‘ is used to set the number of columns in the array that will be generated by the eye() function. If we don’t provide it any value then by default, it’ll be taken as equal to ‘N‘(first parameter) which means the number of rows.
3. (Optional parameter): The parameter ‘k‘ shows the diagonal’s index. The value that is given to this parameter by default is 0(zero) which refers to the main diagonal. If we give it a positive value then it’ll refer to an upper diagonal and a negative value will refer to a lower diagonal.
4. (Optional parameter): The parameter ‘dtype‘ shows the data of the resulting array. The default value that is given to it is ‘float‘.
5. (Optional parameter): The ‘order‘ parameter takes ‘C’ (row-major order) or ‘F’ (column-major order). We can set how the array should be stored using the order parameter. ‘C‘ is the default value provided to this parameter.

Understanding Numpy eye() Function with 3 Examples

Example 1: Create 3×3 Identity Matrix using eye() Numpy Function

import numpy as np

identity_matrix_data = np.eye(3)

print(identity_matrix_data)

Output

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

This code shows importing a Numpy library that is crucial for using the eye() function. Then we create a 3×3 identity matrix using the numpy eye() function which has ones on the main diagonal and zeros elsewhere. As we’ve discussed earlier that if we don’t provide the number of columns then by default, the number of rows(first parameter value) will be assumed as the number of rows.

Example 2: 4X3 Identity matrix with upper diagonal (Parameters ‘M’ and ‘k’)

id_matrix = np.eye(4,3,k=1)
print(id_matrix)

Output

[[0. 1. 0.]
 [0. 0. 1.]
 [0. 0. 0.]
 [0. 0. 0.]]

In this code example, we’ve created an identity matrix of 4×3. Also, we’ve shifted the diagonal to the upper position using the parameter ‘k‘. We’ve learned earlier that providing a positive value to ‘k‘ will shift the diagonal to the upper position and a negative value will take it to the lower position.

The second argument specifies the number of columns. For this example, we’ve set it to be 3 columns.

Example 3: Implementing the Parameters(‘dtype’ and ‘order’)

id_matr = np.eye(3)
print(id_matr)

id_matr2 = np.eye(3,dtype=int,order='F')
print(id_matr2)

Output

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
[[1 0 0]
 [0 1 0]
 [0 0 1]]