Summary  
This chapter explains how to slice arrays by specifying start, end, and step parameters—using defaults and negative values—to extract or reverse subarrays without copying data.

General domain of usage  
Numerical computing

**Slicing** i Python refererer til at hente elementer fra et indeks til et andet inden for en sekvens. I dette kapitel fokuseres der dog på slicing i **NumPy** arrays.

Watch this video for a comprehensive explanation of slicing in NumPy arrays. The video covers the syntax for 1D slicing, how to omit start, end, and step values, and demonstrates each concept with clear visual aids and real array examples. You'll see how different slices affect the output, making the rules of slicing easy to grasp.

## Slicing i 1D-arrays

Den generelle syntaks for slicing i 1D-arrays er som følger: `array[start:end:step]`.

- `start` er indekset, hvor slicing starter;
- `end` er indekset, hvor slicing slutter (selve indekset er ikke inkluderet);
- `step` angiver springet mellem indeksene (standard er `1`).

Her er et eksempel, der tydeliggør det hele (**lilla** felter repræsenterer de elementer, der hentes ved slicing):

Da du ikke eksplicit har angivet `step`, antages den som standard til værdien `1`.

Bemærk

import numpy as np
array = np.array([5, 10, 2, 8, 9, 1, 0, 4])
print(f'Initial array: {array}')
# Slicing from the element at index 2 to the element at index 4 exclusive
print(array[2:4])
# Slicing from the first element to the element at index 5 exclusive
print(array[:5])
# Slicing from the element at index 5 to the last element inclusive
print(array[5:])

## Udeladelse af Start, Slut og Step
Som du kan se, kan du ofte **udelade** `start`, `end`, `step` eller endda dem alle på samme tid. `step` kan udelades, når du ønsker, at den skal være lig med `1`. `start` og `end` kan udelades i følgende scenarier:
1. Udeladelse af `start`:
    - Udskæring fra det første element (`step` er positiv);
    - Udskæring fra det sidste element (`step` er negativ).
2. Udeladelse af `end`:
    - Udskæring til det sidste element inklusiv (`step` er positiv);
    - Udskæring til det første element inklusiv (`step` er negativ).

Se et par flere eksempler (den **sorte pil** angiver, at elementerne tages i **omvendt rækkefølge**):

import numpy as np
array = np.array([5, 10, 2, 8, 9, 1, 0, 4])
print(f'Initial array: {array}')
# Slicing from the first element to the last element inclusive with step=2
print(array[::2])
# Slicing from the element at index 4 to the element at index 2 exclusive (step=-1)
print(array[4:2:-1])
# Slicing from the last element to the first element inclusive (reversed array)
print(array[::-1])
# Slicing from the first element to the last inclusive (the same as our array)
print(array[:])

Billedet nedenfor viser strukturen af `weekly_sales` arrayet, som bruges i opgaven:

import unittest
import importlib.util
import numpy as np


def _dynamic_test(test_case, condition, success_message, failure_message):
    """Codefinity-style formatted test 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):
        # Імпортуємо user_code
        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.weekly_sales = np.array([150, 200, 170, 180, 160, 210, 190])
        cls.expected_alternate = cls.weekly_sales[1::2]  # [200, 180, 210]

    def test_alternate_day_sales(self):
        """1–3. alternate_day_sales — зріз із кожного другого дня, починаючи з другого (вівторок)"""
        ok = hasattr(self.m, "alternate_day_sales")
        arr = getattr(self.m, "alternate_day_sales", None)

        type_ok = isinstance(arr, np.ndarray)
        val_ok = type_ok and np.array_equal(arr, self.expected_alternate)
        shape_ok = type_ok and arr.ndim == 1 and len(arr) == len(self.expected_alternate)

        # Перевіряємо, що значення відповідають саме елементам із індексами 1, 3, 5
        indices_correct = type_ok and np.array_equal(arr, self.weekly_sales[[1, 3, 5]])

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok and indices_correct,
            "alternate_day_sales slice created correctly",
            "alternate_day_sales slice incorrect",
        )


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.

Udsnit

Slicing i 1D-arrays

Udeladelse af Start, Slut og Step

Løsning