Summary  
This chapter explains how to extract subarrays from a NumPy array using slicing syntax (`array[start:end:step]`), including omitting parameters for defaults and using negative steps to reverse or skip elements.

General domain of usage  
Data analysis

**Slicing** in Python bezeichnet das Abrufen von Elementen von einem Index bis zu einem anderen innerhalb einer Sequenz. In diesem Kapitel konzentrieren wir uns jedoch auf das Slicing in **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 in 1D-Arrays

Die allgemeine Syntax für Slicing in 1D-Arrays lautet: `array[start:end:step]`.

- `start` ist der Index, bei dem das Slicing beginnt;
- `end` ist der Index, bei dem das Slicing endet (der Index selbst ist nicht enthalten);
- `step` gibt die Schritte zwischen den Indizes an (Standardwert ist `1`).

Hier ein Beispiel zur Veranschaulichung (**lilafarbene** Felder stellen die durch das Slicing abgerufenen Elemente dar):

Da wir `step` nicht explizit angegeben haben, ist der Standardwert `1`.

Hinweis

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:])

## Start-, End- und Schrittwert weglassen

Wie Sie sehen, können wir häufig die `start`, `end` und `step` **weglassen**, oder sogar alle gleichzeitig.

Zum Beispiel kann der `step`-Wert weggelassen werden, wenn er `1` sein soll.

`start` und `end` können in folgenden Szenarien weggelassen werden:
1. Weglassen von `start`:
    - Slicing vom ersten Element aus (`step` ist positiv);
    - Slicing vom letzten Element aus (`step` ist negativ).
2. Weglassen von `end`:
    - Slicing bis zum letzten Element inklusive (`step` ist positiv);
    - Slicing bis zum ersten Element inklusive (`step` ist negativ).

Schauen wir uns noch ein paar weitere Beispiele an (der **schwarze Pfeil** zeigt an, dass die Elemente in **umgekehrter Reihenfolge** genommen werden):

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[:])

Die folgende Abbildung zeigt die Struktur des in der Aufgabe verwendeten Arrays `weekly_sales`:

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

Entfesseln Sie das volle Potenzial von Pythons wichtigster Bibliothek für numerisches Rechnen, NumPy. Dieser umfassende Kurs ist darauf ausgelegt, Sie von grundlegenden Kenntnissen bis hin zu fortgeschrittener NumPy-Kompetenz zu führen. Ob Datenwissenschaftler, Ingenieur, Forscher oder Entwickler – die Beherrschung von NumPy ist unerlässlich für effiziente Datenmanipulation, wissenschaftliches Rechnen und maschinelles Lernen.

Erkunden Sie die Anwendungen von NumPy und verstehen Sie, warum es eine der beliebtesten Bibliotheken für numerische Berechnungen ist. Lernen Sie die verschiedenen Methoden zur Erstellung und Initialisierung von Arrays kennen, um unterschiedliche Datenanforderungen effizient zu bewältigen.

Erfahren Sie, wie Sie mit Indexnotation auf bestimmte Elemente und Teilmengen in NumPy-Arrays zugreifen. Lernen Sie, bedingte Indizierung anzuwenden, um Daten zu filtern und fehlende Werte effizient zu verwalten.

NumPy bietet viele integrierte Funktionen zur Durchführung gängiger Array-Operationen. Lernen Sie, wie Sie diese Werkzeuge anwenden, um Daten effizient zu transformieren, zu aggregieren und zu analysieren, ohne wiederholten Code schreiben zu müssen.

Erfahren Sie, wie mathematische Operationen effizient auf NumPy-Arrays durchgeführt werden. Wenden Sie diese Operationen an, um reale Probleme zu lösen, und gewinnen Sie ein tieferes Verständnis dafür, wie vektorisierte Berechnungen die numerische Analyse beschleunigen.

Slicing

Slicing in 1D-Arrays

Start-, End- und Schrittwert weglassen

Lösung