Summary
This chapter covers sorting arrays using a function that returns a new sorted array versus an in-place method, and shows how to obtain ascending and descending order (via slicing).

General domain of usage
Employee salary data analysis

**Sorteren** betekent het rangschikken van de elementen van een array in een bepaalde volgorde.

Definitie

Deze bewerking is uiterst nuttig omdat zoeken in een **gesorteerde array** veel sneller is, aangezien efficiënte algoritmen zoals **binaire zoekopdracht** alleen werken met gesorteerde arrays.

Watch this video for a step-by-step explanation of sorting arrays in NumPy. You'll learn how to use both the `numpy.sort()` function and the `.sort()` method, see how to sort arrays in ascending and descending order, and understand the difference between sorting functions and methods. Real-world examples, such as sorting employee salaries, will help you master these essential array manipulation techniques.

## numpy.sort() functie

**NumPy** heeft een ingebouwde functie `sort()` voor het sorteren van elementen op waarde in oplopende volgorde. De returnwaarde van deze functie is een gesorteerde **NumPy** array. Hier is de algemene syntaxis: `numpy.sort(a, axis=-1, kind=None, order=None)`, waarbij:
* `a` een array is;
* `axis` de as is waarlangs gesorteerd wordt (standaard de laatste as (`-1`));
* `kind` het te gebruiken sorteeralgoritme is (standaard `quicksort`).

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

## ndarray.sort()-methode

Zoals eerder vermeld, retourneert de functie `numpy.sort()` een gesorteerde array maar verandert het **originele** array niet. Als je het array wilt aanpassen, moet je `array = np.sort(array)` schrijven.

Echter, **NumPy** biedt als alternatief een `.sort()`-methode, die het array **in-place** sorteert en geen nieuw array retourneert (het retourneert `None`, wat betekent dat het niets teruggeeft). De syntaxis is vergelijkbaar met de `sort()`-functie.

Een **functie** is een op zichzelf staand codeblok dat een specifieke taak uitvoert en direct kan worden aangeroepen. Een **methode** is een functie die aan een object is gekoppeld en op dat object wordt aangeroepen met behulp van de `.`-operator.

Opmerking

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

Na het aanroepen van de `.sort()`-methode is `array_1d` **in-place** gesorteerd en bevat nu elementen in **oplopende** volgorde.


## 1D-arrays sorteren in aflopende volgorde

Soms wil je een array sorteren in **aflopende** volgorde. Noch de `.sort()`-methode noch de `sort()`-functie ondersteunt deze functionaliteit direct. Je kunt echter eenvoudig **slicing** gebruiken met `step` gelijk aan `-1` op een gesorteerde 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

Ontgrendel het volledige potentieel van Python's meest essentiële bibliotheek voor numerieke berekeningen, NumPy. Deze uitgebreide cursus is ontworpen om je van een basiskennis naar een gevorderd niveau van vaardigheid in NumPy te brengen. Of je nu data scientist, ingenieur, onderzoeker of ontwikkelaar bent, het beheersen van NumPy is essentieel voor efficiënte datamanipulatie, wetenschappelijk rekenen en machine learning.

Ontdek de toepassingen van NumPy en begrijp waarom het een van de populairste bibliotheken is voor numerieke berekeningen. Leer de verschillende manieren om arrays te maken en te initialiseren om efficiënt aan diverse databehoeften te voldoen.

Ontdek hoe u specifieke elementen en deelverzamelingen in NumPy-arrays kunt benaderen met behulp van indexnotatie. Leer om conditionele indexering toe te passen om gegevens te filteren en ontbrekende waarden efficiënt te beheren.

NumPy biedt veel ingebouwde functies voor het uitvoeren van veelvoorkomende arraybewerkingen. Leer hoe u deze tools kunt toepassen om gegevens efficiënt te transformeren, aggregeren en analyseren zonder repetitieve code te schrijven.

Leer hoe u wiskundige bewerkingen efficiënt uitvoert op NumPy-arrays. Pas deze bewerkingen toe om realistische problemen op te lossen en krijg een dieper inzicht in hoe gevectoriseerde berekeningen numerieke analyses versnellen.

Arrays Sorteren

numpy.sort() functie

ndarray.sort()-methode

1D-arrays sorteren in aflopende volgorde

Oplossing