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** dispone anche di funzioni per la creazione di array che possono generare automaticamente un array di una determinata **forma** (dimensioni). Ecco le più comuni:
* `zeros()`;
* `ones()`;
* `full()`.

## zeros()

Il nome di questa funzione è esplicativo: crea un array di zeri con una forma specificata. La forma dell'array viene indicata tramite il parametro `shape` e può essere un **intero** (dimensione di un array 1D) oppure una **tupla di interi** per array multidimensionali.

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)

Come puoi vedere, puoi anche specificare il parametro `dtype` nello stesso modo in cui lo hai fatto per altri tipi di array.

## ones()

Questa funzione è simile alla funzione `zeros()`, ma invece di un array di zeri, crea un array di **uni**.


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()

La funzione `numpy.full()` è simile alle funzioni menzionate sopra, ma presenta un secondo parametro, `fill_value`, che specifica il valore con cui riempire l'array. Il suo primo parametro, `shape`, può essere un **intero** oppure una **tupla di interi**:

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

## Ulteriori Applicazioni

Tutte queste funzioni hanno più casi d'uso rispetto al semplice utilizzo come segnaposto. Sono spesso utilizzate direttamente nelle operazioni matematiche in **algebra lineare**. Possono essere applicate in vari ambiti del machine e deep learning, come l'**elaborazione delle immagini**.

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

Sblocca il pieno potenziale della libreria più essenziale di Python per il calcolo numerico, NumPy. Questo corso completo è progettato per portarti da una comprensione da principiante a un livello avanzato di competenza in NumPy. Che tu sia un data scientist, un ingegnere, un ricercatore o uno sviluppatore, padroneggiare NumPy è fondamentale per una manipolazione efficiente dei dati, il calcolo scientifico e il machine learning.

Esplora le applicazioni di NumPy e comprendi perché è una delle librerie più popolari per il calcolo numerico. Scopri i diversi modi per creare e inizializzare array per gestire in modo efficiente varie esigenze di dati.

Scopri come accedere a elementi specifici e sottoinsiemi negli array NumPy utilizzando la notazione degli indici. Apprendi come applicare l'indicizzazione condizionale per filtrare i dati e gestire in modo efficiente i valori mancanti.

NumPy offre molte funzioni integrate per eseguire operazioni comuni sugli array. Scopri come applicare questi strumenti per trasformare, aggregare e analizzare i dati in modo efficiente senza scrivere codice ripetitivo.

Impara come eseguire operazioni matematiche in modo efficiente sugli array NumPy. Applica queste operazioni per risolvere problemi reali e acquisisci una comprensione più approfondita di come i calcoli vettorializzati accelerano l'analisi numerica.

Funzioni Generali di Creazione degli Array

zeros()

ones()

full()

Ulteriori Applicazioni

Soluzione