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

**Segmentación** en Python se refiere a la obtención de elementos desde un índice hasta otro dentro de una secuencia. Sin embargo, en este capítulo nos centraremos en la segmentación en arreglos de **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.

## Segmentación en arreglos 1D

La sintaxis general para la segmentación en arreglos 1D es la siguiente: `array[start:end:step]`.

- `start` es el índice en el que comienza la segmentación;
- `end` es el índice en el que termina la segmentación (el índice en sí no se incluye);
- `step` especifica los incrementos entre los índices (el valor predeterminado es `1`).

Aquí tienes un ejemplo para aclarar todo (los cuadros de color **morado** representan los elementos obtenidos mediante la segmentación):

Como no especificamos explícitamente `step`, su valor predeterminado es `1`.

Nota

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

## Omisión de inicio, fin y paso

Como puedes observar, a menudo podemos **omitir** los valores de `start`, `end`, `step` o incluso todos al mismo tiempo. Por ejemplo, `step` puede omitirse cuando queremos que sea igual a `1`. `start` y `end` pueden omitirse en los siguientes casos:
1. Omitir `start`:
    - Corte desde el primer elemento (`step` es positivo);
    - Corte desde el último elemento (`step` es negativo).
2. Omitir `end`:
    - Corte hasta el último elemento inclusive (`step` es positivo);
    - Corte hasta el primer elemento inclusive (`step` es negativo).


Veamos algunos ejemplos más (la **flecha negra** indica que los elementos se toman en **orden inverso**):

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

La imagen a continuación muestra la estructura del arreglo `weekly_sales` utilizado en la tarea:

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

Desbloquea todo el potencial de la biblioteca más esencial de Python para el cálculo numérico, NumPy. Este curso integral está diseñado para llevarte desde un nivel principiante hasta un nivel avanzado de competencia en NumPy. Ya seas científico de datos, ingeniero, investigador o desarrollador, dominar NumPy es fundamental para la manipulación eficiente de datos, el cálculo científico y el aprendizaje automático.

Explora las aplicaciones de NumPy y comprende por qué es una de las bibliotecas más populares para el cálculo numérico. Aprende las diferentes formas de crear e inicializar arreglos para manejar diversas necesidades de datos de manera eficiente.

Descubre cómo acceder a elementos específicos y subconjuntos en arreglos de NumPy utilizando la notación de índices. Aprende a aplicar indexación condicional para filtrar datos y gestionar valores faltantes de manera eficiente.

NumPy ofrece muchas funciones integradas para realizar operaciones comunes con arreglos. Aprenda cómo aplicar estas herramientas para transformar, agregar y analizar datos de manera eficiente sin escribir código repetitivo.

Aprende a realizar operaciones matemáticas de manera eficiente en arreglos de NumPy. Aplica estas operaciones para resolver problemas del mundo real y adquiere una comprensión más profunda de cómo los cálculos vectorizados aceleran el análisis numérico.

Segmentación

Segmentación en arreglos 1D

Omisión de inicio, fin y paso

Solución