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

**Découpage** (slicing) en Python désigne l'extraction d'éléments d'une séquence entre deux indices. Dans ce chapitre, l'accent sera mis sur le découpage dans les tableaux **NumPy**.

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.

## Découpage dans les tableaux 1D

La syntaxe générale pour le découpage dans les tableaux 1D est la suivante : `array[start:end:step]`.

- `start` correspond à l'indice de début du découpage ;
- `end` correspond à l'indice de fin du découpage (l'indice lui-même n'est pas inclus) ;
- `step` indique l'incrément entre les indices (par défaut, `1`).

Voici un exemple pour illustrer ces notions (les cases **violettes** représentent les éléments extraits par le découpage) :

Comme nous n'avons pas explicitement spécifié `step`, sa valeur par défaut est `1`.

Remarque

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

## Omission du début, de la fin et du pas

Comme vous pouvez le constater, il est souvent possible d’**omettre** les paramètres `start`, `end`, `step`, ou même tous en même temps. Par exemple, `step` peut être omis lorsqu’on souhaite qu’il soit égal à `1`. `start` et `end` peuvent être omis dans les cas suivants :
1. Omission de `start` :
    - Découpage à partir du premier élément (`step` positif) ;
    - Découpage à partir du dernier élément (`step` négatif).
2. Omission de `end` :
    - Découpage jusqu’au dernier élément inclus (`step` positif) ;
    - Découpage jusqu’au premier élément inclus (`step` négatif).


Voici quelques exemples supplémentaires (la **flèche noire** indique que les éléments sont pris dans l’**ordre inverse**) :

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

L'image ci-dessous montre la structure du tableau `weekly_sales` utilisé dans l'exercice :

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

Libérez tout le potentiel de la bibliothèque la plus essentielle de Python pour le calcul numérique, NumPy. Ce cours complet est conçu pour vous faire passer d'une compréhension débutante à un niveau avancé de maîtrise de NumPy. Que vous soyez data scientist, ingénieur, chercheur ou développeur, la maîtrise de NumPy est essentielle pour une manipulation efficace des données, le calcul scientifique et l'apprentissage automatique.

Explorez les applications de NumPy et comprenez pourquoi il s'agit de l'une des bibliothèques les plus populaires pour le calcul numérique. Découvrez les différentes méthodes de création et d'initialisation des tableaux afin de répondre efficacement à divers besoins en données.

Découvrez comment accéder à des éléments spécifiques et à des sous-ensembles dans les tableaux NumPy en utilisant la notation d'index. Apprenez à appliquer l'indexation conditionnelle pour filtrer les données et gérer efficacement les valeurs manquantes.

NumPy propose de nombreuses fonctions intégrées pour effectuer des opérations courantes sur les tableaux. Découvrez comment utiliser ces outils pour transformer, agréger et analyser les données efficacement sans écrire de code répétitif.

Apprenez à effectuer des opérations mathématiques efficacement sur des tableaux NumPy. Appliquez ces opérations pour résoudre des problèmes concrets et acquérez une compréhension approfondie de la manière dont les calculs vectorisés accélèrent l'analyse numérique.

Découpage

Découpage dans les tableaux 1D

Omission du début, de la fin et du pas

Solution