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.

Slicing in 2D and **higher-dimensional arrays** works similarly to slicing in 1D arrays. However, in 2D arrays, there are two axes.

If you want to perform slicing only on **axis 0** to retrieve 1D arrays, the syntax remains the same: `array[start:end:step]`. If you want to perform slicing on the elements of these 1D arrays (**axis 1**), the syntax is as follows: `array[start:end:step, start:end:step]`. Essentially, the number of slices corresponds to the **number of dimensions** of an array.

Moreover, you can use slicing for one axis and **basic indexing** for the other axis. Take a look at an example of 2D slicing (**purple** squares represent the elements retrieved from slicing, and the **black arrow** indicates that the elements are taken in reverse order):

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

The picture below shows the structure of the `student_scores` array used in the task:

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

Unlock the full potential of Python's most essential library for numerical computing, NumPy. This comprehensive course is designed to take you from a beginner's understanding to an advanced level of proficiency in NumPy. Whether you're a data scientist, engineer, researcher, or developer, mastering NumPy is essential for efficient data manipulation, scientific computing, and machine learning.

Explore the applications of NumPy and understand why it's one of the most popular libraries for numerical computing. Learn the different ways to create and initialize arrays to handle various data needs efficiently.

Discover how to access specific elements and subsets in NumPy arrays using index notation. Learn to apply conditional indexing to filter data and manage missing values efficiently.

NumPy provides many built-in functions for performing common array operations. Learn how to apply these tools to transform, aggregate, and analyze data efficiently without writing repetitive code.

Learn how to perform mathematical operations efficiently on NumPy arrays. Apply these operations to solve real-world problems and gain a deeper understanding of how vectorized computations speed up numerical analysis.

Slicing in 2D Arrays

Solution