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 också array-skapande funktioner som automatiskt kan skapa en array med en given **form** (dimensioner). Här är de vanligaste:
* `zeros()`;
* `ones()`;
* `full()`.

## zeros()

Namnet på denna funktion talar för sig själv: den skapar en array av nollor med en angiven form. Arrayens form anges via parametern `shape` och kan vara ett **heltal** (storlek på en 1D-array) eller en **tuppel av heltal** för högre-dimensionella arrayer.

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 också ange parametern `dtype` på samma sätt som du gjorde för andra typer av arrayer.

## ones()

Denna funktion liknar `zeros()`-funktionen, men istället för en array med nollor skapar den en array med **ettor**.


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()` liknar de tidigare nämnda funktionerna, men har en andra parameter, `fill_value`, för att ange värdet som ska fylla arrayen. Dess första parameter, `shape`, kan vara antingen ett **heltal** eller en **tuppel av 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}')

## Fler användningsområden

Alla dessa funktioner har fler användningsområden än att bara vara platshållare. De används ofta direkt i matematiska operationer inom **linjär algebra**. De kan tillämpas inom olika områden av maskininlärning och djupinlärning, såsom **bildbehandling**.

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 upp den fulla 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, vetenskapliga beräkningar 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 de olika sätten att skapa och initiera arrayer för att effektivt hantera olika databehov.

Upptäck 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 villkorsbaserad indexering för att filtrera data och hantera saknade värden effektivt.

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

Lär dig hur du utför matematiska operationer effektivt på NumPy-arrayer. Använd 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.

Allmänna Funktioner för Skapande av Arrayer

zeros()

ones()

full()

Fler användningsområden

Lösning