Summary  
This chapter covers how to sort 2D arrays by specifying different axes (rows, columns, or flattening) and how to apply reverse slicing to obtain descending order.  

General domain of usage  
Data analysis

As you can see, simply passing our 2D array to the `sort()` function sorts each 1D array along the **axis 1** (which is the  default option in a 2D array). Setting `axis=0` sorts each 1D array along the **axis 0** (every column). 

Setting `axis=None` returns a **contiguous sorted 1D array** of all the elements of the 2D array.

import numpy as np
array_2d = np.array([[2, 9, 3], [1, 6, 4], [5, 7, 8]])
# Sorting a 2D array along axis 1
print(np.sort(array_2d))
# Sorting a 2D array along axis 0
print(np.sort(array_2d, axis=0))
# Creating a 1D sorted array out of the elements of array_2d
print(np.sort(array_2d, axis=None))

## Sorting 2D Arrays in Descending Order

When sorting 2D arrays in **descending order** along a given axis, you need to use **two** slices: one **full** slice (`[:]`) and another with a negative step (`[::-1]`). The position of the slice with the negative step should correspond to the **axis** along which you are sorting.

When sorting along **axis 0**, you can use only a slice with a negative step, as it already indexes along this axis.

Note

import numpy as np
array_2d = np.array([[2, 9, 3], [1, 6, 4], [5, 7, 8]])
# Sorting a 2D array along axis 1 in descending order
print(np.sort(array_2d)[:, ::-1])
# Sorting a 2D array along axis 0 in descending order
print(np.sort(array_2d, axis=0)[::-1])
# Creating a 1D sorted array out of the elements of array_2d in descending order
print(np.sort(array_2d, axis=None)[::-1])

import unittest
import importlib.util
import numpy as np
import io
from contextlib import redirect_stdout


def _dynamic_test(test_case, condition, success_message, failure_message):
    """Codefinity-style 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):
        # Початкові дані
        cls.exam_scores = np.array([
            [75, 82, 90],
            [92, 88, 78],
            [60, 70, 85]
        ])
        # Очікувані результати
        cls.expected_top = np.sort(cls.exam_scores, axis=0)[::-1]
        cls.expected_sorted = np.sort(cls.exam_scores, axis=None)

    def test_top_scores_subject(self):
        """1. Columns sorted in descending order"""
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)

        ok = hasattr(module, "top_scores_subject")
        arr = getattr(module, "top_scores_subject", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == self.expected_top.shape
        val_ok = type_ok and np.array_equal(arr, self.expected_top)

        # Перевірка: усередині кожного стовпця порядок спадний
        desc_ok = type_ok and np.all(np.diff(arr, axis=0) <= 0)

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok and desc_ok,
            "top_scores_subject sorted correctly by column (descending)",
            "top_scores_subject sorting incorrect",
        )

    def test_sorted_scores(self):
        """2. All scores sorted in ascending order"""
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)

        ok = hasattr(module, "sorted_scores")
        arr = getattr(module, "sorted_scores", None)
        type_ok = isinstance(arr, np.ndarray)
        dim_ok = type_ok and arr.ndim == 1
        val_ok = type_ok and np.array_equal(arr, self.expected_sorted)
        asc_ok = type_ok and np.all(np.diff(arr) >= 0)

        _dynamic_test(
            self,
            ok and type_ok and dim_ok and val_ok and asc_ok,
            "sorted_scores created correctly in ascending order",
            "sorted_scores incorrect or unsorted",
        )

    def test_print_output(self):
        """3. Both arrays printed"""
        f = io.StringIO()
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        with redirect_stdout(f):
            spec.loader.exec_module(module)
        output = f.getvalue().strip()

        printed_top = "90" in output and "92" in output  # representative values
        printed_sorted = "60" in output and "92" in output

        _dynamic_test(
            self,
            printed_top and printed_sorted,
            "Both arrays printed correctly",
            "Missing or incorrect print output",
        )


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


test_code.py

Develop essential skills for numerical computing using NumPy. Learn how to work with NumPy arrays, create and manipulate multidimensional data, apply indexing and slicing, perform vectorized operations, reshape arrays, use broadcasting, and apply basic linear algebra techniques. The course focuses on practical operations commonly used in data analysis tasks.

Sorting 2D Arrays

Sorting 2D Arrays in Descending Order

Løsning