Summary  
This chapter explains how to use NumPy’s eye() function to create 2D arrays that have ones on their diagonal and zeros elsewhere, supporting both square and rectangular shapes with customizable data types.

General domain of usage  
linear algebra

På liknande sätt som för 1D-arrayer har **NumPy** skapandefunktioner för 2D-arrayer. Vi kommer att gå igenom den vanligaste, funktionen `eye()`.


## eye()

Funktionen `numpy.eye()` skapar en **matris** i form av en 2D-array där elementen med **lika** rad- och kolumnindex är `1`, medan alla andra element är `0`.

De två viktigaste parametrarna är `N` och `M`, som anger antalet **rader** respektive **kolumner**. Parametern `M` är valfri, så du kan ange endast `N` för att skapa en kvadratisk `NxN`-matris.

En kvadratisk matris där alla element på huvuddiagonalen är lika med `1` och alla andra element är lika med `0` kallas för en **identitetsmatris**.

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}')

I vårt exempel skapade vi en **identitetsmatris** genom att endast ange parametern `N` och en **rektangulär matris** genom att ange både `N` och `M`. Vi angav även `dtype` till `np.int8` för den **rektangulära matrisen**, vilket kan vara användbart när man arbetar enbart med **heltal** (`np.float64` är standardvärdet för `dtype`).

De resulterande 2D-arrayerna ser ut så här:


När det gäller tillämpningar används funktionen `eye()` främst för att skapa identitetsmatriser för specifika **linjäralgebraiska** operationer och för att initiera matriser i **maskininlärningsalgoritmer**.

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

Lås upp hela potentialen hos Pythons mest grundläggande bibliotek för numerisk beräkning, NumPy. Denna omfattande kurs är utformad för att ta dig från nybörjarnivå till avancerad kompetens i NumPy. Oavsett om du är data scientist, ingenjör, forskare eller utvecklare är det avgörande att behärska NumPy för effektiv datamanipulering, vetenskaplig beräkning och maskininlärning.

Utforska användningsområdena för NumPy och förstå varför det är ett av de mest populära biblioteken för numerisk beräkning. Lär dig olika metoder för att skapa och initiera arrayer för att effektivt hantera olika databehov.

Utforska hur du får åtkomst till specifika element och delmängder i NumPy-arrayer med hjälp av indexnotation. Lär dig att använda villkorsindexering för att filtrera data och hantera saknade värden effektivt.

NumPy erbjuder många inbyggda funktioner för att utföra vanliga arrayoperationer. Lär dig hur du använder dessa verktyg för att transformera, aggregera och analysera data effektivt utan att skriva upprepad kod.

Lär dig att utföra matematiska operationer effektivt på NumPy-arrayer. Tillämpa dessa operationer för att lösa verkliga problem och få en djupare förståelse för hur vektoriserade beräkningar påskyndar numerisk analys.

Skapandefunktioner för 2D-arrayer

eye()

Lösning