Summary  
This chapter covers slicing and indexing operations on two-dimensional arrays, demonstrating how to extract specific rows, columns, and rectangular subarrays using comma-separated range syntax, negative indexes, and mixed basic indexing.  

General domain of usage  
Data analysis

Watch this video to see how slicing works in 2D NumPy arrays. You'll learn how to extract rows, columns, and subarrays using slicing syntax like `array[start:end, start:end]`. The video uses clear visualizations and practical examples—mirroring the illustrations in this chapter—to help you master retrieving data from different parts of a 2D array. By the end, you'll know how to combine slicing and indexing to select exactly the data you need.

Il slicing negli array 2D e negli **array a dimensioni superiori** funziona in modo simile al slicing negli array 1D. Tuttavia, negli array 2D sono presenti due assi.

Se si desidera effettuare il slicing solo sull’**asse 0** per ottenere array 1D, la sintassi rimane la stessa: `array[start:end:step]`. Se si vuole effettuare il slicing sugli elementi di questi array 1D (**asse 1**), la sintassi è la seguente: `array[start:end:step, start:end:step]`. In sostanza, il numero di slice corrisponde al **numero di dimensioni** di un array.

Inoltre, è possibile utilizzare il slicing per un asse e l’**indicizzazione di base** per l’altro asse. Di seguito un esempio di slicing 2D (i quadrati **viola** rappresentano gli elementi ottenuti dal slicing, mentre la **freccia nera** indica che gli elementi sono presi in ordine inverso):

import numpy as np

array_2d = np.array([
   [1, 2, 3, 4],
   [5, 6, 7, 8],
   [9, 10, 11, 12]
])

# Initial Array
print("Initial array_2d:\n", array_2d)
# Rows from index 1 to the end
print("\narray_2d[1:]:\n", array_2d[1:])
# All rows, first column only
print("\narray_2d[:, 0]:\n", array_2d[:, 0])
# Subarray: rows from 1 to end, columns from 1 to second-to-last
print("\narray_2d[1:, 1:-1]:\n", array_2d[1:, 1:-1])
# All rows except the last, every second column
print("\narray_2d[:-1, ::2]:\n", array_2d[:-1, ::2])
# Third row (index 2) reversed
print("\narray_2d[2, ::-1]:\n", array_2d[2, ::-1])

L'immagine sottostante mostra la struttura dell'array `student_scores` utilizzato nell'esercizio:

import unittest
import importlib.util
import numpy as np


def _dynamic_test(test_case, condition, success_message, failure_message):
    """Codefinity-style test message handler"""
    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.student_scores = np.array([
            [85, 92, 78],
            [88, 75, 83],
            [90, 88, 91]
        ])
        cls.expected_slice = cls.student_scores[0, 1:]  # [92, 78]

    def test_first_student_last_two_scores(self):
        """1–2. Slice includes last two scores of first student using positive indexing"""
        ok = hasattr(self.m, "first_student_last_two_scores")
        arr = getattr(self.m, "first_student_last_two_scores", None)

        type_ok = isinstance(arr, np.ndarray)
        val_ok = type_ok and np.array_equal(arr, self.expected_slice)
        shape_ok = type_ok and arr.shape == (2,)

        # Перевіряємо, що взято елементи саме з першого рядка (0) і стовпців з індексу 1+
        indices_correct = type_ok and np.array_equal(arr, self.student_scores[0][1:])

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


if __name__ == "__main__":
    unittest.main()


test_code.py

Sblocca il pieno potenziale della libreria più essenziale di Python per il calcolo numerico, NumPy. Questo corso completo è progettato per portarti da una comprensione da principiante a un livello avanzato di competenza in NumPy. Che tu sia un data scientist, un ingegnere, un ricercatore o uno sviluppatore, padroneggiare NumPy è fondamentale per una manipolazione efficiente dei dati, il calcolo scientifico e il machine learning.

Esplora le applicazioni di NumPy e comprendi perché è una delle librerie più popolari per il calcolo numerico. Scopri i diversi modi per creare e inizializzare array per gestire in modo efficiente varie esigenze di dati.

Scopri come accedere a elementi specifici e sottoinsiemi negli array NumPy utilizzando la notazione degli indici. Apprendi come applicare l'indicizzazione condizionale per filtrare i dati e gestire in modo efficiente i valori mancanti.

NumPy offre molte funzioni integrate per eseguire operazioni comuni sugli array. Scopri come applicare questi strumenti per trasformare, aggregare e analizzare i dati in modo efficiente senza scrivere codice ripetitivo.

Impara come eseguire operazioni matematiche in modo efficiente sugli array NumPy. Applica queste operazioni per risolvere problemi reali e acquisisci una comprensione più approfondita di come i calcoli vettorializzati accelerano l'analisi numerica.

Slicing in Array 2D

Soluzione