Summary  
This chapter covers methods for sorting array elements in ascending or descending order using NumPy’s out-of-place `sort()` function and in-place `.sort()` method.

General domain of usage  
Data analysis

**Sorting** means arranging the elements of an array in a certain order.

Definition

This operation is extremely useful since searching in a **sorted array** is much faster because efficient algorithms like **binary search** work only with sorted arrays.

## numpy.sort() function

**NumPy** has a built-in function `sort()` for sorting elements by values in ascending order. The return value of this function is a sorted **NumPy** array. Here is its general syntax: `numpy.sort(a, axis=-1, kind=None, order=None)`, where:
* `a` is an array;
* `axis` is the axis along which to sort (last axis (`-1`) by default);
* `kind` is the sorting algorithm to use (`quicksort` by default).

import numpy as np
array_1d = np.array([10, 2, 5, 1, 6, 5])
print(np.sort(array_1d))

## ndarray.sort() method

As we already mentioned, the `numpy.sort()` function returns a sorted array but does not change the **original** array. If we wanted to change the array, we would have to write `array = np.sort(array)`.

However, **NumPy** provides a `.sort()` method as an alternative, which sorts the array **in-place** and does not return a new array (it returns `None`, meaning it doesn't return anything). Its syntax is similar to the `sort()` function.

A **function** is a standalone block of code that performs a specific task and can be called directly. A **method** is a function that is associated with an object and is called on that object, using the `.` operator.

Note

import numpy as np
array_1d = np.array([10, 2, 5, 1, 6, 5])
# Calling the .sort() method 
array_1d.sort()
print(array_1d)

After calling the `.sort()` method, `array_1d` was sorted **in place** and now contains elements sorted in **ascending** order.


## Sorting 1D Arrays in Descending Order

Sometimes we may want to sort an array in **descending** order. Neither the `.sort()` method nor the `sort()` function supports this functionality directly. However, we can simply use **slicing** with `step` equal to `-1` on a sorted array:

import numpy as np
array_1d = np.array([10, 2, 5, 1, 6, 5])
# Sorting array_1d in descending order
array_1d = np.sort(array_1d)[::-1]
print(array_1d)

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 formatted 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.salaries = np.array([45000, 38000, 52000, 47000, 43000, 39000])
        cls.expected_sorted = np.sort(cls.salaries)[::-1]  # спадний порядок
        cls.expected_top3 = cls.expected_sorted[:3]

    def test_sorted_salaries(self):
        """1. salaries 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, "sorted_salaries")
        arr = getattr(module, "sorted_salaries", None)
        type_ok = isinstance(arr, np.ndarray)
        val_ok = type_ok and np.array_equal(arr, self.expected_sorted)
        order_ok = type_ok and np.all(np.diff(arr) <= 0)

        _dynamic_test(
            self,
            ok and type_ok and val_ok and order_ok,
            "salaries sorted in descending order correctly",
            "salaries not sorted correctly in descending order",
        )

    def test_print_top3(self):
        """2. top 3 salaries printed using positive end slice"""
        # Перехоплюємо stdout
        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()

        # Перевірка, що всі 3 найбільші зарплати є у виводі
        expected_values = [str(x) for x in self.expected_top3]
        contains_all = all(val in output for val in expected_values)

        # Перевірка, що не виведено більше трьох
        contains_extra = any(str(x) in output for x in self.expected_sorted[3:])

        _dynamic_test(
            self,
            contains_all and not contains_extra,
            "top 3 salaries printed correctly",
            "top 3 salaries print incorrect or extra values included",
        )


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 Arrays

numpy.sort() function

ndarray.sort() method

Sorting 1D Arrays in Descending Order

Lösning