Summary  
This chapter covers how to use NumPy’s zeros, ones, and full functions to initialize arrays of a given shape and data type filled with zeros, ones, or any custom value.

General domain of usage  
Linear algebra

Watch this video for a clear explanation of NumPy's general array creation functions: `zeros()`, `ones()`, and `full()`. You'll see practical demonstrations of how to use these functions to quickly generate arrays of any shape filled with zeros, ones, or any value you choose. The video covers key parameters like `shape` and `dtype`, and shows real code examples similar to those in this chapter, so you can confidently apply these tools in your own projects.

**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 given form. Arrayets form angives via parameteren `shape` og kan enten være et **heltal** (størrelsen på et 1D-array) eller en **tuple af heltal** for højere-dimensionelle arrays.

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

Som du kan se, kan du også angive parameteren `dtype` på samme måde, som du 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
# Creating a 1D array of ones with 5 elements
ones_1d = np.ones(5)
print(ones_1d)
# Creating a 1D array of ones with specifying dtype
ones_1d_int = np.ones(5, dtype=np.int8)
print(ones_1d_int)
# Creating 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 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
# Create an array of fours of size 5
array_fours_1d = np.full(5, 4)
# Create 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 beregning, NumPy. Dette omfattende kursus er designet til at tage 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 beregning 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 måder at oprette og initialisere arrays på for effektivt at håndtere 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