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** también dispone de funciones para la creación de arrays que pueden generar automáticamente un array con una **forma** (dimensiones) determinada. Las más comunes son:
* `zeros()`;
* `ones()`;
* `full()`.

## zeros()

El nombre de esta función lo indica: crea un array de ceros con una forma determinada. La forma del array se especifica mediante el parámetro `shape` y puede ser un **entero** (tamaño de un array 1D) o una **tupla de enteros** para arrays de mayor dimensión.

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)

Como puedes ver, también puedes especificar el parámetro `dtype` de la misma manera que lo hiciste para otros tipos de arreglos.

## ones()

Esta función es similar a la función `zeros()`, pero en lugar de un arreglo de ceros, crea un arreglo de **unos**.


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 función `numpy.full()` es similar a las funciones mencionadas anteriormente, pero tiene un segundo parámetro, `fill_value`, para especificar el valor con el que se llenará el arreglo. Su primer parámetro, `shape`, puede ser un **entero** o una **tupla de enteros**:

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

## Más aplicaciones

Todas estas funciones tienen más casos de uso que simplemente servir como marcadores de posición. Se utilizan con frecuencia directamente en operaciones matemáticas en **álgebra lineal**. Pueden aplicarse en diversos campos del aprendizaje automático y profundo, como el **procesamiento de imágenes**.

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

Desbloquea todo el potencial de la biblioteca más esencial de Python para el cálculo numérico, NumPy. Este curso integral está diseñado para llevarte desde un nivel principiante hasta un nivel avanzado de competencia en NumPy. Ya seas científico de datos, ingeniero, investigador o desarrollador, dominar NumPy es fundamental para la manipulación eficiente de datos, el cálculo científico y el aprendizaje automático.

Explora las aplicaciones de NumPy y comprende por qué es una de las bibliotecas más populares para el cálculo numérico. Aprende las diferentes formas de crear e inicializar arreglos para manejar diversas necesidades de datos de manera eficiente.

Descubre cómo acceder a elementos específicos y subconjuntos en arreglos de NumPy utilizando la notación de índices. Aprende a aplicar indexación condicional para filtrar datos y gestionar valores faltantes de manera eficiente.

NumPy ofrece muchas funciones integradas para realizar operaciones comunes con arreglos. Aprenda cómo aplicar estas herramientas para transformar, agregar y analizar datos de manera eficiente sin escribir código repetitivo.

Aprende a realizar operaciones matemáticas de manera eficiente en arreglos de NumPy. Aplica estas operaciones para resolver problemas del mundo real y adquiere una comprensión más profunda de cómo los cálculos vectorizados aceleran el análisis numérico.

Funciones Generales de Creación de Arreglos

zeros()

ones()

full()

Más aplicaciones

Solución