Summary  
Demonstrates how to sort two-dimensional arrays along different axes in ascending or descending order by using axis parameters and slicing techniques.

General domain of usage  
Numerical data analysis

Watch this video to see how to sort 2D arrays in NumPy. You'll learn how sorting works along different axes, how to sort each row or column, and how to sort arrays in descending order using slicing. This visual explanation will help you understand the key concepts and syntax discussed in this chapter.

Som du kan se, vil det at sende vores 2D-array direkte til funktionen `sort()` sortere hver 1D-array langs **akse 1** (som er standardindstillingen i et 2D-array). Hvis du angiver `axis=0`, sorteres hver 1D-array langs **akse 0** (hver kolonne).

Hvis du angiver `axis=None`, returneres et **sammenhængende sorteret 1D-array** med alle elementerne fra 2D-arrayet.

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

## Sortering af 2D-arrays i faldende rækkefølge

Ved sortering af 2D-arrays i **faldende rækkefølge** langs en given akse skal der bruges **to** slices: én **fuld** slice (`[:]`) og en anden med et negativt step (`[::-1]`). Positionen af slicen med det negative step skal svare til den **akse**, der sorteres langs.

Ved sortering langs **akse 0** kan der kun bruges en slice med negativt step, da denne allerede indekserer langs denne akse.

Bemærk

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

Lås op for det fulde potentiale af Pythons mest essentielle bibliotek til numerisk beregning, NumPy. Dette omfattende kursus er designet til at tage dig fra et begynderforståelse til et avanceret niveau af færdigheder i NumPy. Uanset om du er data scientist, ingeniør, forsker eller udvikler, er det afgørende at mestre NumPy for effektiv datamanipulation, videnskabelig beregning og maskinlæring.

Udforsk anvendelserne af NumPy og forstå, hvorfor det er et af de mest populære biblioteker til numerisk databehandling. Lær de forskellige måder at oprette og initialisere arrays på for effektivt at håndtere forskellige databehov.

Opdag, hvordan man får adgang til specifikke elementer og delmængder i NumPy-arrays ved hjælp af indeksnotation. Lær at anvende betinget indeksering til at filtrere data og håndtere manglende værdier effektivt.

NumPy tilbyder mange indbyggede funktioner til at udføre almindelige array-operationer. Lær, hvordan disse værktøjer kan anvendes til effektivt at transformere, aggregere og analysere data uden at skrive gentagen kode.

Lær at udføre matematiske operationer effektivt på NumPy-arrays. Anvend disse operationer til at løse virkelige problemer og opnå en dybere forståelse af, hvordan vektoriserede beregninger accelererer numerisk analyse.

Sortering af 2D-arrays

Sortering af 2D-arrays i faldende rækkefølge

Løsning