Summary  
This chapter explains how to assign scalar values or entire arrays to selected portions of one- and two-dimensional arrays using slicing, integer-array indexing, boolean indexing, and NumPy’s broadcasting rules.  

General domain of usage  
data manipulation

Med indekserede arrays bliver tingene mere interessante. Her fokuserer vi på 1D- og 2D-**delarrays**, da 3D-delarrays sjældent anvendes i praksis.

Watch this video for a step-by-step visual explanation of assigning values to indexed subarrays in NumPy. You'll see demonstrations of the different assignment methods for both 1D and 2D arrays, including how to use scalars, 1D arrays, and 2D arrays with slices. The video covers all the examples from this chapter, so you can follow along and understand how each type of assignment works in practice.

Lad os først begynde med at tildele værdier til **slices**. Den generelle syntaks ser sådan ud: `slice = values`, hvor `slice` er et udsnit af et bestemt array, og `values` er de værdier, der skal tildeles.

Mulige formater for `values`:
* en **enkelt skalar** (tal);
* et **1D-array** af samme størrelse som udsnittet (hvis det er 1D); eller størrelsen af den anden dimension (hvis udsnittet er 2D);
* et **2D-array** med samme form som et 2D-udsnit.

import numpy as np
array_1d = np.array([1, 4, 6, 2, 9])
# Assigning an array to the slice of array_1d
array_1d[1:-1] = np.array([3, 5, 7])
print(array_1d)
# Assigning a scalar to the slice of array_1d
array_1d[1:-1] = 5
print(array_1d)
array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
# Assigning a 2D array to the slice of array_2d
array_2d[1:3, 1:] = np.array([[20, 21], [40, 41]])
print(array_2d)
# Assigning a 1D array to the slice of array_2d
array_2d[1:3, 1:] = [50, 51]
print(array_2d)
# Assigning a scalar to the slice of array_2d
array_2d[1:3, 1:] = 30
print(array_2d)

Når vi tildeler en **skalar** til et 1D-udsnit, bliver denne skalar tildelt **hver enkelt element** i udsnittet. Når et **1D-array** tildeles et **2D-udsnit**, bliver dette 1D-array tildelt **hver 1D-array** i udsnittet. Tildeling af en **skalar** til et 2D-udsnit fungerer på samme måde som med et 1D-udsnit.

Tildeling af værdier til **heltalsarray-indekserede** del-arrays fungerer på samme måde som med udsnit. Tildeling af værdier til **boolesk-indekserede** del-arrays fungerer på samme måde som med 1D-udsnit.

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 output for test results"""
    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.init_prices = np.array([15, 8, 22, 7, 12, 5])
        cls.expected_prices = cls.init_prices.copy()
        cls.expected_prices[cls.init_prices > 10] = 20

        cls.init_ratings = np.array([[6, 8, 9], [7, 5, 10]])
        cls.expected_ratings = cls.init_ratings.copy()
        cls.expected_ratings[1, 1:] = np.array([9, 8])

    def test_prices_update(self):
        """1. Assign 20 to every element in prices greater than 10"""
        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()

        prices = getattr(module, "prices", None)
        type_ok = isinstance(prices, np.ndarray)
        val_ok = type_ok and np.array_equal(prices, self.expected_prices)

        # Перевіряємо, що всі значення > 10 стали 20
        logic_ok = type_ok and np.all(prices[self.init_prices > 10] == 20)

        # Перевіряємо наявність друку
        printed_ok = "20" in output

        _dynamic_test(
            self,
            type_ok and val_ok and logic_ok and printed_ok,
            "prices updated and printed correctly",
            "prices update incorrect or print missing",
        )

    def test_ratings_update(self):
        """2. Assign [9, 8] to last two elements of second row using positive row index and slice"""
        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()

        ratings = getattr(module, "ratings", None)
        type_ok = isinstance(ratings, np.ndarray)
        val_ok = type_ok and np.array_equal(ratings, self.expected_ratings)

        # Перевірка: змінилася лише друга стрічка
        second_row_correct = type_ok and np.array_equal(ratings[1, 1:], np.array([9, 8]))
        first_row_unchanged = type_ok and np.array_equal(ratings[0], np.array([6, 8, 9]))

        printed_ok = "9" in output and "8" in output

        _dynamic_test(
            self,
            type_ok and val_ok and second_row_correct and first_row_unchanged and printed_ok,
            "ratings updated and printed correctly",
            "ratings update incorrect or print missing",
        )


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.

Tildeling af værdier til indekserede underarrayer

Løsning