Summary  
This chapter covers how to assign values to specific elements or subarrays in NumPy arrays using indexing and slicing in both one- and two-dimensional contexts, and explains how the array’s data type affects the stored values.  

General domain of usage  
Data cleaning and preprocessing

Watch this video for a step-by-step demonstration of how to assign values to indexed elements in NumPy arrays. You'll see practical examples of updating individual elements and subarrays in both 1D and 2D arrays, along with explanations of how data types affect assignments. This visual guide will help reinforce your understanding of modifying data directly within NumPy arrays.

Asignar valores a **elementos específicos** o **subarreglos** es útil para actualizar datos, corregir errores o aplicar condiciones en conjuntos de datos. Esto resulta especialmente útil en tareas como **reemplazar** entradas no válidas, **ajustar** valores para análisis o **modificar** partes de un arreglo para simulaciones y cálculos.

En primer lugar, se puede asignar un valor a un **elemento indexado** de un arreglo. La sintaxis general para lograr esto en arreglos unidimensionales es: `array[i] = n`, donde `i` es un índice determinado y `n` es el valor que se va a asignar.

En arreglos bidimensionales, la sintaxis es la siguiente: `array[i, j] = n`, donde `i` y `j` son los índices de **fila** y **columna**, respectivamente. Para arreglos de mayor dimensión, la cantidad de índices corresponde al **número de dimensiones**.

import numpy as np
array_1d = np.array([1, 4, 6, 2])
# Assigning 10 to the first element of array_1d
array_1d[0] = 10
print(array_1d)
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
# Assigning 8 to the element in the second row and column of array_2d
array_2d[1, 1] = 8
print(array_2d)

Si se asigna un valor de un tipo de dato **superior**, como un flotante, a un elemento con un tipo de dato **inferior**, como un entero, el valor puede cambiarse o causar un error. Por ejemplo, asignar `3.5` a un elemento entero lo almacenará como `3`, perdiendo la parte decimal.

Nota

**Tipos de datos superiores** son aquellos que pueden almacenar un rango más amplio de valores y, a menudo, ocupan más memoria.

Estudiar más

import numpy as np
array_1d = np.array([1, 4, 6, 2])
# Assigning 10.2 to the first element of array_1d
array_1d[0] = 10.2
print(array_1d)

No se lanzó ninguna excepción; sin embargo, al primer elemento se le asignó el valor `10` en lugar de `10.2`. El valor `float` se convirtió en **entero** ya que ese es el `dtype` del array.

La imagen a continuación muestra la estructura del array `employee_data` utilizado en la tarea:

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):
    """Codefinity-style feedback formatting"""
    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):
        # Очікуваний масив після оновлення
        cls.initial_data = np.array([
            [4500, 7],
            [3800, 8],
            [5200, 9],
            [4700, 6],
            [4300, 7],
            [3900, 5]
        ])
        cls.expected_data = cls.initial_data.copy()
        cls.expected_data[3, 0] = 6000

    def test_salary_updated(self):
        """1–2. Salary of fourth employee updated to 6000 using positive indexing"""
        # Перехоплюємо stdout під час виконання користувацького коду
        f = io.StringIO()
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        with redirect_stdout(f):
            spec.loader.exec_module(module)
        output = f.getvalue().strip()

        # Отримуємо змінну з модуля
        employee_data = getattr(module, "employee_data", None)
        type_ok = isinstance(employee_data, np.ndarray)

        # Перевіряємо, що правильний елемент оновлено
        value_ok = type_ok and employee_data[3, 0] == 6000

        # Перевіряємо, що решта елементів не змінена
        unchanged_ok = type_ok and np.array_equal(
            np.delete(employee_data, (3,), axis=0),
            np.delete(self.expected_data, (3,), axis=0)
        )

        # Перевіряємо, що результат надруковано
        printed_ok = "6000" in output

        _dynamic_test(
            self,
            type_ok and value_ok and unchanged_ok and printed_ok,
            "Salary updated and printed correctly",
            "Salary update incorrect or print missing",
        )


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.

Asignación de valores a elementos indexados

Solución