Summary  
This chapter explains how to use NumPy’s eye() function to create 2D arrays with ones on the diagonal and zeros elsewhere, allowing you to specify the number of rows, optional columns, and data type.  

General domain of usage  
Linear algebra operations

Similarly to 1D arrays, **NumPy** has creation functions for 2D arrays. We will cover the most common one, the `eye()` function.


## eye()

The `numpy.eye()` function creates a **matrix** in the format of a 2D array where the elements with **equal** row and column indices are `1`, while all other elements are `0`.

The two most important parameters are `N` and `M`, which specify the number of **rows** and **columns** respectively. The `M` parameter is optional, so you can specify only `N` to create a square `NxN` matrix.

A square matrix with all main diagonal elements equal to `1` and all other elements equal to `0` is called an **identity matrix**.

Definition

import numpy as np
# Creating a 2x2 identity matrix
identity_matrix = np.eye(2)
print(f'2x2 identity matrix:\n{identity_matrix}')
# Creating a 4x3 matrix with np.eye()
rectangular_matrix = np.eye(4, 3, dtype=np.int8)
print(f'4x3 matrix:\n{rectangular_matrix}')

In our example, we created an **identity matrix** by specifying only the `N` parameter and a **rectangular matrix** by specifying both `N` and `M`. We also set the `dtype` to `np.int8` for the **rectangular matrix**, which can be useful when working with only **integers** (`np.float64` is the default value for `dtype`).

The resulting 2D arrays look as follows:


Regarding applications, the `eye()` function is primarily used to create identity matrices for specific **linear algebra** operations and to initialize matrices in **machine learning algorithms**.

import unittest
import importlib.util
import numpy as np
import io
from contextlib import redirect_stdout


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        # Імпортуємо user_code
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        cls.m = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(cls.m)
        cls.module_path = spec.origin

        # Очікуваний результат
        cls.exp_matrix = np.eye(5, 2, dtype=np.int8)

    def test_matrix_properties(self):
        """1–3. Check that matrix is created correctly with np.eye(5, 2, dtype=np.int8)"""
        ok = hasattr(self.m, "matrix")
        arr = getattr(self.m, "matrix", None)

        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == (5, 2)
        dtype_ok = type_ok and arr.dtype == np.int8
        val_ok = type_ok and np.array_equal(arr, self.exp_matrix)

        # Значення по головній діагоналі мають бути 1, решта — 0
        diag_ok = type_ok and np.all(np.diag(arr[:2, :2]) == 1)
        zero_ok = type_ok and np.all(arr[np.where(arr != np.eye(5, 2))] == 0)

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and dtype_ok and val_ok and diag_ok and zero_ok,
            "matrix created correctly",
            "matrix incorrect or has wrong properties",
        )

    def test_matrix_printed(self):
        """Перевіряємо, що matrix виводиться"""
        f = io.StringIO()
        with open(self.module_path, "r", encoding="utf-8") as file:
            code = file.read()
        with redirect_stdout(f):
            exec(code, {})
        output = f.getvalue().strip()

        # Має бути надруковано хоча б одну «1» та «0»
        printed_ok = "1" in output and "0" in output

        _dynamic_test(
            self,
            printed_ok,
            "matrix printed correctly",
            "matrix not printed or printed incorrectly",
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Develop essential skills for numerical computing using NumPy. Learn how to work with NumPy arrays, create and manipulate multidimensional data, apply indexing and slicing, perform vectorized operations, reshape arrays, use broadcasting, and apply basic linear algebra techniques. The course focuses on practical operations commonly used in data analysis tasks.

Creation Functions for 2D Arrays

eye()

Løsning