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

**Sortering** innebär att ordna elementen i en array i en viss ordning.

Definition

Denna operation är mycket användbar eftersom sökning i en **sorterad array** är mycket snabbare då effektiva algoritmer som **binärsökning** endast fungerar med sorterade arrayer.

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

**NumPy** har en inbyggd funktion `sort()` för att sortera element efter värde i stigande ordning. Returvärdet från denna funktion är en sorterad **NumPy**-array. Här är dess allmänna syntax: `numpy.sort(a, axis=-1, kind=None, order=None)`, där:
* `a` är en array;
* `axis` är axeln längs vilken sorteringen sker (sista axeln (`-1`) som standard);
* `kind` är sorteringsalgoritmen som används (`quicksort` som standard).

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

## ndarray.sort()-metod

Som redan nämnts returnerar funktionen `numpy.sort()` en sorterad array men ändrar inte **originalet**. Om du vill ändra arrayen måste du skriva `array = np.sort(array)`.

**NumPy** tillhandahåller dock en `.sort()`-metod som alternativ, vilken sorterar arrayen **på plats** och inte returnerar en ny array (den returnerar `None`, vilket betyder att den inte returnerar något). Syntaxen är liknande som för funktionen `sort()`.

En **funktion** är ett fristående kodblock som utför en specifik uppgift och kan anropas direkt. En **metod** är en funktion som är kopplad till ett objekt och anropas på det objektet med hjälp av `.`-operatorn.

Observera

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

Efter att ha anropat metoden `.sort()` sorterades `array_1d` **på plats** och innehåller nu element sorterade i **stigande** ordning.


## Sortering av endimensionella arrayer i fallande ordning

Ibland kan du vilja sortera en array i **fallande** ordning. Varken metoden `.sort()` eller funktionen `sort()` stöder denna funktionalitet direkt. Du kan dock enkelt använda **slicing** med `step` lika med `-1` på en sorterad 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

Lås upp den fulla potentialen hos Pythons mest grundläggande bibliotek för numerisk beräkning, NumPy. Denna omfattande kurs är utformad för att ta dig från nybörjarnivå till avancerad kompetens i NumPy. Oavsett om du är data scientist, ingenjör, forskare eller utvecklare är det avgörande att behärska NumPy för effektiv datamanipulering, vetenskapliga beräkningar och maskininlärning.

Utforska användningsområdena för NumPy och förstå varför det är ett av de mest populära biblioteken för numerisk beräkning. Lär dig de olika sätten att skapa och initiera arrayer för att effektivt hantera olika databehov.

Upptäck hur du får åtkomst till specifika element och delmängder i NumPy-arrayer med hjälp av indexnotation. Lär dig att använda villkorsbaserad indexering för att filtrera data och hantera saknade värden effektivt.

NumPy tillhandahåller många inbyggda funktioner för att utföra vanliga arrayoperationer. Lär dig hur du använder dessa verktyg för att effektivt transformera, aggregera och analysera data utan att skriva repetitiv kod.

Lär dig hur du utför matematiska operationer effektivt på NumPy-arrayer. Använd dessa operationer för att lösa verkliga problem och få en djupare förståelse för hur vektoriserade beräkningar påskyndar numerisk analys.

Sortering av Arrayer

numpy.sort() funktion

ndarray.sort()-metod

Sortering av endimensionella arrayer i fallande ordning

Lösning