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** in Python bezeichnet das Abrufen von Elementen von einem Index bis zu einem anderen innerhalb einer Sequenz. In diesem Kapitel liegt der Fokus jedoch auf dem 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** Kästchen stellen die durch das Slicing abgerufenen Elemente dar):

Da Sie `step` nicht explizit angegeben haben, wird standardmäßig der Wert `1` verwendet.

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 Sie häufig `start`, `end`, `step` oder sogar alle gleichzeitig weglassen. `step` kann weggelassen werden, wenn er den Wert `1` haben soll. `start` und `end` können in den folgenden Fällen weggelassen werden:
1. Weglassen von `start`:
    - Slicing ab dem ersten Element (`step` ist positiv);
    - Slicing ab dem letzten Element (`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).

Sehen Sie sich noch einige weitere Beispiele an (der schwarze Pfeil zeigt an, dass die Elemente in umgekehrter Reihenfolge ausgewählt 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[:])

Das folgende Bild zeigt die Struktur des `weekly_sales`-Arrays, das in der Aufgabe verwendet wird:

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