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.

Kuten huomaat, pelkkä 2D-taulukon välittäminen `sort()`-funktiolle lajittelee jokaisen 1D-taulukon **akselin 1** (oletusvaihtoehto 2D-taulukossa) mukaan. Asettamalla `axis=0` lajittelee jokaisen 1D-taulukon **akselin 0** (jokainen sarake) mukaan.

Asettamalla `axis=None` palautetaan **yhtenäinen lajiteltu 1D-taulukko**, joka sisältää kaikki 2D-taulukon alkiot.

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

## Kaksiulotteisten taulukoiden lajittelu laskevaan järjestykseen

Kun lajittelet kaksiulotteisia taulukoita **laskevaan järjestykseen** tietyn akselin mukaan, sinun tulee käyttää **kahta** viipaletta: yksi **täysi** viipale (`[:]`) ja toinen, jossa on negatiivinen askel (`[::-1]`). Negatiivisen askeleen viipaleen sijainnin tulee vastata sitä **akselia**, jonka mukaan lajittelet.

Kun lajittelet **akselin 0** mukaan, voit käyttää vain viipaletta, jossa on negatiivinen askel, sillä se jo viittaa tähän akseliin.

Huomio

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

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ä.

2D-Taulukoiden Lajittelu

Kaksiulotteisten taulukoiden lajittelu laskevaan järjestykseen

Ratkaisu