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

**Lajittelu** tarkoittaa taulukon alkioiden järjestämistä tiettyyn järjestykseen.

Määritelmä

Tämä toiminto on erittäin hyödyllinen, koska haku **lajitellusta taulukosta** on paljon nopeampaa, sillä tehokkaat algoritmit kuten **binäärihaku** toimivat vain lajitelluilla taulukoilla.

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()-funktio

**NumPy** sisältää sisäänrakennetun `sort()`-funktion, jolla voidaan lajitella alkiot arvojen mukaan nousevaan järjestykseen. Tämän funktion palautusarvo on lajiteltu **NumPy**-taulukko. Yleinen syntaksi on: `numpy.sort(a, axis=-1, kind=None, order=None)`, jossa:
* `a` on taulukko;
* `axis` on akseli, jonka mukaan lajitellaan (oletuksena viimeinen akseli (`-1`));
* `kind` on käytettävä lajittelualgoritmi (oletuksena `quicksort`).

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

## ndarray.sort()-menetelmä

Kuten jo mainittiin, `numpy.sort()`-funktio palauttaa lajitellun taulukon, mutta ei muuta **alkuperäistä** taulukkoa. Jos haluat muuttaa taulukkoa, sinun täytyy kirjoittaa `array = np.sort(array)`.

**NumPy** tarjoaa kuitenkin vaihtoehtoisesti `.sort()`-menetelmän, joka lajittelee taulukon **paikallaan** eikä palauta uutta taulukkoa (palauttaa `None`, eli ei palauta mitään). Sen syntaksi on samanlainen kuin `sort()`-funktion.

**Funktio** on itsenäinen koodilohko, joka suorittaa tietyn tehtävän ja jota voidaan kutsua suoraan. **Metodi** on funktio, joka liittyy olioon ja jota kutsutaan kyseiselle oliolle pisteoperaattorilla (`.`).

Huomio

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

Kun `.sort()`-metodia on kutsuttu, `array_1d` on lajiteltu **paikan päällä** ja sisältää nyt alkiot **nousevassa** järjestyksessä.


## Yksidimensionaalisten taulukoiden lajittelu laskevaan järjestykseen

Joskus voi olla tarpeen lajitella taulukko **laskevaan** järjestykseen. Kumpikaan `.sort()`-metodi tai `sort()`-funktio ei tue tätä toimintoa suoraan. Voit kuitenkin käyttää **viipalointia** asettamalla `step` arvoksi `-1` lajitellulle taulukolle:

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

Avaa Pythonin tärkeimmän numeerisen laskennan kirjaston, NumPyn, koko potentiaali. Tämä kattava kurssi on suunniteltu viemään sinut aloittelijan tasolta edistyneeksi NumPy-osaajaksi. Olitpa sitten data-analyytikko, insinööri, tutkija tai kehittäjä, NumPyn hallinta on olennaista tehokkaaseen datan käsittelyyn, tieteelliseen laskentaan ja koneoppimiseen.

Tutustu NumPyn käyttökohteisiin ja ymmärrä, miksi se on yksi suosituimmista kirjastoista numeeriseen laskentaan. Opiskele erilaisia tapoja luoda ja alustaa taulukoita erilaisten tietotarpeiden tehokkaaseen käsittelyyn.

Opi, kuinka NumPy-taulukoiden yksittäisiin alkioihin ja osajoukkoihin päästään käsiksi indeksimerkinnän avulla. Tutustu ehdollisen indeksoinnin käyttöön tietojen suodattamisessa ja puuttuvien arvojen hallinnassa tehokkaasti.

NumPy tarjoaa monia sisäänrakennettuja funktioita yleisten taulukko-operaatioiden suorittamiseen. Opi käyttämään näitä työkaluja datan muuntamiseen, aggregointiin ja analysointiin tehokkaasti ilman toistuvaa koodia.

Opi suorittamaan matemaattisia operaatioita tehokkaasti NumPy-taulukoilla. Sovella näitä operaatioita todellisten ongelmien ratkaisemiseen ja syvennä ymmärrystäsi siitä, miten vektorisoidut laskutoimitukset nopeuttavat numeerista analyysiä.

Taulukoiden lajittelu

numpy.sort()-funktio

ndarray.sort()-menetelmä

Yksidimensionaalisten taulukoiden lajittelu laskevaan järjestykseen

Ratkaisu