Summary  
Demonstrates how to generate arrays of a specified shape filled with zeros, ones, or any given value using general array creation functions.  

General domain of usage  
Linear algebra

**NumPy** har også array-oprettelsesfunktioner, der automatisk kan oprette et array med en given **form** (dimensioner). Her er de mest almindelige:
* `zeros()`;
* `ones()`;
* `full()`.

## zeros()

Navnet på denne funktion taler for sig selv: den opretter et array af nuller med en angivet form. Arrayets form angives via parameteren `shape` og kan enten være et **heltal** (størrelse på et 1D-array) eller en **tuple af heltal** for højere-dimensionelle arrays.

import numpy as np
# Сreating a 1D array of zeros with 5 elements
zeros_1d = np.zeros(5)
print(zeros_1d)
# Сreating a 1D array of zeros with specifying dtype
zeros_1d_int = np.zeros(5, dtype=np.int8)
print(zeros_1d_int)
# Сreating a 2D array of zeros of shape 5x3
zeros_2d = np.zeros((5, 3))
print(zeros_2d)

Som du kan se, kan vi også angive parameteren `dtype` på samme måde, som vi gjorde for andre typer arrays.

## ones()

Denne funktion ligner `zeros()`-funktionen, men i stedet for et array af nuller, opretter den et array af **etter**.


import numpy as np
# Сreating a 1D array of ones with 5 elements
ones_1d = np.ones(5)
print(ones_1d)
# Сreating a 1D array of ones with specifying dtype
ones_1d_int = np.ones(5, dtype=np.int8)
print(ones_1d_int)
# Сreating a 2D array of ones of shape 5x3
ones_2d = np.ones((5, 3))
print(ones_2d)

## full()

Funktionen `numpy.full()` ligner de tidligere nævnte funktioner, men den har en anden parameter, `fill_value`, som angiver værdien, der skal udfylde arrayet med. Dens første parameter, `shape`, kan enten være et **heltal** eller et **tuple af heltal**:

import numpy as np
# Сreate an array of fours of size 5
array_fours_1d = np.full(5, 4)
# Сreate an array of fives of shape 4x2
array_fives_2d = np.full((4, 2), 5)
print(f'1D fours array: {array_fours_1d}')
print(f'2D fives array:\n{array_fives_2d}')

## Flere anvendelser

Alle disse funktioner har flere anvendelsesmuligheder end blot at fungere som pladsholdere. De bruges ofte direkte i matematiske operationer inden for **lineær algebra**. De kan anvendes i forskellige områder af maskin- og dybdelæring, såsom **billedbehandling**.

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):
    """Helper for Codefinity-style result output."""
    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):
        # Імпортуємо код користувача
        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

    def test_zeros_array_1d(self):
        """1. zeros_array_1d — 1D масив з 5 нулів"""
        ok = hasattr(self.m, "zeros_array_1d")
        arr = getattr(self.m, "zeros_array_1d", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == (5,)
        val_ok = type_ok and np.all(arr == 0)
        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok,
            "zeros_array_1d created correctly",
            "zeros_array_1d incorrect",
        )

    def test_zeros_array_2d(self):
        """2. zeros_array_2d — 2D масив 2x4 з нулів"""
        ok = hasattr(self.m, "zeros_array_2d")
        arr = getattr(self.m, "zeros_array_2d", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == (2, 4)
        val_ok = type_ok and np.all(arr == 0)
        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok,
            "zeros_array_2d created correctly",
            "zeros_array_2d incorrect",
        )

    def test_ones_array_1d(self):
        """3. ones_array_1d — 1D масив з 3 одиниць"""
        ok = hasattr(self.m, "ones_array_1d")
        arr = getattr(self.m, "ones_array_1d", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == (3,)
        val_ok = type_ok and np.all(arr == 1)
        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok,
            "ones_array_1d created correctly",
            "ones_array_1d incorrect",
        )

    def test_ones_array_2d(self):
        """4. ones_array_2d — 2D масив 2x3 з одиниць"""
        ok = hasattr(self.m, "ones_array_2d")
        arr = getattr(self.m, "ones_array_2d", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == (2, 3)
        val_ok = type_ok and np.all(arr == 1)
        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok,
            "ones_array_2d created correctly",
            "ones_array_2d incorrect",
        )

    def test_sevens_array_2d(self):
        """5. sevens_array_2d — 2D масив 2x2 із сімок"""
        ok = hasattr(self.m, "sevens_array_2d")
        arr = getattr(self.m, "sevens_array_2d", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == (2, 2)
        val_ok = type_ok and np.all(arr == 7)
        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok,
            "sevens_array_2d created correctly",
            "sevens_array_2d incorrect",
        )

    def test_print_output(self):
        """Перевіряє, що всі масиви виводяться"""
        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()

        printed_ok = all(
            kw in output
            for kw in [
                "1D zeros array",
                "1D ones array",
                "2D zeros array",
                "2D ones array",
                "2D sevens array",
            ]
        )
        _dynamic_test(
            self,
            printed_ok,
            "All arrays printed correctly",
            "Print statements missing or incorrect",
        )


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.

Generelle Array-Oprettelsesfunktioner

zeros()

ones()

full()

Flere anvendelser

Løsning