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å samme måde som for 1D-arrays har **NumPy** oprettelsesfunktioner for 2D-arrays. Vi vil gennemgå den mest almindelige, `eye()`-funktionen.


## eye()

Funktionen `numpy.eye()` opretter en **matrix** i formatet af et 2D-array, hvor elementerne med **ens** række- og kolonneindeks er `1`, mens alle andre elementer er `0`.

De to vigtigste parametre er `N` og `M`, som angiver antallet af henholdsvis **rækker** og **kolonner**. Parameteren `M` er valgfri, så du kan nøjes med at angive `N` for at oprette en kvadratisk `NxN`-matrix.

En kvadratisk matrix, hvor alle hoveddiagonale elementer er lig med `1`, og alle andre elementer er lig med `0`, kaldes en **identitetsmatrix**.

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 eksemplet oprettes en **identitetsmatrix** ved kun at angive parameteren `N` og en **rektangulær matrix** ved at angive både `N` og `M`. Datatypen `dtype` sættes til `np.int8` for den **rektangulære matrix**, hvilket kan være nyttigt, når der kun arbejdes med **heltal** (`np.float64` er standardværdien for `dtype`).

De resulterende 2D-arrays ser således ud:


Med hensyn til anvendelser bruges funktionen `eye()` primært til at oprette identitetsmatricer til specifikke **lineære algebra**-operationer og til initialisering af matricer i **maskinlæringsalgoritmer**.

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 op for det fulde potentiale af Pythons mest essentielle bibliotek til numerisk databehandling, NumPy. Dette omfattende kursus er designet til at føre dig fra et begynderforståelse til et avanceret niveau af færdigheder i NumPy. Uanset om du er data scientist, ingeniør, forsker eller udvikler, er det afgørende at mestre NumPy for effektiv datamanipulation, videnskabelig databehandling og maskinlæring.

Udforsk anvendelserne af NumPy og forstå, hvorfor det er et af de mest populære biblioteker til numerisk databehandling. Lær de forskellige metoder til at oprette og initialisere arrays for effektiv håndtering af forskellige databehov.

Opdag, hvordan man får adgang til specifikke elementer og delmængder i NumPy-arrays ved hjælp af indeksnotation. Lær at anvende betinget indeksering til at filtrere data og håndtere manglende værdier effektivt.

NumPy tilbyder mange indbyggede funktioner til at udføre almindelige array-operationer. Lær, hvordan disse værktøjer kan anvendes til effektivt at transformere, aggregere og analysere data uden at skrive gentagen kode.

Lær at udføre matematiske operationer effektivt på NumPy-arrays. Anvend disse operationer til at løse virkelige problemer og opnå en dybere forståelse af, hvordan vektoriserede beregninger accelererer numerisk analyse.

Oprettelsesfunktioner for 2D-Arrays

eye()

Løsning